Merge pull request #2682 in HDFFV/hdf5 from ~DEROBINS/hdf5_der:h5s_1_10 to hdf5_1_10

* commit '30c756decb6101704a925443d623301656ba60e4':
  Misc normalizations with develop.
  Added missing types to bin/trace after develop normalization.
  More normalization with H5S from develop.
  Continued normalization of H5S with develop.
  Normalization of H5MM and H5FL with develop. Adds the new stats calls.
  Further normalization of H5S with develop

33 files changed, 1340 insertions, 1245 deletions

diff --git a/bin/trace b/bin/trace
index 1a39891..ab7a92c 100755
--- a/bin/trace
+++ b/bin/trace
@@ -68,6 +68,7 @@ $Source = "";
                "unsigned"                   => "Iu",
                "unsigned int"               => "Iu",
                "uint32_t"                   => "Iu",
+               "uint64_t"                   => "UL",
                "H5I_type_t"                 => "It",
                "H5G_link_t"                 => "Ll", #Same as H5L_type_t now
                "H5L_type_t"                 => "Ll",
@@ -98,6 +99,7 @@ $Source = "";
                "unsigned long long"         => "UL",
                "void"                       => "x",
                "FILE"                       => "x",
+               "H5_alloc_stats_t"           => "x",
                "H5A_operator_t"             => "x",
                "H5A_operator1_t"            => "x",
                "H5A_operator2_t"            => "x",
diff --git a/src/H5.c b/src/H5.c
index ed09c7c..03fe535 100644
--- a/src/H5.c
+++ b/src/H5.c
@@ -547,6 +547,87 @@ done:
 
 
 /*-------------------------------------------------------------------------
+ * Function:	H5get_free_list_sizes
+ *
+ * Purpose:	Gets the current size of the different kinds of free lists that
+ *	the library uses to manage memory.  The free list sizes can be set with
+ *	H5set_free_list_limits and garbage collected with H5garbage_collect.
+ *      These lists are global for the entire library.
+ *
+ * Parameters:
+ *  size_t *reg_size;    OUT: The current size of all "regular" free list memory used
+ *  size_t *arr_size;    OUT: The current size of all "array" free list memory used
+ *  size_t *blk_size;    OUT: The current size of all "block" free list memory used
+ *  size_t *fac_size;    OUT: The current size of all "factory" free list memory used
+ *
+ * Return:	Success:	non-negative
+ *		Failure:	negative
+ *
+ * Programmer:  Quincey Koziol
+ *              Friday, March 6, 2020
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5get_free_list_sizes(size_t *reg_size, size_t *arr_size, size_t *blk_size,
+    size_t *fac_size)
+{
+    herr_t ret_value = SUCCEED;         /* Return value */
+
+    FUNC_ENTER_API(FAIL)
+    H5TRACE4("e", "*z*z*z*z", reg_size, arr_size, blk_size, fac_size);
+
+    /* Call the free list function to actually get the sizes */
+    if(H5FL_get_free_list_sizes(reg_size, arr_size, blk_size, fac_size) < 0)
+        HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGET, FAIL, "can't get garbage collection sizes")
+
+done:
+    FUNC_LEAVE_API(ret_value)
+}   /* end H5get_free_list_sizes() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5get_alloc_stats
+ *
+ * Purpose:	Gets the memory allocation statistics for the library, if the
+ *	--enable-memory-alloc-sanity-check option was given when building the
+ *      library.  Applications can check whether this option was enabled by
+ *	detecting if the 'H5_MEMORY_ALLOC_SANITY_CHECK' macro is defined.  This
+ *	option is enabled by default for debug builds of the library and
+ *	disabled by default for non-debug builds.  If the option is not enabled,
+ *	all the values returned with be 0.  These statistics are global for the
+ *	entire library, but don't include allocations from chunked dataset I/O
+ *	filters or non-native VOL connectors.
+ *
+ * Parameters:
+ *  H5_alloc_stats_t *stats;            OUT: Memory allocation statistics
+ *
+ * Return:	Success:	non-negative
+ *		Failure:	negative
+ *
+ * Programmer:  Quincey Koziol
+ *              Saturday, March 7, 2020
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5get_alloc_stats(H5_alloc_stats_t *stats)
+{
+    herr_t ret_value = SUCCEED;         /* Return value */
+
+    FUNC_ENTER_API(FAIL)
+    H5TRACE1("e", "*x", stats);
+
+    /* Call the internal allocation stat routine to get the values */
+    if(H5MM_get_alloc_stats(stats) < 0)
+        HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGET, FAIL, "can't get allocation stats")
+
+done:
+    FUNC_LEAVE_API(ret_value)
+}   /* end H5get_alloc_stats() */
+
+
+/*-------------------------------------------------------------------------
  * Function:    H5_debug_mask
  *
  * Purpose:     Set runtime debugging flags according to the string S.  The
diff --git a/src/H5Bdbg.c b/src/H5Bdbg.c
index f15fe79..d900852 100644
--- a/src/H5Bdbg.c
+++ b/src/H5Bdbg.c
@@ -13,11 +13,11 @@
 
 /*-------------------------------------------------------------------------
  *
- * Created:        H5Bdbg.c
- *            Dec 11 2008
- *            Quincey Koziol <koziol@hdfgroup.org>
+ * Created:         H5Bdbg.c
+ *                  Dec 11 2008
+ *                  Quincey Koziol
  *
- * Purpose:        Debugging routines for B-link tree package.
+ * Purpose:         Debugging routines for B-link tree package.
  *
  *-------------------------------------------------------------------------
  */
@@ -32,32 +32,30 @@
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"        /* Generic Functions            */
-#include "H5Bpkg.h"        /* B-link trees                */
-#include "H5Eprivate.h"        /* Error handling              */
-#include "H5MMprivate.h"    /* Memory management            */
-
+#include "H5private.h"          /* Generic Functions            */
+#include "H5Bpkg.h"             /* B-link trees                 */
+#include "H5Eprivate.h"         /* Error handling               */
+#include "H5MMprivate.h"        /* Memory management            */
 
 
+
 /*-------------------------------------------------------------------------
  * Function:    H5B_debug
  *
- * Purpose:    Prints debugging info about a B-tree.
+ * Purpose:     Prints debugging info about a B-tree.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Robb Matzke
- *        matzke@llnl.gov
- *        Aug  4 1997
+ * Programmer:  Robb Matzke
+ *              Aug  4 1997
  *
  *-------------------------------------------------------------------------
  */
 herr_t
-H5B_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth,
-    const H5B_class_t *type, void *udata)
+H5B_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth, const H5B_class_t *type, void *udata)
 {
-    H5B_t    *bt = NULL;
-    H5UC_t    *rc_shared;             /* Ref-counted shared info */
+    H5B_t       *bt = NULL;
+    H5UC_t      *rc_shared;             /* Ref-counted shared info */
     H5B_shared_t *shared;               /* Pointer to shared B-tree info */
     H5B_cache_ud_t cache_udata;         /* User-data for metadata cache callback */
     unsigned    u;                      /* Local index variable */
@@ -80,7 +78,7 @@ H5B_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth,
 
     /* Get shared info for B-tree */
     if(NULL == (rc_shared = (type->get_shared)(f, udata)))
-    HGOTO_ERROR(H5E_BTREE, H5E_CANTGET, FAIL, "can't retrieve B-tree's shared ref. count object")
+        HGOTO_ERROR(H5E_BTREE, H5E_CANTGET, FAIL, "can't retrieve B-tree's shared ref. count object")
     shared = (H5B_shared_t *)H5UC_GET_OBJ(rc_shared);
     HDassert(shared);
 
@@ -91,7 +89,7 @@ H5B_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth,
     cache_udata.type = type;
     cache_udata.rc_shared = rc_shared;
     if(NULL == (bt = (H5B_t *)H5AC_protect(f, H5AC_BT, addr, &cache_udata, H5AC__READ_ONLY_FLAG)))
-    HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree node")
+        HGOTO_ERROR(H5E_BTREE, H5E_CANTPROTECT, FAIL, "unable to load B-tree node")
 
     /*
      * Print the values.
@@ -126,26 +124,24 @@ H5B_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent, int fwidth,
      * Print the child addresses
      */
     for(u = 0; u < bt->nchildren; u++) {
-    HDfprintf(stream, "%*sChild %d...\n", indent, "", u);
-    HDfprintf(stream, "%*s%-*s %a\n", indent + 3, "", MAX(0, fwidth - 3),
-        "Address:", bt->child[u]);
+        HDfprintf(stream, "%*sChild %d...\n", indent, "", u);
+        HDfprintf(stream, "%*s%-*s %a\n", indent + 3, "", MAX(0, fwidth - 3),
+            "Address:", bt->child[u]);
 
         /* If there is a key debugging routine, use it to display the left & right keys */
-    if(type->debug_key) {
+        if(type->debug_key) {
             /* Decode the 'left' key & print it */
             HDfprintf(stream, "%*s%-*s\n", indent + 3, "", MAX(0, fwidth - 3),
                       "Left Key:");
             HDassert(H5B_NKEY(bt,shared,u));
-        (void)(type->debug_key)(stream, indent + 6, MAX(0, fwidth - 6),
-                H5B_NKEY(bt, shared, u), udata);
+            (void)(type->debug_key)(stream, indent + 6, MAX(0, fwidth - 6), H5B_NKEY(bt, shared, u), udata);
 
             /* Decode the 'right' key & print it */
             HDfprintf(stream, "%*s%-*s\n", indent + 3, "", MAX(0, fwidth - 3),
                       "Right Key:");
             HDassert(H5B_NKEY(bt, shared, u + 1));
-        (void)(type->debug_key)(stream, indent + 6, MAX (0, fwidth - 6),
-                H5B_NKEY(bt, shared, u + 1), udata);
-    } /* end if */
+            (void)(type->debug_key)(stream, indent + 6, MAX (0, fwidth - 6), H5B_NKEY(bt, shared, u + 1), udata);
+        } /* end if */
     } /* end for */
 
 done:
@@ -155,18 +151,18 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5B_debug() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5B__assert
  *
- * Purpose:    Verifies that the tree is structured correctly.
+ * Purpose:     Verifies that the tree is structured correctly.
  *
- * Return:    Success:    SUCCEED
+ * Return:      Success:    SUCCEED
  *
- *        Failure:    aborts if something is wrong.
+ *              Failure:    aborts if something is wrong.
  *
- * Programmer:    Robb Matzke
- *        Tuesday, November  4, 1997
+ * Programmer:  Robb Matzke
+ *              Tuesday, November  4, 1997
  *
  *-------------------------------------------------------------------------
  */
@@ -174,32 +170,32 @@ done:
 herr_t
 H5B__assert(H5F_t *f, haddr_t addr, const H5B_class_t *type, void *udata)
 {
-    H5B_t    *bt = NULL;
-    H5UC_t    *rc_shared;             /* Ref-counted shared info */
+    H5B_t       *bt = NULL;
+    H5UC_t      *rc_shared;             /* Ref-counted shared info */
     H5B_shared_t *shared;               /* Pointer to shared B-tree info */
     H5B_cache_ud_t cache_udata;         /* User-data for metadata cache callback */
-    int            ncell, cmp;
-    static int    ncalls = 0;
-    herr_t    status;
+    int         ncell, cmp;
+    static int  ncalls = 0;
+    herr_t      status;
     herr_t      ret_value = SUCCEED;    /* Return value */
 
     /* A queue of child data */
     struct child_t {
-    haddr_t            addr;
-    unsigned        level;
-    struct child_t           *next;
+        haddr_t             addr;
+        unsigned            level;
+        struct child_t      *next;
     } *head = NULL, *tail = NULL, *prev = NULL, *cur = NULL, *tmp = NULL;
 
     FUNC_ENTER_PACKAGE
 
     if(0 == ncalls++) {
-    if(H5DEBUG(B))
-        HDfprintf(H5DEBUG(B), "H5B: debugging B-trees (expensive)\n");
+        if(H5DEBUG(B))
+            HDfprintf(H5DEBUG(B), "H5B: debugging B-trees (expensive)\n");
     } /* end if */
 
     /* Get shared info for B-tree */
     if(NULL == (rc_shared = (type->get_shared)(f, udata)))
-    HGOTO_ERROR(H5E_BTREE, H5E_CANTGET, FAIL, "can't retrieve B-tree's shared ref. count object")
+        HGOTO_ERROR(H5E_BTREE, H5E_CANTGET, FAIL, "can't retrieve B-tree's shared ref. count object")
     shared = (H5B_shared_t *)H5UC_GET_OBJ(rc_shared);
     HDassert(shared);
 
@@ -228,60 +224,60 @@ H5B__assert(H5F_t *f, haddr_t addr, const H5B_class_t *type, void *udata)
      * test.
      */
     for(ncell = 0; cur; ncell++) {
-    bt = (H5B_t *)H5AC_protect(f, H5AC_BT, cur->addr, &cache_udata, H5AC__READ_ONLY_FLAG);
-    HDassert(bt);
-
-    /* Check node header */
-    HDassert(bt->level == cur->level);
-    if(cur->next && cur->next->level == bt->level)
-        HDassert(H5F_addr_eq(bt->right, cur->next->addr));
-    else
-        HDassert(!H5F_addr_defined(bt->right));
-    if(prev && prev->level == bt->level)
-        HDassert(H5F_addr_eq(bt->left, prev->addr));
-    else
-        HDassert(!H5F_addr_defined(bt->left));
-
-    if(cur->level > 0) {
+        bt = (H5B_t *)H5AC_protect(f, H5AC_BT, cur->addr, &cache_udata, H5AC__READ_ONLY_FLAG);
+        HDassert(bt);
+
+        /* Check node header */
+        HDassert(bt->level == cur->level);
+        if(cur->next && cur->next->level == bt->level)
+            HDassert(H5F_addr_eq(bt->right, cur->next->addr));
+        else
+            HDassert(!H5F_addr_defined(bt->right));
+        if(prev && prev->level == bt->level)
+            HDassert(H5F_addr_eq(bt->left, prev->addr));
+        else
+            HDassert(!H5F_addr_defined(bt->left));
+
+        if(cur->level > 0) {
             unsigned u;
 
-        for(u = 0; u < bt->nchildren; u++) {
-        /*
-        * Check that child nodes haven't already been seen.  If they
-        * have then the tree has a cycle.
-        */
-        for(tmp = head; tmp; tmp = tmp->next)
-            HDassert(H5F_addr_ne(tmp->addr, bt->child[u]));
-
-        /* Add the child node to the end of the queue */
-        tmp = (struct child_t *)H5MM_calloc(sizeof(struct child_t));
-        HDassert(tmp);
-        tmp->addr = bt->child[u];
-        tmp->level = bt->level - 1;
-        tail->next = tmp;
-        tail = tmp;
-
-        /* Check that the keys are monotonically increasing */
-        cmp = (type->cmp2)(H5B_NKEY(bt, shared, u), udata, H5B_NKEY(bt, shared, u + 1));
-        HDassert(cmp < 0);
-        } /* end for */
-    } /* end if */
-
-    /* Release node */
-    status = H5AC_unprotect(f, H5AC_BT, cur->addr, bt, H5AC__NO_FLAGS_SET);
-    HDassert(status >= 0);
+            for(u = 0; u < bt->nchildren; u++) {
+                /*
+                 * Check that child nodes haven't already been seen.  If they
+                 * have then the tree has a cycle.
+                 */
+                for(tmp = head; tmp; tmp = tmp->next)
+                    HDassert(H5F_addr_ne(tmp->addr, bt->child[u]));
+
+                /* Add the child node to the end of the queue */
+                tmp = (struct child_t *)H5MM_calloc(sizeof(struct child_t));
+                HDassert(tmp);
+                tmp->addr = bt->child[u];
+                tmp->level = bt->level - 1;
+                tail->next = tmp;
+                tail = tmp;
+
+                /* Check that the keys are monotonically increasing */
+                cmp = (type->cmp2)(H5B_NKEY(bt, shared, u), udata, H5B_NKEY(bt, shared, u + 1));
+                HDassert(cmp < 0);
+            } /* end for */
+        } /* end if */
+
+        /* Release node */
+        status = H5AC_unprotect(f, H5AC_BT, cur->addr, bt, H5AC__NO_FLAGS_SET);
+        HDassert(status >= 0);
         bt = NULL;    /* Make certain future references will be caught */
 
-    /* Advance current location in queue */
-    prev = cur;
-    cur = cur->next;
+        /* Advance current location in queue */
+        prev = cur;
+        cur = cur->next;
     } /* end for */
 
     /* Free all entries from queue */
     while(head) {
-    tmp = head->next;
-    H5MM_xfree(head);
-    head = tmp;
+        tmp = head->next;
+        H5MM_xfree(head);
+        head = tmp;
     } /* end while */
 
 done:
diff --git a/src/H5Dbtree.c b/src/H5Dbtree.c
index b3a9905..098e01b 100644
--- a/src/H5Dbtree.c
+++ b/src/H5Dbtree.c
@@ -39,6 +39,7 @@
 #include "H5FLprivate.h"	/* Free Lists                           */
 #include "H5Iprivate.h"		/* IDs			  		*/
 #include "H5MFprivate.h"	/* File space management		*/
+#include "H5MMprivate.h"	/* Memory management			*/
 #include "H5Oprivate.h"		/* Object headers		  	*/
 #include "H5Sprivate.h"         /* Dataspaces                           */
 #include "H5VMprivate.h"		/* Vector and array functions		*/
@@ -252,7 +253,7 @@ H5D__btree_get_shared(const H5F_t H5_ATTR_UNUSED *f, const void *_udata)
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5D__btree_new_node(H5F_t *f, H5B_ins_t op, void *_lt_key, void *_udata,
+H5D__btree_new_node(H5F_t H5_ATTR_NDEBUG_UNUSED *f, H5B_ins_t op, void *_lt_key, void *_udata,
     void *_rt_key, haddr_t *addr_p/*out*/)
 {
     H5D_btree_key_t	*lt_key = (H5D_btree_key_t *) _lt_key;
@@ -535,7 +536,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static H5B_ins_t
-H5D__btree_insert(H5F_t *f, haddr_t addr, void *_lt_key, hbool_t *lt_key_changed,
+H5D__btree_insert(H5F_t H5_ATTR_NDEBUG_UNUSED *f, haddr_t H5_ATTR_NDEBUG_UNUSED addr, void *_lt_key, hbool_t *lt_key_changed,
     void *_md_key, void *_udata, void *_rt_key, hbool_t H5_ATTR_UNUSED *rt_key_changed,
     haddr_t *new_node_p/*out*/)
 {
@@ -685,13 +686,12 @@ H5D__btree_decode_key(const H5B_shared_t *shared, const uint8_t *raw, void *_key
     /* decode */
     UINT32DECODE(raw, key->nbytes);
     UINT32DECODE(raw, key->filter_mask);
-    for(u = 0; u < layout->ndims; u++)
-    {
-        if (layout->dim[u] == 0)
+    for(u = 0; u < layout->ndims; u++) {
+        if(layout->dim[u] == 0)
             HGOTO_ERROR(H5E_DATASET, H5E_BADVALUE, FAIL, "chunk size must be > 0, dim = %u ", u)
 
         /* Retrieve coordinate offset */
-	    UINT64DECODE(raw, tmp_offset);
+        UINT64DECODE(raw, tmp_offset);
         HDassert(0 == (tmp_offset % layout->dim[u]));
 
         /* Convert to a scaled offset */
@@ -943,7 +943,7 @@ H5D__btree_idx_create(const H5D_chk_idx_info_t *idx_info)
 
     /* Create the v1 B-tree for the chunk index */
     if(H5B_create(idx_info->f, H5B_BTREE, &udata, &(idx_info->storage->idx_addr)/*out*/) < 0)
-	HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't create B-tree")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't create B-tree")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
diff --git a/src/H5Dbtree2.c b/src/H5Dbtree2.c
index 23d58ad..ccb786b 100644
--- a/src/H5Dbtree2.c
+++ b/src/H5Dbtree2.c
@@ -32,6 +32,7 @@
 #include "H5Dpkg.h"		/* Datasets				*/
 #include "H5FLprivate.h"	/* Free Lists                           */
 #include "H5MFprivate.h"     	/* File space management                */
+#include "H5MMprivate.h"	/* Memory management			*/
 #include "H5VMprivate.h"	/* Vector and array functions		*/
 
 
@@ -203,9 +204,9 @@ const H5B2_class_t H5D_BT2_FILT[1] = {{	/* B-tree class information */
 
 /* Declare a free list to manage the H5D_bt2_ctx_t struct */
 H5FL_DEFINE_STATIC(H5D_bt2_ctx_t);
-/* Declare a free list to manage the page elements */
-H5FL_BLK_DEFINE(chunk_dim);
 
+/* Declare a free list to manage the page elements */
+H5FL_ARR_DEFINE_STATIC(uint32_t, H5O_LAYOUT_NDIMS);
 
 
 
@@ -246,7 +247,7 @@ H5D__bt2_crt_context(void *_udata)
     ctx->ndims = udata->ndims;
 
     /* Set up the "local" information for this dataset's chunk dimension sizes */
-    if(NULL == (my_dim = (uint32_t *)H5FL_BLK_MALLOC(chunk_dim, H5O_LAYOUT_NDIMS * sizeof(uint32_t))))
+    if(NULL == (my_dim = (uint32_t *)H5FL_ARR_MALLOC(uint32_t, H5O_LAYOUT_NDIMS)))
         HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, NULL, "can't allocate chunk dims")
     H5MM_memcpy(my_dim, udata->dim, H5O_LAYOUT_NDIMS * sizeof(uint32_t));
     ctx->dim = my_dim;
@@ -291,7 +292,7 @@ H5D__bt2_dst_context(void *_ctx)
 
     /* Free array for chunk dimension sizes */
     if(ctx->dim)
-	(void)H5FL_BLK_FREE(chunk_dim, ctx->dim);
+        H5FL_ARR_FREE(uint32_t, ctx->dim);
     /* Release callback context */
     ctx = H5FL_FREE(H5D_bt2_ctx_t, ctx);
 
@@ -1547,7 +1548,7 @@ H5D__bt2_idx_dest(const H5D_chk_idx_info_t *idx_info)
             HGOTO_ERROR(H5E_DATASET, H5E_CANTOPENOBJ, FAIL, "can't patch v2 B-tree file pointer")
 
         /* Close v2 B-tree */
-	if(H5B2_close(idx_info->storage->u.btree2.bt2) < 0)
+        if(H5B2_close(idx_info->storage->u.btree2.bt2) < 0)
             HGOTO_ERROR(H5E_DATASET, H5E_CANTCLOSEOBJ, FAIL, "can't close v2 B-tree")
         idx_info->storage->u.btree2.bt2 = NULL;
     } /* end if */
diff --git a/src/H5Dchunk.c b/src/H5Dchunk.c
index 0f7bccf..36c47d0 100644
--- a/src/H5Dchunk.c
+++ b/src/H5Dchunk.c
@@ -724,15 +724,18 @@ H5D__chunk_set_info_real(H5O_layout_chunk_t *layout, unsigned ndims,
 
     /* Compute the # of chunks in dataset dimensions */
     for(u = 0, layout->nchunks = 1, layout->max_nchunks = 1; u < ndims; u++) {
-        /* Sanity check */
-        HDassert(layout->dim[u] > 0);
-
         /* Round up to the next integer # of chunks, to accommodate partial chunks */
         layout->chunks[u] = ((curr_dims[u] + layout->dim[u]) - 1) / layout->dim[u];
         if(H5S_UNLIMITED == max_dims[u])
             layout->max_chunks[u] = H5S_UNLIMITED;
         else
+        {
+            /* Sanity check */
+            if(layout->dim[u] == 0)
+                HGOTO_ERROR(H5E_DATASET, H5E_BADVALUE, FAIL, "dimension size must be > 0, dim = %u ", u)
+
             layout->max_chunks[u] = ((max_dims[u] + layout->dim[u]) - 1) / layout->dim[u];
+        }
 
         /* Accumulate the # of chunks */
         layout->nchunks *= layout->chunks[u];
@@ -1126,21 +1129,19 @@ H5D__chunk_io_init(const H5D_io_info_t *io_info, const H5D_type_info_t *type_inf
     if((file_space_normalized = H5S_hyper_normalize_offset((H5S_t *)file_space, old_offset)) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "unable to normalize selection")
 
-    /* Decide the number of chunks in each dimension*/
-    for(u = 0; u < f_ndims; u++) {
+    /* Decide the number of chunks in each dimension */
+    for(u = 0; u < f_ndims; u++)
         /* Keep the size of the chunk dimensions as hsize_t for various routines */
         fm->chunk_dim[u] = fm->layout->u.chunk.dim[u];
-    } /* end for */
 
 #ifdef H5_HAVE_PARALLEL
     /* Calculate total chunk in file map*/
     fm->select_chunk = NULL;
     if(io_info->using_mpi_vfd) {
         H5_CHECK_OVERFLOW(fm->layout->u.chunk.nchunks, hsize_t, size_t);
-        if(fm->layout->u.chunk.nchunks) {
+        if(fm->layout->u.chunk.nchunks)
             if(NULL == (fm->select_chunk = (H5D_chunk_info_t **)H5MM_calloc((size_t)fm->layout->u.chunk.nchunks * sizeof(H5D_chunk_info_t *))))
                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate chunk info")
-        }
     } /* end if */
 #endif /* H5_HAVE_PARALLEL */
 
@@ -1182,10 +1183,9 @@ H5D__chunk_io_init(const H5D_io_info_t *io_info, const H5D_type_info_t *type_inf
         HDassert(fm->single_space);
 
         /* Allocate the single chunk information */
-        if(NULL == dataset->shared->cache.chunk.single_chunk_info) {
+        if(NULL == dataset->shared->cache.chunk.single_chunk_info)
             if(NULL == (dataset->shared->cache.chunk.single_chunk_info = H5FL_MALLOC(H5D_chunk_info_t)))
                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate chunk info")
-        } /* end if */
         fm->single_chunk_info = dataset->shared->cache.chunk.single_chunk_info;
         HDassert(fm->single_chunk_info);
 
@@ -1200,10 +1200,9 @@ H5D__chunk_io_init(const H5D_io_info_t *io_info, const H5D_type_info_t *type_inf
         hbool_t sel_hyper_flag;         /* Whether file selection is a hyperslab */
 
         /* Initialize skip list for chunk selections */
-        if(NULL == dataset->shared->cache.chunk.sel_chunks) {
+        if(NULL == dataset->shared->cache.chunk.sel_chunks)
             if(NULL == (dataset->shared->cache.chunk.sel_chunks = H5SL_create(H5SL_TYPE_HSIZE, NULL)))
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTCREATE, FAIL, "can't create skip list for chunk selections")
-        } /* end if */
         fm->sel_chunks = dataset->shared->cache.chunk.sel_chunks;
         HDassert(fm->sel_chunks);
 
@@ -1272,7 +1271,7 @@ H5D__chunk_io_init(const H5D_io_info_t *io_info, const H5D_type_info_t *type_inf
         } /* end else */
 
         /* Build the memory selection for each chunk */
-        if(sel_hyper_flag && H5S_select_shape_same(file_space, mem_space) == TRUE) {
+        if(sel_hyper_flag && H5S_SELECT_SHAPE_SAME(file_space, mem_space) == TRUE) {
             /* Reset chunk template information */
             fm->mchunk_tmpl = NULL;
 
@@ -1298,10 +1297,9 @@ H5D__chunk_io_init(const H5D_io_info_t *io_info, const H5D_type_info_t *type_inf
             fm->mchunk_tmpl = tmp_mspace;
 
             /* Create temporary datatypes for selection iteration */
-            if(!file_type) {
+            if(!file_type)
                 if(NULL == (file_type = H5T_copy(dataset->shared->type, H5T_COPY_ALL)))
                     HGOTO_ERROR(H5E_DATATYPE, H5E_CANTCOPY, FAIL, "unable to copy file datatype")
-            } /* end if */
 
             /* Create selection iterator for memory selection */
             if(0 == (elmt_size = H5T_get_size(mem_type)))
@@ -1404,7 +1402,7 @@ H5D__chunk_mem_alloc(size_t size, const H5O_pline_t *pline)
 /*-------------------------------------------------------------------------
  * Function:    H5D__chunk_mem_xfree
  *
- * Purpose:    Free space for a chunk in memory.  This routine allocates
+ * Purpose:    Free space for a chunk in memory.  This routine releases
  *              memory space for non-filtered chunks from a block free list
  *              and uses malloc()/free() for filtered chunks.
  *
@@ -1565,7 +1563,8 @@ H5D__create_chunk_map_single(H5D_chunk_map_t *fm, const H5D_io_info_t
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "unable to copy file selection")
 
     /* Move selection back to have correct offset in chunk */
-    H5S_SELECT_ADJUST_U(fm->single_space, coords);
+    if(H5S_SELECT_ADJUST_U(fm->single_space, coords) < 0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't adjust chunk selection")
 
 #ifdef H5_HAVE_PARALLEL
     /* store chunk selection information */
@@ -1626,7 +1625,7 @@ H5D__create_chunk_file_map_hyper(H5D_chunk_map_t *fm, const H5D_io_info_t
     FUNC_ENTER_STATIC
 
     /* Sanity check */
-    HDassert(fm->f_ndims>0);
+    HDassert(fm->f_ndims > 0);
 
     /* Get number of elements selected in file */
     sel_points = fm->nelmts;
@@ -1652,7 +1651,7 @@ H5D__create_chunk_file_map_hyper(H5D_chunk_map_t *fm, const H5D_io_info_t
     while(sel_points) {
         /* Check for intersection of temporary chunk and file selection */
         /* (Casting away const OK - QAK) */
-        if(TRUE == H5S_hyper_intersect_block((H5S_t *)fm->file_space, coords, end)) {
+        if(TRUE == H5S_hyper_intersect_block(fm->file_space, coords, end)) {
             H5S_t *tmp_fchunk;                  /* Temporary file dataspace */
             H5D_chunk_info_t *new_chunk_info;   /* chunk information to insert into skip list */
             hsize_t    chunk_points;            /* Number of elements in chunk selection */
@@ -1680,12 +1679,13 @@ H5D__create_chunk_file_map_hyper(H5D_chunk_map_t *fm, const H5D_io_info_t
             } /* end if */
 
             /* Move selection back to have correct offset in chunk */
-            H5S_SELECT_ADJUST_U(tmp_fchunk, coords);
+            if(H5S_SELECT_ADJUST_U(tmp_fchunk, coords) < 0)
+                HGOTO_ERROR(H5E_DATASET, H5E_CANTSELECT, FAIL, "can't adjust chunk selection")
 
             /* Add temporary chunk to the list of chunks */
 
             /* Allocate the file & memory chunk information */
-            if (NULL==(new_chunk_info = H5FL_MALLOC(H5D_chunk_info_t))) {
+            if(NULL == (new_chunk_info = H5FL_MALLOC(H5D_chunk_info_t))) {
                 (void)H5S_close(tmp_fchunk);
                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate chunk info")
             } /* end if */
@@ -1693,7 +1693,7 @@ H5D__create_chunk_file_map_hyper(H5D_chunk_map_t *fm, const H5D_io_info_t
             /* Initialize the chunk information */
 
             /* Set the chunk index */
-            new_chunk_info->index=chunk_index;
+            new_chunk_info->index = chunk_index;
 
 #ifdef H5_HAVE_PARALLEL
             /* Store chunk selection information, for multi-chunk I/O */
@@ -1706,16 +1706,13 @@ H5D__create_chunk_file_map_hyper(H5D_chunk_map_t *fm, const H5D_io_info_t
             new_chunk_info->fspace_shared = FALSE;
 
             /* Set the memory chunk dataspace */
-            new_chunk_info->mspace=NULL;
+            new_chunk_info->mspace = NULL;
             new_chunk_info->mspace_shared = FALSE;
 
             /* Copy the chunk's scaled coordinates */
-        H5MM_memcpy(new_chunk_info->scaled, scaled, sizeof(hsize_t) * fm->f_ndims);
+            H5MM_memcpy(new_chunk_info->scaled, scaled, sizeof(hsize_t) * fm->f_ndims);
             new_chunk_info->scaled[fm->f_ndims] = 0;
 
-            /* Copy the chunk's scaled coordinates */
-        H5MM_memcpy(new_chunk_info->scaled, scaled, sizeof(hsize_t) * fm->f_ndims);
-
             /* Insert the new chunk into the skip list */
             if(H5SL_insert(fm->sel_chunks, new_chunk_info, &new_chunk_info->index) < 0) {
                 H5D__free_chunk_info(new_chunk_info, NULL, NULL);
@@ -1723,8 +1720,7 @@ H5D__create_chunk_file_map_hyper(H5D_chunk_map_t *fm, const H5D_io_info_t
             } /* end if */
 
             /* Get number of elements selected in chunk */
-            if((chunk_points = H5S_GET_SELECT_NPOINTS(tmp_fchunk)) < 0)
-                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't get file selection # of elements")
+            chunk_points = H5S_GET_SELECT_NPOINTS(tmp_fchunk);
             H5_CHECKED_ASSIGN(new_chunk_info->chunk_points, uint32_t, chunk_points, hsize_t);
 
             /* Decrement # of points left in file selection */
@@ -1739,12 +1735,12 @@ H5D__create_chunk_file_map_hyper(H5D_chunk_map_t *fm, const H5D_io_info_t
         chunk_index++;
 
         /* Set current increment dimension */
-        curr_dim=(int)fm->f_ndims-1;
+        curr_dim = (int)fm->f_ndims - 1;
 
         /* Increment chunk location in fastest changing dimension */
         H5_CHECK_OVERFLOW(fm->chunk_dim[curr_dim],hsize_t,hssize_t);
-        coords[curr_dim]+=fm->chunk_dim[curr_dim];
-        end[curr_dim]+=fm->chunk_dim[curr_dim];
+        coords[curr_dim] += fm->chunk_dim[curr_dim];
+        end[curr_dim] += fm->chunk_dim[curr_dim];
         scaled[curr_dim]++;
 
         /* Bring chunk location back into bounds, if necessary */
@@ -1794,12 +1790,12 @@ static herr_t
 H5D__create_chunk_mem_map_hyper(const H5D_chunk_map_t *fm)
 {
     H5SL_node_t *curr_node;                 /* Current node in skip list */
-    hsize_t    file_sel_start[H5O_LAYOUT_NDIMS];    /* Offset of low bound of file selection */
-    hsize_t    file_sel_end[H5O_LAYOUT_NDIMS];  /* Offset of high bound of file selection */
-    hsize_t    mem_sel_start[H5O_LAYOUT_NDIMS]; /* Offset of low bound of file selection */
-    hsize_t    mem_sel_end[H5O_LAYOUT_NDIMS];   /* Offset of high bound of file selection */
-    hssize_t adjust[H5O_LAYOUT_NDIMS];      /* Adjustment to make to all file chunks */
-    hssize_t chunk_adjust[H5O_LAYOUT_NDIMS];  /* Adjustment to make to a particular chunk */
+    hsize_t     file_sel_start[H5S_MAX_RANK];    /* Offset of low bound of file selection */
+    hsize_t     file_sel_end[H5S_MAX_RANK]; /* Offset of high bound of file selection */
+    hsize_t     mem_sel_start[H5S_MAX_RANK]; /* Offset of low bound of file selection */
+    hsize_t     mem_sel_end[H5S_MAX_RANK];  /* Offset of high bound of file selection */
+    hssize_t    adjust[H5S_MAX_RANK];       /* Adjustment to make to all file chunks */
+    hssize_t    chunk_adjust[H5S_MAX_RANK];  /* Adjustment to make to a particular chunk */
     unsigned    u;                          /* Local index variable */
     herr_t    ret_value = SUCCEED;        /* Return value */
 
@@ -1813,7 +1809,7 @@ H5D__create_chunk_mem_map_hyper(const H5D_chunk_map_t *fm)
         H5D_chunk_info_t *chunk_info;   /* Pointer to chunk information */
 
         /* Get the node */
-        curr_node=H5SL_first(fm->sel_chunks);
+        curr_node = H5SL_first(fm->sel_chunks);
 
         /* Get pointer to chunk's information */
         chunk_info = (H5D_chunk_info_t *)H5SL_item(curr_node);
@@ -1836,15 +1832,15 @@ H5D__create_chunk_mem_map_hyper(const H5D_chunk_map_t *fm)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't get file selection bound info")
 
         /* Calculate the adjustment for memory selection from file selection */
-        HDassert(fm->m_ndims==fm->f_ndims);
-        for(u=0; u<fm->f_ndims; u++) {
-            H5_CHECK_OVERFLOW(file_sel_start[u],hsize_t,hssize_t);
-            H5_CHECK_OVERFLOW(mem_sel_start[u],hsize_t,hssize_t);
-            adjust[u]=(hssize_t)file_sel_start[u]-(hssize_t)mem_sel_start[u];
+        HDassert(fm->m_ndims == fm->f_ndims);
+        for(u = 0; u < fm->f_ndims; u++) {
+            H5_CHECK_OVERFLOW(file_sel_start[u], hsize_t, hssize_t);
+            H5_CHECK_OVERFLOW(mem_sel_start[u], hsize_t, hssize_t);
+            adjust[u] = (hssize_t)file_sel_start[u] - (hssize_t)mem_sel_start[u];
         } /* end for */
 
         /* Iterate over each chunk in the chunk list */
-        curr_node=H5SL_first(fm->sel_chunks);
+        curr_node = H5SL_first(fm->sel_chunks);
         while(curr_node) {
             H5D_chunk_info_t *chunk_info;   /* Pointer to chunk information */
 
@@ -1879,11 +1875,11 @@ H5D__create_chunk_mem_map_hyper(const H5D_chunk_map_t *fm)
             } /* end for */
 
             /* Adjust the selection */
-            if(H5S_hyper_adjust_s(chunk_info->mspace, chunk_adjust) < 0) /*lint !e772 The chunk_adjust array will always be initialized */
+            if(H5S_hyper_adjust_s(chunk_info->mspace, chunk_adjust) < 0)
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "unable to adjust selection")
 
             /* Get the next chunk node in the skip list */
-            curr_node=H5SL_next(curr_node);
+            curr_node = H5SL_next(curr_node);
         } /* end while */
     } /* end else */
 
@@ -2052,11 +2048,10 @@ H5D__chunk_mem_cb(void H5_ATTR_UNUSED *elem, const H5T_t H5_ATTR_UNUSED *type, u
             HGOTO_ERROR(H5E_DATASPACE, H5E_NOTFOUND, FAIL, "can't locate chunk in skip list")
 
         /* Check if the chunk already has a memory space */
-        if(NULL == chunk_info->mspace) {
+        if(NULL == chunk_info->mspace)
             /* Copy the template memory chunk dataspace */
             if(NULL == (chunk_info->mspace = H5S_copy(fm->mchunk_tmpl, FALSE, FALSE)))
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "unable to copy file space")
-        } /* end else */
 
         /* Update the "last chunk seen" information */
         fm->last_index = chunk_index;
@@ -5236,7 +5231,7 @@ H5D__chunk_prune_by_extent(H5D_t *dset, const hsize_t *old_dim)
                 } /* end if */
                 else
                     dims_outside_fill[u] = FALSE;
-        } /* end if */
+        } /* end else */
 
         carry = FALSE;
         while(!carry) {
@@ -5690,9 +5685,8 @@ H5D__chunk_copy_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
     /* Check for an edge chunk that is not filtered */
     if(pline && pline->nused) {
         must_filter = TRUE;
-        if( (udata->common.layout->flags & H5O_LAYOUT_CHUNK_DONT_FILTER_PARTIAL_BOUND_CHUNKS) &&
-            (H5D__chunk_is_partial_edge_chunk(udata->dset_ndims, udata->common.layout->dim,
-                                              chunk_rec->scaled, udata->dset_dims)) )
+        if((udata->common.layout->flags & H5O_LAYOUT_CHUNK_DONT_FILTER_PARTIAL_BOUND_CHUNKS) &&
+            H5D__chunk_is_partial_edge_chunk(udata->dset_ndims, udata->common.layout->dim, chunk_rec->scaled, udata->dset_dims))
             must_filter = FALSE;
     }
 
@@ -6816,7 +6810,7 @@ H5D__chunk_format_convert(H5D_t *dset, H5D_chk_idx_info_t *idx_info, H5D_chk_idx
     udata.dset_ndims = dset->shared->ndims;
     udata.dset_dims = dset->shared->curr_dims;
 
-    /*  terate over the chunks in the current index and insert the chunk addresses into version 1 B-tree index */
+    /* Iterate over the chunks in the current index and insert the chunk addresses into version 1 B-tree index */
     if((idx_info->storage->ops->iterate)(idx_info, H5D__chunk_format_convert_cb, &udata) < 0)
     HGOTO_ERROR(H5E_DATASET, H5E_BADITER, FAIL, "unable to iterate over chunk index to chunk info")
 
@@ -6878,8 +6872,8 @@ H5D__get_num_chunks(const H5D_t *dset, const H5S_t H5_ATTR_UNUSED *space, hsize_
 {
     H5D_chk_idx_info_t idx_info;                /* Chunked index info */
     hsize_t            num_chunks = 0;          /* Number of written chunks */
-    H5D_rdcc_ent_t    *ent;                     /* Cache entry  */
-    const H5D_rdcc_t  *rdcc = NULL;             /* Raw data chunk cache */
+    H5D_rdcc_ent_t     *ent;                    /* Cache entry  */
+    const H5D_rdcc_t   *rdcc = NULL;            /* Raw data chunk cache */
     herr_t             ret_value = SUCCEED;     /* Return value */
 
     FUNC_ENTER_PACKAGE_TAG(dset->oloc.addr)
@@ -6889,8 +6883,7 @@ H5D__get_num_chunks(const H5D_t *dset, const H5S_t H5_ATTR_UNUSED *space, hsize_
     HDassert(space);
     HDassert(nchunks);
 
-    /* Get the raw data chunk cache */
-    rdcc = &(dset->shared->cache.chunk);
+    rdcc = &(dset->shared->cache.chunk); /* raw data chunk cache */
     HDassert(rdcc);
 
     /* Search for cached chunks that haven't been written out */
@@ -6906,28 +6899,27 @@ H5D__get_num_chunks(const H5D_t *dset, const H5S_t H5_ATTR_UNUSED *space, hsize_
     idx_info.storage = &dset->shared->layout.storage.u.chunk;
 
     /* If the dataset is not written, number of chunks will be 0 */
-    if(!H5F_addr_defined(idx_info.storage->idx_addr)) {
+    if(!H5F_addr_defined(idx_info.storage->idx_addr))
         *nchunks = 0;
-        HGOTO_DONE(SUCCEED);
-    }
     else {
-    /* Iterate over the allocated chunks */
-    if((dset->shared->layout.storage.u.chunk.ops->iterate)(&idx_info, H5D__get_num_chunks_cb, &num_chunks) < 0)
-        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "unable to retrieve allocated chunk information from index")
-    *nchunks = num_chunks;
+        /* Iterate over the allocated chunks */
+        if((dset->shared->layout.storage.u.chunk.ops->iterate)(&idx_info, H5D__get_num_chunks_cb, &num_chunks) < 0)
+            HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "unable to retrieve allocated chunk information from index")
+        *nchunks = num_chunks;
     }
 
 done:
-    FUNC_LEAVE_NOAPI(ret_value)
+    FUNC_LEAVE_NOAPI_TAG(ret_value)
 } /* end H5D__get_num_chunks() */
 
 
 /*-------------------------------------------------------------------------
  * Function:    H5D__get_chunk_info_cb
  *
- * Purpose:     Get the chunk info of the desired chunk, given by its index.
+ * Purpose:     Get the chunk info of the queried chunk, given by its index.
  *
  * Return:      Success:    H5_ITER_CONT or H5_ITER_STOP
+ *                          H5_ITER_STOP indicates the queried chunk is found
  *              Failure:    Negative (H5_ITER_ERROR)
  *
  * Programmer:  Binh-Minh Ribler
@@ -6939,8 +6931,7 @@ static int
 H5D__get_chunk_info_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
 {
     H5D_chunk_info_iter_ud_t *chunk_info = (H5D_chunk_info_iter_ud_t *)_udata;
-    hsize_t            ii = 0;            /* Dimension index */
-    int ret_value = H5_ITER_CONT;         /* Callback return value */
+    int     ret_value = H5_ITER_CONT;   /* Callback return value */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -6948,19 +6939,22 @@ H5D__get_chunk_info_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
     HDassert(chunk_rec);
     HDassert(chunk_info);
 
-    /* If this is the desired chunk, retrieve its info and stop iterating */
-    if (chunk_info->curr_idx == chunk_info->chunk_idx) {
+    /* If this is the queried chunk, retrieve its info and stop iterating */
+    if(chunk_info->curr_idx == chunk_info->chunk_idx) {
+        hsize_t ii = 0;                     /* Dimension index */
+
+        /* Copy info */
         chunk_info->filter_mask = chunk_rec->filter_mask;
         chunk_info->chunk_addr = chunk_rec->chunk_addr;
         chunk_info->nbytes = chunk_rec->nbytes;
-        for (ii = 0; ii < chunk_info->ndims; ii++)
+        for(ii = 0; ii < chunk_info->ndims; ii++)
             chunk_info->scaled[ii] = chunk_rec->scaled[ii];
         chunk_info->found = TRUE;
 
         /* Stop iterating */
         ret_value = H5_ITER_STOP;
     }
-    /* Iterate the next chunk */
+    /* Go to the next chunk */
     else
         chunk_info->curr_idx++;
 
@@ -7150,18 +7144,18 @@ H5D__get_chunk_info_by_coord(const H5D_t *dset, const hsize_t *offset, unsigned*
         if(H5D__chunk_flush_entry(dset, ent, FALSE) < 0)
             HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "cannot flush indexed storage buffer")
 
+    /* Set addr & size for when dset is not written or queried chunk is not found */
+    if(addr)
+        *addr = HADDR_UNDEF;
+    if(size)
+        *size = 0;
+
     /* Compose chunked index info struct */
     idx_info.f = dset->oloc.file;
     idx_info.pline = &dset->shared->dcpl_cache.pline;
     idx_info.layout = &dset->shared->layout.u.chunk;
     idx_info.storage = &dset->shared->layout.storage.u.chunk;
 
-    /* Set addr & size for when dset is not written or queried chunk is not found */
-    if (addr)
-        *addr = HADDR_UNDEF;
-    if (size)
-        *size = 0;
-
     /* If the dataset is not written, return without errors */
     if(!H5F_addr_defined(idx_info.storage->idx_addr)) {
         HGOTO_DONE(SUCCEED);
diff --git a/src/H5Ddbg.c b/src/H5Ddbg.c
index 347e34c..7220868 100644
--- a/src/H5Ddbg.c
+++ b/src/H5Ddbg.c
@@ -21,11 +21,11 @@
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"		/* Generic Functions			*/
-#include "H5CXprivate.h"        /* API Contexts                         */
-#include "H5Dpkg.h"		/* Datasets 				*/
-#include "H5Eprivate.h"		/* Error handling		  	*/
-#include "H5Iprivate.h"		/* IDs			  		*/
+#include "H5private.h"          /* Generic Functions                        */
+#include "H5CXprivate.h"        /* API Contexts                             */
+#include "H5Dpkg.h"             /* Datasets                                 */
+#include "H5Eprivate.h"         /* Error handling                           */
+#include "H5Iprivate.h"         /* IDs                                      */
 
 
 /****************/
@@ -60,17 +60,12 @@
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Ddebug
+ * Function:    H5Ddebug
  *
- * Purpose:	Prints various information about a dataset.  This function is
- *		not to be documented in the API at this time.
+ * Purpose:     Prints various information about a dataset.  This function is
+ *              not to be documented in the API at this time.
  *
- * Return:	Success:	Non-negative
- *
- *		Failure:	Negative
- *
- * Programmer:	Robb Matzke
- *              Wednesday, April 28, 1999
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
@@ -85,13 +80,13 @@ H5Ddebug(hid_t dset_id)
 
     /* Check args */
     if(NULL == (dset = (H5D_t *)H5I_object_verify(dset_id, H5I_DATASET)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataset")
 
     /* Print B-tree information */
     if(H5D_CHUNKED == dset->shared->layout.type)
-	(void)H5D__chunk_dump_index(dset, stdout);
+        (void)H5D__chunk_dump_index(dset, stdout);
     else if(H5D_CONTIGUOUS == dset->shared->layout.type)
-	HDfprintf(stdout, "    %-10s %a\n", "Address:", dset->shared->layout.storage.u.contig.addr);
+        HDfprintf(stdout, "    %-10s %a\n", "Address:", dset->shared->layout.storage.u.contig.addr);
 
 done:
     FUNC_LEAVE_API(ret_value)
diff --git a/src/H5Dearray.c b/src/H5Dearray.c
index 2e32494..a53489e 100644
--- a/src/H5Dearray.c
+++ b/src/H5Dearray.c
@@ -11,10 +11,10 @@
  * help@hdfgroup.org.                                                        *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
-/* Programmer:     Quincey Koziol <koziol@hdfgroup.org>
- *               Tuesday, January 27, 2009
+/* Programmer:      Quincey Koziol
+ *                  Tuesday, January 27, 2009
  *
- * Purpose:    Extensible array indexed (chunked) I/O functions.  The chunks
+ * Purpose:     Extensible array indexed (chunked) I/O functions.  The chunks
  *              are given a single-dimensional index which is used as the
  *              offset in an extensible array that maps a chunk coordinate to
  *              a disk address.
@@ -31,13 +31,14 @@
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"        /* Generic Functions            */
-#include "H5Dpkg.h"        /* Datasets                */
-#include "H5Eprivate.h"        /* Error handling              */
-#include "H5EAprivate.h"    /* Extensible arrays              */
-#include "H5FLprivate.h"    /* Free Lists                           */
-#include "H5MFprivate.h"    /* File space management        */
-#include "H5VMprivate.h"        /* Vector functions            */
+#include "H5private.h"		/* Generic Functions			*/
+#include "H5Dpkg.h"		/* Datasets				*/
+#include "H5Eprivate.h"		/* Error handling		  	*/
+#include "H5EAprivate.h"	/* Extensible arrays		  	*/
+#include "H5FLprivate.h"	/* Free Lists                           */
+#include "H5MFprivate.h"	/* File space management		*/
+#include "H5MMprivate.h"	/* Memory management			*/
+#include "H5VMprivate.h"        /* Vector functions			*/
 
 
 /****************/
@@ -182,7 +183,7 @@ const H5EA_class_t H5EA_CLS_CHUNK[1]={{
     H5D__earray_fill,           /* Fill block of missing elements callback */
     H5D__earray_encode,         /* Element encoding callback */
     H5D__earray_decode,         /* Element decoding callback */
-    H5D__earray_debug,        /* Element debugging callback */
+    H5D__earray_debug,          /* Element debugging callback */
     H5D__earray_crt_dbg_context, /* Create debugging context */
     H5D__earray_dst_dbg_context  /* Destroy debugging context */
 }};
@@ -213,16 +214,16 @@ H5FL_DEFINE_STATIC(H5D_earray_ctx_t);
 H5FL_DEFINE_STATIC(H5D_earray_ctx_ud_t);
 
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_crt_context
  *
- * Purpose:    Create context for callbacks
+ * Purpose:     Create context for callbacks
  *
- * Return:    Success:    non-NULL
- *        Failure:    NULL
+ * Return:      Success:    non-NULL
+ *              Failure:    NULL
  *
- * Programmer:    Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Thursday, January 29, 2009
  *
  *-------------------------------------------------------------------------
@@ -262,16 +263,16 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5D__earray_crt_context() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_dst_context
  *
- * Purpose:    Destroy context for callbacks
+ * Purpose:     Destroy context for callbacks
  *
- * Return:    Success:    non-NULL
- *        Failure:    NULL
+ * Return:      Success:    non-NULL
+ *              Failure:    NULL
  *
- * Programmer:    Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Thursday, January 29, 2009
  *
  *-------------------------------------------------------------------------
@@ -292,7 +293,7 @@ H5D__earray_dst_context(void *_ctx)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5D__earray_dst_context() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_fill
  *
@@ -322,16 +323,16 @@ H5D__earray_fill(void *nat_blk, size_t nelmts)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5D__earray_fill() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_encode
  *
- * Purpose:    Encode an element from "native" to "raw" form
+ * Purpose:     Encode an element from "native" to "raw" form
  *
- * Return:    Success:    non-negative
- *        Failure:    negative
+ * Return:      Success:    non-negative
+ *              Failure:    negative
  *
- * Programmer:    Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Tuesday, January 27, 2009
  *
  *-------------------------------------------------------------------------
@@ -366,16 +367,16 @@ H5D__earray_encode(void *raw, const void *_elmt, size_t nelmts, void *_ctx)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5D__earray_encode() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_decode
  *
- * Purpose:    Decode an element from "raw" to "native" form
+ * Purpose:     Decode an element from "raw" to "native" form
  *
- * Return:    Success:    non-negative
- *        Failure:    negative
+ * Return:      Success:    non-negative
+ *              Failure:    negative
  *
- * Programmer:    Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Thursday, January 29, 2009
  *
  *-------------------------------------------------------------------------
@@ -410,16 +411,16 @@ H5D__earray_decode(const void *_raw, void *_elmt, size_t nelmts, void *_ctx)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5D__earray_decode() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_debug
  *
- * Purpose:    Display an element for debugging
+ * Purpose:     Display an element for debugging
  *
- * Return:    Success:    non-negative
- *        Failure:    negative
+ * Return:      Success:    non-negative
+ *              Failure:    negative
  *
- * Programmer:    Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Thursday, January 29, 2009
  *
  *-------------------------------------------------------------------------
@@ -444,16 +445,16 @@ H5D__earray_debug(FILE *stream, int indent, int fwidth, hsize_t idx,
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5D__earray_debug() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_filt_fill
  *
- * Purpose:    Fill "missing elements" in block of elements
+ * Purpose:     Fill "missing elements" in block of elements
  *
- * Return:    Success:    non-negative
- *        Failure:    negative
+ * Return:      Success:    non-negative
+ *              Failure:    negative
  *
- * Programmer:    Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Saturday, January 31, 2009
  *
  *-------------------------------------------------------------------------
@@ -475,16 +476,16 @@ H5D__earray_filt_fill(void *nat_blk, size_t nelmts)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5D__earray_filt_fill() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_filt_encode
  *
- * Purpose:    Encode an element from "native" to "raw" form
+ * Purpose:     Encode an element from "native" to "raw" form
  *
- * Return:    Success:    non-negative
- *        Failure:    negative
+ * Return:      Success:    non-negative
+ *              Failure:    negative
  *
- * Programmer:    Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Saturday, January 31, 2009
  *
  *-------------------------------------------------------------------------
@@ -522,16 +523,16 @@ H5D__earray_filt_encode(void *_raw, const void *_elmt, size_t nelmts, void *_ctx
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5D__earray_filt_encode() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_filt_decode
  *
- * Purpose:    Decode an element from "raw" to "native" form
+ * Purpose:     Decode an element from "raw" to "native" form
  *
- * Return:    Success:    non-negative
- *        Failure:    negative
+ * Return:      Success:    non-negative
+ *              Failure:    negative
  *
- * Programmer:    Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Saturday, January 31, 2009
  *
  *-------------------------------------------------------------------------
@@ -568,16 +569,16 @@ H5D__earray_filt_decode(const void *_raw, void *_elmt, size_t nelmts, void *_ctx
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5D__earray_filt_decode() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_filt_debug
  *
- * Purpose:    Display an element for debugging
+ * Purpose:     Display an element for debugging
  *
- * Return:    Success:    non-negative
- *        Failure:    negative
+ * Return:      Success:    non-negative
+ *              Failure:    negative
  *
- * Programmer:    Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Saturday, January 31, 2009
  *
  *-------------------------------------------------------------------------
@@ -603,24 +604,24 @@ H5D__earray_filt_debug(FILE *stream, int indent, int fwidth, hsize_t idx,
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5D__earray_filt_debug() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_crt_dbg_context
  *
- * Purpose:    Create context for debugging callback
- *        (get the layout message in the specified object header)
+ * Purpose:     Create context for debugging callback
+ *              (get the layout message in the specified object header)
  *
- * Return:    Success:    non-NULL
- *        Failure:    NULL
+ * Return:      Success:    non-NULL
+ *              Failure:    NULL
  *
- * Programmer:    Vailin Choi; July 2010
+ * Programmer:  Vailin Choi; July 2010
  *
  *-------------------------------------------------------------------------
  */
 static void *
 H5D__earray_crt_dbg_context(H5F_t *f, haddr_t obj_addr)
 {
-    H5D_earray_ctx_ud_t    *dbg_ctx = NULL;   /* Context for fixed array callback */
+    H5D_earray_ctx_ud_t	*dbg_ctx = NULL;   /* Context for fixed array callback */
     H5O_loc_t obj_loc;          /* Pointer to an object's location */
     hbool_t obj_opened = FALSE; /* Flag to indicate that the object header was opened */
     H5O_layout_t layout;        /* Layout message */
@@ -677,24 +678,24 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5D__earray_crt_dbg_context() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_dst_dbg_context
  *
- * Purpose:    Destroy context for debugging callback
- *        (free the layout message from the specified object header)
+ * Purpose:     Destroy context for debugging callback
+ *              (free the layout message from the specified object header)
  *
- * Return:    Success:    non-negative
- *        Failure:    negative
+ * Return:      Success:    non-negative
+ *              Failure:    negative
  *
- * Programmer:    Vailin Choi; July 2010
+ * Programmer:  Vailin Choi; July 2010
  *
  *-------------------------------------------------------------------------
  */
 static herr_t
 H5D__earray_dst_dbg_context(void *_dbg_ctx)
 {
-    H5D_earray_ctx_ud_t    *dbg_ctx = (H5D_earray_ctx_ud_t    *)_dbg_ctx; /* Context for extensible array callback */
+    H5D_earray_ctx_ud_t	*dbg_ctx = (H5D_earray_ctx_ud_t	*)_dbg_ctx; /* Context for extensible array callback */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -707,18 +708,18 @@ H5D__earray_dst_dbg_context(void *_dbg_ctx)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5D__earray_dst_dbg_context() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_idx_depend
  *
- * Purpose:    Create flush dependency between extensible array and dataset's
+ * Purpose:     Create flush dependency between extensible array and dataset's
  *              object header.
  *
- * Return:    Success:    non-negative
- *        Failure:    negative
+ * Return:      Success:    non-negative
+ *              Failure:    negative
  *
- * Programmer:    Quincey Koziol
- *        Tuesday, June  2, 2009
+ * Programmer:  Quincey Koziol
+ *              Tuesday, June  2, 2009
  *
  *-------------------------------------------------------------------------
  */
@@ -769,22 +770,22 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5D__earray_idx_depend() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_idx_open
  *
- * Purpose:    Opens an existing extensible array.
+ * Purpose:     Opens an existing extensible array.
  *
- * Note:    This information is passively initialized from each index
+ * Note:        This information is passively initialized from each index
  *              operation callback because those abstract chunk index operations
  *              are designed to work with the v1 B-tree chunk indices also,
  *              which don't require an 'open' for the data structure.
  *
- * Return:    Success:    non-negative
- *        Failure:    negative
+ * Return:      Success:    non-negative
+ *              Failure:    negative
  *
- * Programmer:    Quincey Koziol
- *        Thursday, January 29, 2009
+ * Programmer:  Quincey Koziol
+ *              Thursday, January 29, 2009
  *
  *-------------------------------------------------------------------------
  */
@@ -813,7 +814,7 @@ H5D__earray_idx_open(const H5D_chk_idx_info_t *idx_info)
 
     /* Open the extensible array for the chunk index */
     if(NULL == (idx_info->storage->u.earray.ea = H5EA_open(idx_info->f, idx_info->storage->idx_addr, &udata)))
-    HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't open extensible array")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't open extensible array")
 
     /* Check for SWMR writes to the file */
     if(H5F_INTENT(idx_info->f) & H5F_ACC_SWMR_WRITE)
@@ -824,15 +825,15 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5D__earray_idx_open() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_idx_init
  *
- * Purpose:    Initialize the indexing information for a dataset.
+ * Purpose:     Initialize the indexing information for a dataset.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Wednesday, May 27, 2009
  *
  *-------------------------------------------------------------------------
@@ -861,7 +862,7 @@ H5D__earray_idx_init(const H5D_chk_idx_info_t *idx_info, const H5S_t *space,
 
     /* Get the dim info for dataset */
     if((sndims = H5S_get_simple_extent_dims(space, NULL, max_dims)) < 0)
-    HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get dataspace dimensions")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get dataspace dimensions")
     H5_CHECKED_ASSIGN(ndims, unsigned, sndims, int);
 
     /* Find the rank of the unlimited dimension */
@@ -892,22 +893,22 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5D__earray_idx_init() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_idx_create
  *
- * Purpose:    Creates a new indexed-storage extensible array and initializes
+ * Purpose:     Creates a new indexed-storage extensible array and initializes
  *              the layout struct with information about the storage.  The
- *        struct should be immediately written to the object header.
+ *              struct should be immediately written to the object header.
  *
- *        This function must be called before passing LAYOUT to any of
- *        the other indexed storage functions!
+ *              This function must be called before passing LAYOUT to any of
+ *              the other indexed storage functions!
  *
- * Return:    Non-negative on success (with the LAYOUT argument initialized
- *        and ready to write to an object header). Negative on failure.
+ * Return:      Non-negative on success (with the LAYOUT argument initialized
+ *              and ready to write to an object header). Negative on failure.
  *
- * Programmer:    Quincey Koziol
- *        Tuesday, January 27, 2009
+ * Programmer:  Quincey Koziol
+ *              Tuesday, January 27, 2009
  *
  *-------------------------------------------------------------------------
  */
@@ -964,11 +965,11 @@ H5D__earray_idx_create(const H5D_chk_idx_info_t *idx_info)
 
     /* Create the extensible array for the chunk index */
     if(NULL == (idx_info->storage->u.earray.ea = H5EA_create(idx_info->f, &cparam, &udata)))
-    HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't create extensible array")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't create extensible array")
 
     /* Get the address of the extensible array in file */
     if(H5EA_get_addr(idx_info->storage->u.earray.ea, &(idx_info->storage->idx_addr)) < 0)
-    HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't query extensible array address")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't query extensible array address")
 
     /* Check for SWMR writes to the file */
     if(H5F_INTENT(idx_info->f) & H5F_ACC_SWMR_WRITE)
@@ -979,16 +980,16 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5D__earray_idx_create() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_idx_is_space_alloc
  *
- * Purpose:    Query if space is allocated for index method
+ * Purpose:     Query if space is allocated for index method
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Quincey Koziol
- *        Thursday, January 29, 2009
+ * Programmer:  Quincey Koziol
+ *              Thursday, January 29, 2009
  *
  *-------------------------------------------------------------------------
  */
@@ -1003,15 +1004,15 @@ H5D__earray_idx_is_space_alloc(const H5O_storage_chunk_t *storage)
     FUNC_LEAVE_NOAPI((hbool_t)H5F_addr_defined(storage->idx_addr))
 } /* end H5D__earray_idx_is_space_alloc() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_idx_insert
  *
- * Purpose:    Insert chunk address into the indexing structure.
+ * Purpose:     Insert chunk address into the indexing structure.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Vailin Choi; May 2014
+ * Programmer:  Vailin Choi; May 2014
  *
  *-------------------------------------------------------------------------
  */
@@ -1045,43 +1046,43 @@ H5D__earray_idx_insert(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *udata
     ea = idx_info->storage->u.earray.ea;
 
     if(!H5F_addr_defined(udata->chunk_block.offset))
-    HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "The chunk should have allocated already")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "The chunk should have allocated already")
     if(udata->chunk_idx != (udata->chunk_idx & 0xffffffff)) /* negative value */
-    HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "chunk index must be less than 2^32")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "chunk index must be less than 2^32")
 
     /* Check for filters on chunks */
     if(idx_info->pline->nused > 0) {
-    H5D_earray_filt_elmt_t elmt;            /* Extensible array element */
+        H5D_earray_filt_elmt_t elmt;            /* Extensible array element */
 
-    elmt.addr = udata->chunk_block.offset;
+        elmt.addr = udata->chunk_block.offset;
         H5_CHECKED_ASSIGN(elmt.nbytes, uint32_t, udata->chunk_block.length, hsize_t);
-    elmt.filter_mask = udata->filter_mask;
+        elmt.filter_mask = udata->filter_mask;
 
-    /* Set the info for the chunk */
-    if(H5EA_set(ea, udata->chunk_idx, &elmt) < 0)
-        HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't set chunk info")
+        /* Set the info for the chunk */
+        if(H5EA_set(ea, udata->chunk_idx, &elmt) < 0)
+            HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't set chunk info")
     } /* end if */
     else {
-    /* Set the address for the chunk */
-    if(H5EA_set(ea, udata->chunk_idx, &udata->chunk_block.offset) < 0)
-        HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't set chunk address")
+        /* Set the address for the chunk */
+        if(H5EA_set(ea, udata->chunk_idx, &udata->chunk_block.offset) < 0)
+            HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't set chunk address")
     } /* end else */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5D__earray_idx_insert() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_idx_get_addr
  *
- * Purpose:    Get the file address of a chunk if file space has been
- *        assigned.  Save the retrieved information in the udata
- *        supplied.
+ * Purpose:     Get the file address of a chunk if file space has been
+ *              assigned.  Save the retrieved information in the udata
+ *              supplied.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Thursday, January 29, 2009
  *
  *-------------------------------------------------------------------------
@@ -1091,7 +1092,7 @@ H5D__earray_idx_get_addr(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *uda
 {
     H5EA_t      *ea;                    /* Pointer to extensible array structure */
     hsize_t     idx;                    /* Array index of chunk */
-    herr_t    ret_value = SUCCEED;    /* Return value */
+    herr_t      ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -1119,11 +1120,11 @@ H5D__earray_idx_get_addr(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *uda
     if(idx_info->layout->u.earray.unlim_dim > 0) {
         hsize_t swizzled_coords[H5O_LAYOUT_NDIMS];    /* swizzled chunk coordinates */
         unsigned ndims = (idx_info->layout->ndims - 1); /* Number of dimensions */
-    unsigned u;
+        unsigned u;
 
-    /* Compute coordinate offset from scaled offset */
-    for(u = 0; u < ndims; u++)
-        swizzled_coords[u] = udata->common.scaled[u] * idx_info->layout->dim[u];
+        /* Compute coordinate offset from scaled offset */
+        for(u = 0; u < ndims; u++)
+            swizzled_coords[u] = udata->common.scaled[u] * idx_info->layout->dim[u];
 
         H5VM_swizzle_coords(hsize_t, swizzled_coords, idx_info->layout->u.earray.unlim_dim);
 
@@ -1156,27 +1157,27 @@ H5D__earray_idx_get_addr(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *uda
             HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get chunk address")
 
         /* Update the other (constant) information for the chunk */
-    udata->chunk_block.length = idx_info->layout->size;
+        udata->chunk_block.length = idx_info->layout->size;
         udata->filter_mask = 0;
     } /* end else */
 
     if(!H5F_addr_defined(udata->chunk_block.offset))
-    udata->chunk_block.length = 0;
+        udata->chunk_block.length = 0;
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5D__earray_idx_get_addr() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_idx_resize
  *
- * Purpose:    Calculate/setup the swizzled down chunk array, used for chunk
+ * Purpose:     Calculate/setup the swizzled down chunk array, used for chunk
  *              index calculations.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Thursday, July 23, 2009
  *
  *-------------------------------------------------------------------------
@@ -1221,15 +1222,15 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5D__earray_idx_resize() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_idx_iterate_cb
  *
- * Purpose:    Callback routine for extensible array element iteration.
+ * Purpose:     Callback routine for extensible array element iteration.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Vailin Choi; Feb 2015
+ * Programmer:  Vailin Choi; Feb 2015
  *
  *-------------------------------------------------------------------------
  */
@@ -1256,8 +1257,8 @@ H5D__earray_idx_iterate_cb(hsize_t H5_ATTR_UNUSED idx, const void *_elmt, void *
 
     /* Make "generic chunk" callback */
     if(H5F_addr_defined(udata->chunk_rec.chunk_addr))
-    if((ret_value = (udata->cb)(&udata->chunk_rec, udata->udata)) < 0)
-        HERROR(H5E_DATASET, H5E_CALLBACK, "failure in generic chunk iterator callback");
+        if((ret_value = (udata->cb)(&udata->chunk_rec, udata->udata)) < 0)
+            HERROR(H5E_DATASET, H5E_CALLBACK, "failure in generic chunk iterator callback");
 
     /* Update coordinates of chunk in dataset */
     ndims = udata->common.layout->ndims - 1;
@@ -1280,20 +1281,20 @@ H5D__earray_idx_iterate_cb(hsize_t H5_ATTR_UNUSED idx, const void *_elmt, void *
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5D__earray_idx_iterate_cb() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_idx_iterate
  *
- * Purpose:    Iterate over the chunks in an index, making a callback
+ * Purpose:     Iterate over the chunks in an index, making a callback
  *              for each one.
  *
- * Note:    This implementation is slow, particularly for sparse
+ * Note:        This implementation is slow, particularly for sparse
  *              extensible arrays, replace it with call to H5EA_iterate()
  *              when that's available.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Thursday, January 29, 2009
  *
  *-------------------------------------------------------------------------
@@ -1331,42 +1332,42 @@ H5D__earray_idx_iterate(const H5D_chk_idx_info_t *idx_info,
 
     /* Get the extensible array statistics */
     if(H5EA_get_stats(ea, &ea_stat) < 0)
-    HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't query extensible array statistics")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't query extensible array statistics")
 
     if(ea_stat.stored.max_idx_set > 0) {
         H5D_earray_it_ud_t udata;   /* User data for iteration callback */
 
-    /* Initialize userdata */
-    HDmemset(&udata, 0, sizeof udata);
-    udata.common.layout = idx_info->layout;
-    udata.common.storage = idx_info->storage;
+        /* Initialize userdata */
+        HDmemset(&udata, 0, sizeof udata);
+        udata.common.layout = idx_info->layout;
+        udata.common.storage = idx_info->storage;
         HDmemset(&udata.chunk_rec, 0, sizeof(udata.chunk_rec));
         udata.filtered = (idx_info->pline->nused > 0);
         if(!udata.filtered) {
             udata.chunk_rec.nbytes = idx_info->layout->size;
             udata.chunk_rec.filter_mask = 0;
         } /* end if */
-    udata.cb = chunk_cb;
-    udata.udata = chunk_udata;
+        udata.cb = chunk_cb;
+        udata.udata = chunk_udata;
 
         /* Iterate over the extensible array elements */
-    if((ret_value = H5EA_iterate(ea, H5D__earray_idx_iterate_cb, &udata)) < 0)
-        HERROR(H5E_DATASET, H5E_BADITER, "unable to iterate over fixed array chunk index");
+        if((ret_value = H5EA_iterate(ea, H5D__earray_idx_iterate_cb, &udata)) < 0)
+            HERROR(H5E_DATASET, H5E_BADITER, "unable to iterate over fixed array chunk index");
     } /* end if */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5D__earray_idx_iterate() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_idx_remove
  *
- * Purpose:    Remove chunk from index.
+ * Purpose:     Remove chunk from index.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Thursday, January 29, 2009
  *
  *-------------------------------------------------------------------------
@@ -1376,7 +1377,7 @@ H5D__earray_idx_remove(const H5D_chk_idx_info_t *idx_info, H5D_chunk_common_ud_t
 {
     H5EA_t      *ea;                    /* Pointer to extensible array structure */
     hsize_t     idx;                    /* Array index of chunk */
-    herr_t    ret_value = SUCCEED;    /* Return value */
+    herr_t      ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -1405,11 +1406,11 @@ H5D__earray_idx_remove(const H5D_chk_idx_info_t *idx_info, H5D_chunk_common_ud_t
     if(idx_info->layout->u.earray.unlim_dim > 0) {
         hsize_t swizzled_coords[H5O_LAYOUT_NDIMS];    /* swizzled chunk coordinates */
         unsigned ndims = (idx_info->layout->ndims - 1); /* Number of dimensions */
-    unsigned u;
+        unsigned u;
 
-    /* Compute coordinate offset from scaled offset */
-    for(u = 0; u < ndims; u++)
-        swizzled_coords[u] = udata->scaled[u] * idx_info->layout->dim[u];
+        /* Compute coordinate offset from scaled offset */
+        for(u = 0; u < ndims; u++)
+            swizzled_coords[u] = udata->scaled[u] * idx_info->layout->dim[u];
 
         H5VM_swizzle_coords(hsize_t, swizzled_coords, idx_info->layout->u.earray.unlim_dim);
 
@@ -1469,16 +1470,16 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5D__earray_idx_remove() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_idx_delete_cb
  *
- * Purpose:    Delete space for chunk in file
+ * Purpose:     Delete space for chunk in file
  *
- * Return:    Success:    Non-negative
- *        Failure:    negative
+ * Return:      Success:    Non-negative
+ *              Failure:    negative
  *
- * Programmer:    Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Saturday, January 31, 2009
  *
  *-------------------------------------------------------------------------
@@ -1506,21 +1507,21 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5D__earray_idx_delete_cb() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_idx_delete
  *
- * Purpose:    Delete index and raw data storage for entire dataset
+ * Purpose:     Delete index and raw data storage for entire dataset
  *              (i.e. all chunks)
  *
- * Note:    This implementation is slow, particularly for sparse
+ * Note:        This implementation is slow, particularly for sparse
  *              extensible arrays, replace it with call to H5EA_iterate()
  *              when that's available.
  *
- * Return:    Success:    Non-negative
- *        Failure:    negative
+ * Return:      Success:    Non-negative
+ *              Failure:    negative
  *
- * Programmer:    Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Thursday, January 29, 2009
  *
  *-------------------------------------------------------------------------
@@ -1568,15 +1569,15 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5D__earray_idx_delete() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_idx_copy_setup
  *
- * Purpose:    Set up any necessary information for copying chunks
+ * Purpose:     Set up any necessary information for copying chunks
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Saturday, January 31, 2009
  *
  *-------------------------------------------------------------------------
@@ -1623,15 +1624,15 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5D__earray_idx_copy_setup() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_idx_copy_shutdown
  *
- * Purpose:    Shutdown any information from copying chunks
+ * Purpose:     Shutdown any information from copying chunks
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Saturday, January 31, 2009
  *
  *-------------------------------------------------------------------------
@@ -1662,7 +1663,7 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5D__earray_idx_copy_shutdown() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_idx_size
  *
@@ -1703,7 +1704,7 @@ H5D__earray_idx_size(const H5D_chk_idx_info_t *idx_info, hsize_t *index_size)
 
     /* Get the extensible array statistics */
     if(H5EA_get_stats(ea, &ea_stat) < 0)
-    HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't query extensible array statistics")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't query extensible array statistics")
 
     /* Set the size of the extensible array */
     *index_size = ea_stat.computed.hdr_size + ea_stat.computed.index_blk_size
@@ -1719,15 +1720,15 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5D__earray_idx_size() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_idx_reset
  *
- * Purpose:    Reset indexing information.
+ * Purpose:     Reset indexing information.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Saturday, January 31, 2009
  *
  *-------------------------------------------------------------------------
@@ -1742,7 +1743,7 @@ H5D__earray_idx_reset(H5O_storage_chunk_t *storage, hbool_t reset_addr)
 
     /* Reset index info */
     if(reset_addr) {
-    storage->idx_addr = HADDR_UNDEF;
+        storage->idx_addr = HADDR_UNDEF;
         storage->u.earray.dset_ohdr_addr = HADDR_UNDEF;
     } /* end if */
     storage->u.earray.ea = NULL;
@@ -1750,15 +1751,15 @@ H5D__earray_idx_reset(H5O_storage_chunk_t *storage, hbool_t reset_addr)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5D__earray_idx_reset() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_idx_dump
  *
- * Purpose:    Dump indexing information to a stream.
+ * Purpose:     Dump indexing information to a stream.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Saturday, January 31, 2009
  *
  *-------------------------------------------------------------------------
@@ -1777,15 +1778,15 @@ H5D__earray_idx_dump(const H5O_storage_chunk_t *storage, FILE *stream)
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5D__earray_idx_dump() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5D__earray_idx_dest
  *
- * Purpose:    Release indexing information in memory.
+ * Purpose:     Release indexing information in memory.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Saturday, January 31, 2009
  *
  *-------------------------------------------------------------------------
@@ -1805,7 +1806,7 @@ H5D__earray_idx_dest(const H5D_chk_idx_info_t *idx_info)
     /* Check if the extensible array is open */
     if(idx_info->storage->u.earray.ea) {
 
-    /* Patch the top level file pointer contained in ea if needed */
+        /* Patch the top level file pointer contained in ea if needed */
         if(H5EA_patch_file(idx_info->storage->u.earray.ea, idx_info->f) < 0)
             HGOTO_ERROR(H5E_DATASET, H5E_CANTOPENOBJ, FAIL, "can't patch earray file pointer")
 
diff --git a/src/H5Dfarray.c b/src/H5Dfarray.c
index c4a3d4b..a9202c2 100644
--- a/src/H5Dfarray.c
+++ b/src/H5Dfarray.c
@@ -263,12 +263,12 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5D__farray_dst_context
  *
- * Purpose:    Destroy context for callbacks
+ * Purpose:     Destroy context for callbacks
  *
- * Return:    Success:    non-NULL
- *        Failure:    NULL
+ * Return:      Success:    non-NULL
+ *              Failure:    NULL
  *
- * Programmer:    Vailin Choi
+ * Programmer:  Vailin Choi
  *              Thursday, April 30, 2009
  *
  *-------------------------------------------------------------------------
@@ -293,12 +293,12 @@ H5D__farray_dst_context(void *_ctx)
 /*-------------------------------------------------------------------------
  * Function:    H5D__farray_fill
  *
- * Purpose:    Fill "missing elements" in block of elements
+ * Purpose:     Fill "missing elements" in block of elements
  *
- * Return:    Success:    non-negative
- *        Failure:    negative
+ * Return:      Success:    non-negative
+ *              Failure:    negative
  *
- * Programmer:    Vailin Choi
+ * Programmer:  Vailin Choi
  *              Thursday, April 30, 2009
  *
  *-------------------------------------------------------------------------
@@ -323,12 +323,12 @@ H5D__farray_fill(void *nat_blk, size_t nelmts)
 /*-------------------------------------------------------------------------
  * Function:    H5D__farray_encode
  *
- * Purpose:    Encode an element from "native" to "raw" form
+ * Purpose:     Encode an element from "native" to "raw" form
  *
- * Return:    Success:    non-negative
- *        Failure:    negative
+ * Return:      Success:    non-negative
+ *              Failure:    negative
  *
- * Programmer:    Vailin Choi
+ * Programmer:  Vailin Choi
  *              Thursday, April 30, 2009
  *
  *-------------------------------------------------------------------------
@@ -367,12 +367,12 @@ H5D__farray_encode(void *raw, const void *_elmt, size_t nelmts, void *_ctx)
 /*-------------------------------------------------------------------------
  * Function:    H5D__farray_decode
  *
- * Purpose:    Decode an element from "raw" to "native" form
+ * Purpose:     Decode an element from "raw" to "native" form
  *
- * Return:    Success:    non-negative
- *        Failure:    negative
+ * Return:      Success:    non-negative
+ *              Failure:    negative
  *
- * Programmer:    Vailin Choi
+ * Programmer:  Vailin Choi
  *              Thursday, April 30, 2009
  *
  *-------------------------------------------------------------------------
@@ -411,12 +411,12 @@ H5D__farray_decode(const void *_raw, void *_elmt, size_t nelmts, void *_ctx)
 /*-------------------------------------------------------------------------
  * Function:    H5D__farray_debug
  *
- * Purpose:    Display an element for debugging
+ * Purpose:     Display an element for debugging
  *
- * Return:    Success:    non-negative
- *        Failure:    negative
+ * Return:      Success:    non-negative
+ *              Failure:    negative
  *
- * Programmer:    Vailin Choi
+ * Programmer:  Vailin Choi
  *              Thursday, April 30, 2009
  *
  *-------------------------------------------------------------------------
@@ -445,21 +445,21 @@ H5D__farray_debug(FILE *stream, int indent, int fwidth, hsize_t idx,
 /*-------------------------------------------------------------------------
  * Function:    H5D__farray_crt_dbg_context
  *
- * Purpose:    Create context for debugging callback
- *        (get the layout message in the specified object header)
+ * Purpose:     Create context for debugging callback
+ *              (get the layout message in the specified object header)
  *
- * Return:    Success:    non-NULL
- *        Failure:    NULL
+ * Return:      Success:    non-NULL
+ *              Failure:    NULL
  *
- * Programmer:    Vailin Choi
- *        5th August, 2009
+ * Programmer:  Vailin Choi
+ *              5th August, 2009
  *
  *-------------------------------------------------------------------------
  */
 static void *
 H5D__farray_crt_dbg_context(H5F_t *f, haddr_t obj_addr)
 {
-    H5D_farray_ctx_ud_t    *dbg_ctx = NULL;   /* Context for fixed array callback */
+    H5D_farray_ctx_ud_t     *dbg_ctx = NULL;   /* Context for fixed array callback */
     H5O_loc_t obj_loc;          /* Pointer to an object's location */
     hbool_t obj_opened = FALSE; /* Flag to indicate that the object header was opened */
     H5O_layout_t layout;        /* Layout message */
@@ -520,14 +520,14 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5D__farray_dst_dbg_context
  *
- * Purpose:    Destroy context for debugging callback
- *        (free the layout message from the specified object header)
+ * Purpose:     Destroy context for debugging callback
+ *              (free the layout message from the specified object header)
  *
- * Return:    Success:    non-negative
- *        Failure:    negative
+ * Return:      Success:    non-negative
+ *              Failure:    negative
  *
- * Programmer:    Quincey Koziol
- *        24th September, 2009
+ * Programmer:  Quincey Koziol
+ *              24th September, 2009
  *
  *-------------------------------------------------------------------------
  */
@@ -551,12 +551,12 @@ H5D__farray_dst_dbg_context(void *_dbg_ctx)
 /*-------------------------------------------------------------------------
  * Function:    H5D__farray_filt_fill
  *
- * Purpose:    Fill "missing elements" in block of elements
+ * Purpose:     Fill "missing elements" in block of elements
  *
- * Return:    Success:    non-negative
- *        Failure:    negative
+ * Return:      Success:    non-negative
+ *              Failure:    negative
  *
- * Programmer:    Vailin Choi
+ * Programmer:  Vailin Choi
  *              Thursday, April 30, 2009
  *
  *-------------------------------------------------------------------------
@@ -582,12 +582,12 @@ H5D__farray_filt_fill(void *nat_blk, size_t nelmts)
 /*-------------------------------------------------------------------------
  * Function:    H5D__farray_filt_encode
  *
- * Purpose:    Encode an element from "native" to "raw" form
+ * Purpose:     Encode an element from "native" to "raw" form
  *
- * Return:    Success:    non-negative
- *        Failure:    negative
+ * Return:      Success:    non-negative
+ *              Failure:    negative
  *
- * Programmer:    Vailin Choi
+ * Programmer:  Vailin Choi
  *              Thursday, April 30, 2009
  *
  *-------------------------------------------------------------------------
@@ -629,12 +629,12 @@ H5D__farray_filt_encode(void *_raw, const void *_elmt, size_t nelmts, void *_ctx
 /*-------------------------------------------------------------------------
  * Function:    H5D__farray_filt_decode
  *
- * Purpose:    Decode an element from "raw" to "native" form
+ * Purpose:     Decode an element from "raw" to "native" form
  *
- * Return:    Success:    non-negative
- *        Failure:    negative
+ * Return:      Success:    non-negative
+ *              Failure:    negative
  *
- * Programmer:    Vailin Choi
+ * Programmer:  Vailin Choi
  *              Thursday, April 30, 2009
  *
  *-------------------------------------------------------------------------
@@ -675,12 +675,12 @@ H5D__farray_filt_decode(const void *_raw, void *_elmt, size_t nelmts, void *_ctx
 /*-------------------------------------------------------------------------
  * Function:    H5D__farray_filt_debug
  *
- * Purpose:    Display an element for debugging
+ * Purpose:     Display an element for debugging
  *
- * Return:    Success:    non-negative
- *        Failure:    negative
+ * Return:      Success:    non-negative
+ *              Failure:    negative
  *
- * Programmer:    Vailin Choi
+ * Programmer:  Vailin Choi
  *              Thursday, April 30, 2009
  *
  *-------------------------------------------------------------------------
@@ -710,13 +710,13 @@ H5D__farray_filt_debug(FILE *stream, int indent, int fwidth, hsize_t idx,
 /*-------------------------------------------------------------------------
  * Function:    H5D__farray_idx_depend
  *
- * Purpose:    Create flush dependency between fixed array and dataset's
+ * Purpose:     Create flush dependency between fixed array and dataset's
  *              object header.
  *
- * Return:    Success:    non-negative
- *        Failure:    negative
+ * Return:      Success:    non-negative
+ *              Failure:    negative
  *
- * Programmer:    Vailin Choi
+ * Programmer:  Vailin Choi
  *              Thursday, April 30, 2009
  *
  *-------------------------------------------------------------------------
@@ -800,13 +800,13 @@ H5D__farray_idx_init(const H5D_chk_idx_info_t *idx_info, const H5S_t H5_ATTR_UNU
 /*-------------------------------------------------------------------------
  * Function:    H5D__farray_idx_open
  *
- * Purpose:    Opens an existing fixed array and initializes
+ * Purpose:     Opens an existing fixed array and initializes
  *              the layout struct with information about the storage.
  *
- * Return:    Success:    non-negative
- *        Failure:    negative
+ * Return:      Success:    non-negative
+ *              Failure:    negative
  *
- * Programmer:    Vailin Choi
+ * Programmer:  Vailin Choi
  *              Thursday, April 30, 2009
  *
  *-------------------------------------------------------------------------
@@ -851,17 +851,17 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5D__farray_idx_create
  *
- * Purpose:    Creates a new indexed-storage fixed array and initializes
+ * Purpose:     Creates a new indexed-storage fixed array and initializes
  *              the layout struct with information about the storage.  The
- *        struct should be immediately written to the object header.
+ *              struct should be immediately written to the object header.
  *
- *        This function must be called before passing LAYOUT to any of
- *        the other indexed storage functions!
+ *              This function must be called before passing LAYOUT to any of
+ *              the other indexed storage functions!
  *
- * Return:    Non-negative on success (with the LAYOUT argument initialized
- *        and ready to write to an object header). Negative on failure.
+ * Return:      Non-negative on success (with the LAYOUT argument initialized
+ *              and ready to write to an object header). Negative on failure.
  *
- * Programmer:    Vailin Choi
+ * Programmer:  Vailin Choi
  *              Thursday, April 30, 2009
  *
  *-------------------------------------------------------------------------
@@ -932,11 +932,11 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5D__farray_idx_is_space_alloc
  *
- * Purpose:    Query if space is allocated for index method
+ * Purpose:     Query if space is allocated for index method
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Vailin Choi
+ * Programmer:  Vailin Choi
  *              Thursday, April 30, 2009
  *
  *-------------------------------------------------------------------------
@@ -956,11 +956,11 @@ H5D__farray_idx_is_space_alloc(const H5O_storage_chunk_t *storage)
 /*-------------------------------------------------------------------------
  * Function:    H5D__farray_idx_insert
  *
- * Purpose:    Insert chunk address into the indexing structure.
+ * Purpose:     Insert chunk address into the indexing structure.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Vailin Choi; 5 May 2014
+ * Programmer:  Vailin Choi; 5 May 2014
  *
  *-------------------------------------------------------------------------
  */
@@ -969,7 +969,7 @@ H5D__farray_idx_insert(const H5D_chk_idx_info_t *idx_info, H5D_chunk_ud_t *udata
     const H5D_t H5_ATTR_UNUSED *dset)
 {
     H5FA_t      *fa;      /* Pointer to fixed array structure */
-    herr_t    ret_value = SUCCEED;        /* Return value */
+    herr_t      ret_value = SUCCEED;        /* Return value */
 
     FUNC_ENTER_STATIC
 
diff --git a/src/H5Dfill.c b/src/H5Dfill.c
index 0cd8803..e67926c 100644
--- a/src/H5Dfill.c
+++ b/src/H5Dfill.c
@@ -38,6 +38,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5FLprivate.h"	/* Free Lists                           */
 #include "H5Iprivate.h"		/* IDs			  		*/
+#include "H5MMprivate.h"	/* Memory management			*/
 #include "H5VMprivate.h"	/* Vector and array functions		*/
 #include "H5WBprivate.h"        /* Wrapped Buffers                      */
 
@@ -174,7 +175,7 @@ done:
 --------------------------------------------------------------------------*/
 herr_t
 H5D__fill(const void *fill, const H5T_t *fill_type, void *buf,
-    const H5T_t *buf_type, const H5S_t *space)
+          const H5T_t *buf_type, const H5S_t *space)
 {
     H5S_sel_iter_t *mem_iter = NULL; /* Memory selection iteration info */
     hbool_t mem_iter_init = FALSE; /* Whether the memory selection iterator has been initialized */
@@ -248,12 +249,11 @@ H5D__fill(const void *fill, const H5T_t *fill_type, void *buf,
          * of the VL data.
          */
         if(TRUE == H5T_detect_class(fill_type, H5T_VLEN, FALSE)) {
-            hssize_t nelmts;                    /* Number of data elements */
+            hsize_t nelmts;                    /* Number of data elements */
 
             /* Get the number of elements in the selection */
             nelmts = H5S_GET_SELECT_NPOINTS(space);
-            HDassert(nelmts >= 0);
-            H5_CHECK_OVERFLOW(nelmts, hssize_t, size_t);
+            H5_CHECK_OVERFLOW(nelmts, hsize_t, size_t);
 
             /* Allocate a temporary buffer */
             if(NULL == (tmp_buf = H5FL_BLK_MALLOC(type_conv, (size_t)nelmts * buf_size)))
diff --git a/src/H5Dint.c b/src/H5Dint.c
index 91fde93..6c0fd76 100644
--- a/src/H5Dint.c
+++ b/src/H5Dint.c
@@ -2704,7 +2704,7 @@ H5D__vlen_get_buf_size(void H5_ATTR_UNUSED *elem, hid_t type_id,
         HGOTO_ERROR(H5E_DATASET, H5E_NOSPACE, FAIL, "can't resize tbuf")
 
     /* Select point to read in */
-    if(H5S_select_elements(vlen_bufsize->fspace, H5S_SELECT_SET, (hsize_t)1, point) < 0)
+    if(H5S_select_elements(vlen_bufsize->fspace, H5S_SELECT_SET, (size_t)1, point) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTCREATE, FAIL, "can't select point")
 
     /* Read in the point (with the custom VL memory allocator) */
diff --git a/src/H5Dio.c b/src/H5Dio.c
index 895f0bb..7762a5a 100644
--- a/src/H5Dio.c
+++ b/src/H5Dio.c
@@ -21,14 +21,14 @@
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"		/* Generic Functions			*/
-#include "H5CXprivate.h"        /* API Contexts                         */
-#include "H5Dpkg.h"		/* Dataset functions			*/
-#include "H5Eprivate.h"		/* Error handling		  	*/
-#include "H5FLprivate.h"	/* Free Lists                           */
-#include "H5Iprivate.h"		/* IDs			  		*/
-#include "H5MMprivate.h"        /* Memory management                    */
-#include "H5Sprivate.h"		/* Dataspace			  	*/
+#include "H5private.h"          /* Generic Functions                        */
+#include "H5CXprivate.h"        /* API Contexts                             */
+#include "H5Dpkg.h"             /* Dataset functions                        */
+#include "H5Eprivate.h"         /* Error handling                           */
+#include "H5FLprivate.h"        /* Free Lists                               */
+#include "H5Iprivate.h"         /* IDs                                      */
+#include "H5MMprivate.h"        /* Memory management                        */
+#include "H5Sprivate.h"         /* Dataspace                                */
 
 #ifdef H5_HAVE_PARALLEL
 /* Remove this if H5R_DATASET_REGION is no longer used in this file */
@@ -50,6 +50,7 @@
 /* Local Prototypes */
 /********************/
 
+/* Setup/teardown routines */
 static herr_t H5D__get_offset_copy(const H5D_t *dset, const hsize_t *offset,
         hsize_t *offset_copy/*out*/);
 static herr_t H5D__ioinfo_init(H5D_t *dset, const H5D_type_info_t *type_info,
@@ -102,7 +103,6 @@ H5D__get_offset_copy(const H5D_t *dset, const hsize_t *offset, hsize_t *offset_c
     HDassert(offset);
     HDassert(offset_copy);
 
-
     /* The library's chunking code requires the offset to terminate with a zero.
      * So transfer the offset array to an internal offset array that we
      * can properly terminate (handled via the calloc call).
@@ -127,14 +127,13 @@ done:
 
 } /* end H5D__get_offset_copy() */
 
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Dread
+ * Function:    H5Dread
  *
  * Purpose:     Reads (part of) a DSET from the file into application
  *              memory BUF. The part of the dataset to read is defined with
- *              MEM_SPACE_ID and FILE_SPACE_ID.	 The data points are
+ *              MEM_SPACE_ID and FILE_SPACE_ID. The data points are
  *              converted from their file type to the MEM_TYPE_ID specified.
  *              Additional miscellaneous data transfer properties can be
  *              passed to this function with the PLIST_ID argument.
@@ -194,8 +193,8 @@ H5Dread(hid_t dset_id, hid_t mem_type_id, hid_t mem_space_id,
     /* Set DXPL for operation */
     H5CX_set_dxpl(dxpl_id);
 
-    /* Read raw data */
-    if (H5D__read(dset, mem_type_id, mem_space, file_space, buf/*out*/) < 0)
+    /* Read the data */
+    if (H5D__read(dset, mem_type_id, mem_space, file_space, buf) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "can't read data")
 
 done:
@@ -442,9 +441,9 @@ H5D__read(H5D_t *dataset, hid_t mem_type_id, const H5S_t *mem_space,
                                         /* Note that if this variable is used, the        */
                                         /* projected mem space must be discarded at the   */
                                         /* end of the function to avoid a memory leak.    */
-    H5D_storage_t store;                /*union of EFL and chunk pointer in file space */
-    hssize_t	snelmts;                /*total number of elmts	(signed) */
-    hsize_t	nelmts;                 /*total number of elmts	*/
+    H5D_storage_t store;                /* union of EFL and chunk pointer in file space */
+    hssize_t    snelmts;                /* total number of elmts	(signed) */
+    hsize_t     nelmts;                 /* total number of elmts	*/
     hbool_t     io_op_init = FALSE;     /* Whether the I/O op has been initialized */
     char        fake_char;              /* Temporary variable for NULL buffer pointers */
     herr_t	ret_value = SUCCEED;	/* Return value	*/
@@ -518,7 +517,7 @@ H5D__read(H5D_t *dataset, hid_t mem_type_id, const H5S_t *mem_space,
      * Note that in general, this requires us to touch up the memory buffer as
      * well.
      */
-    if(TRUE == H5S_select_shape_same(mem_space, file_space) &&
+    if(TRUE == H5S_SELECT_SHAPE_SAME(mem_space, file_space) &&
             H5S_GET_EXTENT_NDIMS(mem_space) != H5S_GET_EXTENT_NDIMS(file_space)) {
         void *adj_buf = NULL;   /* Pointer to the location in buf corresponding  */
                                 /* to the beginning of the projected mem space.  */
@@ -656,9 +655,9 @@ H5D__write(H5D_t *dataset, hid_t mem_type_id, const H5S_t *mem_space,
                                         /* Note that if this variable is used, the        */
                                         /* projected mem space must be discarded at the   */
                                         /* end of the function to avoid a memory leak.    */
-    H5D_storage_t store;                /*union of EFL and chunk pointer in file space */
-    hssize_t	snelmts;                /*total number of elmts	(signed) */
-    hsize_t	nelmts;                 /*total number of elmts	*/
+    H5D_storage_t store;                /* union of EFL and chunk pointer in file space */
+    hssize_t    snelmts;                /* total number of elmts	(signed) */
+    hsize_t     nelmts;                 /* total number of elmts	*/
     hbool_t     io_op_init = FALSE;     /* Whether the I/O op has been initialized */
     char        fake_char;              /* Temporary variable for NULL buffer pointers */
     herr_t	ret_value = SUCCEED;	/* Return value	*/
@@ -753,7 +752,7 @@ H5D__write(H5D_t *dataset, hid_t mem_type_id, const H5S_t *mem_space,
      * Note that in general, this requires us to touch up the memory buffer
      * as well.
      */
-    if(TRUE == H5S_select_shape_same(mem_space, file_space) &&
+    if(TRUE == H5S_SELECT_SHAPE_SAME(mem_space, file_space) &&
             H5S_GET_EXTENT_NDIMS(mem_space) != H5S_GET_EXTENT_NDIMS(file_space)) {
         void *adj_buf = NULL;   /* Pointer to the location in buf corresponding  */
                                 /* to the beginning of the projected mem space.  */
@@ -973,8 +972,7 @@ H5D__typeinfo_init(const H5D_t *dset, hid_t mem_type_id, hbool_t do_write,
         type_info->dst_type_id = mem_type_id;
     } /* end else */
 
-    /*
-     * Locate the type conversion function and dataspace conversion
+    /* Locate the type conversion function and dataspace conversion
      * functions, and set up the element numbering information. If a data
      * type conversion is necessary then register datatype atoms. Data type
      * conversion is necessary if the user has set the `need_bkg' to a high
@@ -1170,7 +1168,7 @@ H5D__ioinfo_adjust(H5D_io_info_t *io_info, const H5D_t *dset,
                 uint32_t                        global_no_collective_cause;
                 hbool_t                         local_error_message_previously_written = FALSE;
                 hbool_t                         global_error_message_previously_written = FALSE;
-                size_t                          index;
+                size_t                          idx;
                 size_t                          cause_strings_len;
                 char                            local_no_collective_cause_string[512] = "";
                 char                            global_no_collective_cause_string[512] = "";
@@ -1192,8 +1190,8 @@ H5D__ioinfo_adjust(H5D_io_info_t *io_info, const H5D_t *dset,
 
                 /* Append each of the "reason for breaking collective I/O" error messages to the
                  * local and global no collective cause strings */
-                for (cause = 1, index = 0; (cause < H5D_MPIO_NO_COLLECTIVE_MAX_CAUSE) && (index < cause_strings_len); cause <<= 1, index++) {
-                    size_t cause_strlen = HDstrlen(cause_strings[index]);
+                for (cause = 1, idx = 0; (cause < H5D_MPIO_NO_COLLECTIVE_MAX_CAUSE) && (idx < cause_strings_len); cause <<= 1, idx++) {
+                    size_t cause_strlen = HDstrlen(cause_strings[idx]);
 
                     if (cause & local_no_collective_cause) {
                         /* Check if there were any previous error messages included. If so, prepend a semicolon
@@ -1202,7 +1200,7 @@ H5D__ioinfo_adjust(H5D_io_info_t *io_info, const H5D_t *dset,
                         if(local_error_message_previously_written)
                             HDstrncat(local_no_collective_cause_string, "; ", 2);
 
-                        HDstrncat(local_no_collective_cause_string, cause_strings[index], cause_strlen);
+                        HDstrncat(local_no_collective_cause_string, cause_strings[idx], cause_strlen);
 
                         local_error_message_previously_written = TRUE;
                     } /* end if */
@@ -1214,7 +1212,7 @@ H5D__ioinfo_adjust(H5D_io_info_t *io_info, const H5D_t *dset,
                         if(global_error_message_previously_written)
                             HDstrncat(global_no_collective_cause_string, "; ", 2);
 
-                        HDstrncat(global_no_collective_cause_string, cause_strings[index], cause_strlen);
+                        HDstrncat(global_no_collective_cause_string, cause_strings[idx], cause_strlen);
 
                         global_error_message_previously_written = TRUE;
                     } /* end if */
@@ -1242,7 +1240,7 @@ H5D__ioinfo_adjust(H5D_io_info_t *io_info, const H5D_t *dset,
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5D__ioinfo_adjust() */
-#endif /*H5_HAVE_PARALLEL*/
+#endif /* H5_HAVE_PARALLEL */
 
 
 /*-------------------------------------------------------------------------
diff --git a/src/H5Dmpio.c b/src/H5Dmpio.c
index 0f1f70d..edb8d99 100644
--- a/src/H5Dmpio.c
+++ b/src/H5Dmpio.c
@@ -82,6 +82,7 @@
 /* Macros to represent the regularity of the selection for multiple chunk IO case. */
 #define H5D_CHUNK_SELECT_REG          1
 
+
 /******************/
 /* Local Typedefs */
 /******************/
@@ -2844,30 +2845,30 @@ H5D__chunk_redistribute_shared_chunks(const H5D_io_info_t *io_info, const H5D_ty
             size_t            mod_data_size;
 
             /* Look up the chunk and get its file and memory dataspaces */
-            if (NULL == (chunk_info = (H5D_chunk_info_t *) H5SL_search(fm->sel_chunks, &chunk_entry->index)))
+            if(NULL == (chunk_info = (H5D_chunk_info_t *) H5SL_search(fm->sel_chunks, &chunk_entry->index)))
                 HGOTO_ERROR(H5E_DATASPACE, H5E_NOTFOUND, FAIL, "can't locate chunk in skip list")
 
             /* Determine size of serialized chunk file dataspace, plus the size of
              * the data being written
              */
-            if (H5S_encode(chunk_info->fspace, &mod_data_p, &mod_data_size) < 0)
+            if(H5S_encode(chunk_info->fspace, &mod_data_p, &mod_data_size) < 0)
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTENCODE, FAIL, "unable to get encoded dataspace size")
 
-            if ((iter_nelmts = H5S_GET_SELECT_NPOINTS(chunk_info->mspace)) < 0)
+            if((iter_nelmts = H5S_GET_SELECT_NPOINTS(chunk_info->mspace)) < 0)
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTCOUNT, FAIL, "dataspace is invalid")
 
             mod_data_size += (size_t) iter_nelmts * type_info->src_type_size;
 
-            if (NULL == (mod_data[num_send_requests] = (unsigned char *) H5MM_malloc(mod_data_size)))
+            if(NULL == (mod_data[num_send_requests] = (unsigned char *) H5MM_malloc(mod_data_size)))
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "couldn't allocate chunk modification send buffer")
 
             /* Serialize the chunk's file dataspace into the buffer */
             mod_data_p = mod_data[num_send_requests];
-            if (H5S_encode(chunk_info->fspace, &mod_data_p, &mod_data_size) < 0)
+            if(H5S_encode(chunk_info->fspace, &mod_data_p, &mod_data_size) < 0)
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTENCODE, FAIL, "unable to encode dataspace")
 
             /* Initialize iterator for memory selection */
-            if (H5S_select_iter_init(mem_iter, chunk_info->mspace, type_info->src_type_size) < 0)
+            if(H5S_select_iter_init(mem_iter, chunk_info->mspace, type_info->src_type_size) < 0)
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize memory selection information")
             mem_iter_init = TRUE;
 
@@ -2878,11 +2879,11 @@ H5D__chunk_redistribute_shared_chunks(const H5D_io_info_t *io_info, const H5D_ty
             /* Send modification data to new owner */
             H5_CHECK_OVERFLOW(mod_data_size, size_t, int)
             H5_CHECK_OVERFLOW(chunk_entry->index, hsize_t, int)
-            if (MPI_SUCCESS != (mpi_code = MPI_Isend(mod_data[num_send_requests], (int) mod_data_size, MPI_BYTE,
+            if(MPI_SUCCESS != (mpi_code = MPI_Isend(mod_data[num_send_requests], (int) mod_data_size, MPI_BYTE,
                     chunk_entry->owners.new_owner, (int) chunk_entry->index, io_info->comm, &send_requests[num_send_requests])))
                 HMPI_GOTO_ERROR(FAIL, "MPI_Isend failed", mpi_code)
 
-            if (mem_iter_init && H5S_SELECT_ITER_RELEASE(mem_iter) < 0)
+            if(mem_iter_init && H5S_SELECT_ITER_RELEASE(mem_iter) < 0)
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "couldn't release memory selection iterator")
             mem_iter_init = FALSE;
 
@@ -3051,11 +3052,11 @@ H5D__mpio_filtered_collective_write_type(H5D_filtered_collective_io_info_t *chun
     } /* end if */
 
 done:
-    if (write_buf_array)
+    if(write_buf_array)
         H5MM_free(write_buf_array);
-    if (file_offset_array)
+    if(file_offset_array)
         H5MM_free(file_offset_array);
-    if (length_array)
+    if(length_array)
         H5MM_free(length_array);
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -3183,53 +3184,53 @@ H5D__filtered_collective_chunk_entry_io(H5D_filtered_collective_io_info_t *chunk
      * from the current process, then apply any modifications from other processes. Finally,
      * filter the newly-updated chunk.
      */
-    switch (io_info->op_type) {
+    switch(io_info->op_type) {
         case H5D_IO_OP_READ:
-            if (NULL == (file_iter = (H5S_sel_iter_t *) H5MM_malloc(sizeof(H5S_sel_iter_t))))
+            if(NULL == (file_iter = (H5S_sel_iter_t *) H5MM_malloc(sizeof(H5S_sel_iter_t))))
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "couldn't allocate file iterator")
 
-            if (H5S_select_iter_init(file_iter, chunk_info->fspace, type_info->src_type_size) < 0)
+            if(H5S_select_iter_init(file_iter, chunk_info->fspace, type_info->src_type_size) < 0)
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize memory selection information")
             file_iter_init = TRUE;
 
-            if ((iter_nelmts = H5S_GET_SELECT_NPOINTS(chunk_info->fspace)) < 0)
+            if((iter_nelmts = H5S_GET_SELECT_NPOINTS(chunk_info->fspace)) < 0)
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTCOUNT, FAIL, "dataspace is invalid")
 
-            if (NULL == (tmp_gath_buf = H5MM_malloc((hsize_t) iter_nelmts * type_info->src_type_size)))
+            if(NULL == (tmp_gath_buf = H5MM_malloc((hsize_t) iter_nelmts * type_info->src_type_size)))
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "couldn't allocate temporary gather buffer")
 
-            if (!H5D__gather_mem(chunk_entry->buf, chunk_info->fspace, file_iter, (size_t) iter_nelmts, tmp_gath_buf))
+            if(!H5D__gather_mem(chunk_entry->buf, chunk_info->fspace, file_iter, (size_t) iter_nelmts, tmp_gath_buf))
                 HGOTO_ERROR(H5E_IO, H5E_READERROR, FAIL, "couldn't gather from chunk buffer")
 
-            if ((iter_nelmts = H5S_GET_SELECT_NPOINTS(chunk_info->mspace)) < 0)
+            if((iter_nelmts = H5S_GET_SELECT_NPOINTS(chunk_info->mspace)) < 0)
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTCOUNT, FAIL, "dataspace is invalid")
 
-            if (H5D__scatter_mem(tmp_gath_buf, chunk_info->mspace, mem_iter, (size_t) iter_nelmts, io_info->u.rbuf) < 0)
-                   HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "couldn't scatter to read buffer")
+            if(H5D__scatter_mem(tmp_gath_buf, chunk_info->mspace, mem_iter, (size_t) iter_nelmts, io_info->u.rbuf) < 0)
+                HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "couldn't scatter to read buffer")
 
             break;
 
         case H5D_IO_OP_WRITE:
-            if ((iter_nelmts = H5S_GET_SELECT_NPOINTS(chunk_info->mspace)) < 0)
+            if((iter_nelmts = H5S_GET_SELECT_NPOINTS(chunk_info->mspace)) < 0)
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTCOUNT, FAIL, "dataspace is invalid")
 
-            if (NULL == (tmp_gath_buf = H5MM_malloc((hsize_t) iter_nelmts * type_info->src_type_size)))
+            if(NULL == (tmp_gath_buf = H5MM_malloc((hsize_t) iter_nelmts * type_info->src_type_size)))
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTALLOC, FAIL, "couldn't allocate temporary gather buffer")
 
             /* Gather modification data from the application write buffer into a temporary buffer */
             if(!H5D__gather_mem(io_info->u.wbuf, chunk_info->mspace, mem_iter, (size_t) iter_nelmts, tmp_gath_buf))
                 HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "couldn't gather from write buffer")
 
-            if (H5S_SELECT_ITER_RELEASE(mem_iter) < 0)
+            if(H5S_SELECT_ITER_RELEASE(mem_iter) < 0)
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "couldn't release selection iterator")
             mem_iter_init = FALSE;
 
             /* Initialize iterator for file selection */
-            if (H5S_select_iter_init(mem_iter, chunk_info->fspace, type_info->dst_type_size) < 0)
+            if(H5S_select_iter_init(mem_iter, chunk_info->fspace, type_info->dst_type_size) < 0)
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize file selection information")
             mem_iter_init = TRUE;
 
-            if ((iter_nelmts = H5S_GET_SELECT_NPOINTS(chunk_info->fspace)) < 0)
+            if((iter_nelmts = H5S_GET_SELECT_NPOINTS(chunk_info->fspace)) < 0)
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTCOUNT, FAIL, "dataspace is invalid")
 
             /* Scatter the owner's modification data into the chunk data buffer according to
@@ -3238,41 +3239,41 @@ H5D__filtered_collective_chunk_entry_io(H5D_filtered_collective_io_info_t *chunk
             if(H5D__scatter_mem(tmp_gath_buf, chunk_info->fspace, mem_iter, (size_t) iter_nelmts, chunk_entry->buf) < 0)
                 HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "couldn't scatter to chunk data buffer")
 
-            if (H5S_SELECT_ITER_RELEASE(mem_iter) < 0)
+            if(H5S_SELECT_ITER_RELEASE(mem_iter) < 0)
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "couldn't release selection iterator")
             mem_iter_init = FALSE;
 
-            if (MPI_SUCCESS != (mpi_code = MPI_Waitall(chunk_entry->async_info.num_receive_requests,
+            if(MPI_SUCCESS != (mpi_code = MPI_Waitall(chunk_entry->async_info.num_receive_requests,
                     chunk_entry->async_info.receive_requests_array, MPI_STATUSES_IGNORE)))
                 HMPI_GOTO_ERROR(FAIL, "MPI_Waitall failed", mpi_code)
 
             /* For each asynchronous receive call previously posted, receive the chunk modification
              * buffer from another rank and update the chunk data
              */
-            for (i = 0; i < (size_t) chunk_entry->async_info.num_receive_requests; i++) {
+            for(i = 0; i < (size_t) chunk_entry->async_info.num_receive_requests; i++) {
                 const unsigned char *mod_data_p;
 
                 /* Decode the process' chunk file dataspace */
                 mod_data_p = chunk_entry->async_info.receive_buffer_array[i];
-                if (NULL == (dataspace = H5S_decode(&mod_data_p)))
+                if(NULL == (dataspace = H5S_decode(&mod_data_p)))
                     HGOTO_ERROR(H5E_DATASET, H5E_CANTDECODE, FAIL, "unable to decode dataspace")
 
-                if (H5S_select_iter_init(mem_iter, dataspace, type_info->dst_type_size) < 0)
+                if(H5S_select_iter_init(mem_iter, dataspace, type_info->dst_type_size) < 0)
                     HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to initialize memory selection information")
                 mem_iter_init = TRUE;
 
-                if ((iter_nelmts = H5S_GET_SELECT_NPOINTS(dataspace)) < 0)
+                if((iter_nelmts = H5S_GET_SELECT_NPOINTS(dataspace)) < 0)
                     HGOTO_ERROR(H5E_DATASET, H5E_CANTCOUNT, FAIL, "dataspace is invalid")
 
                 /* Update the chunk data with the received modification data */
                 if(H5D__scatter_mem(mod_data_p, dataspace, mem_iter, (size_t) iter_nelmts, chunk_entry->buf) < 0)
                     HGOTO_ERROR(H5E_DATASET, H5E_WRITEERROR, FAIL, "couldn't scatter to write buffer")
 
-                if (H5S_SELECT_ITER_RELEASE(mem_iter) < 0)
+                if(H5S_SELECT_ITER_RELEASE(mem_iter) < 0)
                     HGOTO_ERROR(H5E_DATASET, H5E_CANTFREE, FAIL, "couldn't release selection iterator")
                 mem_iter_init = FALSE;
-                if (dataspace) {
-                    if (H5S_close(dataspace) < 0)
+                if(dataspace) {
+                    if(H5S_close(dataspace) < 0)
                         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTFREE, FAIL, "can't close dataspace")
                     dataspace = NULL;
                 }
diff --git a/src/H5Doh.c b/src/H5Doh.c
index f8ce69f..588123b 100644
--- a/src/H5Doh.c
+++ b/src/H5Doh.c
@@ -189,15 +189,15 @@ H5O__dset_isa(const H5O_t *oh)
 
     /* Datatype */
     if((exists = H5O_msg_exists_oh(oh, H5O_DTYPE_ID)) < 0)
-	HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to read object header")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to read object header")
     else if(!exists)
-	HGOTO_DONE(FALSE)
+        HGOTO_DONE(FALSE)
 
     /* Layout */
     if((exists = H5O_msg_exists_oh(oh, H5O_SDSPACE_ID)) < 0)
-	HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to read object header")
+        HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to read object header")
     else if(!exists)
-	HGOTO_DONE(FALSE)
+        HGOTO_DONE(FALSE)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
diff --git a/src/H5Dscatgath.c b/src/H5Dscatgath.c
index 0d88812..0e0edf7 100644
--- a/src/H5Dscatgath.c
+++ b/src/H5Dscatgath.c
@@ -27,6 +27,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5FLprivate.h"	/* Free Lists                           */
 #include "H5Iprivate.h"		/* IDs                                  */
+#include "H5MMprivate.h"	/* Memory management			*/
 
 
 /****************/
@@ -559,11 +560,9 @@ H5D__scatgath_read(const H5D_io_info_t *io_info, const H5D_type_info_t *type_inf
 
                 if(H5Z_xform_eval(data_transform, type_info->tconv_buf, smine_nelmts, type_info->mem_type) < 0)
                     HGOTO_ERROR(H5E_DATASET, H5E_BADVALUE, FAIL, "Error performing data transform")
-            } /* end if */
+            }
 
-            /*
-             * Scatter the data into memory.
-             */
+            /* Scatter the data into memory */
             if(H5D__scatter_mem(type_info->tconv_buf, mem_space, mem_iter, smine_nelmts, buf/*out*/) < 0)
                 HGOTO_ERROR(H5E_DATASET, H5E_READERROR, FAIL, "scatter failed")
         } /* end else */
@@ -691,9 +690,9 @@ H5D__scatgath_write(const H5D_io_info_t *io_info, const H5D_type_info_t *type_in
                 if(H5CX_get_data_transform(&data_transform) < 0)
                     HGOTO_ERROR(H5E_DATASET, H5E_CANTGET, FAIL, "can't get data transform info")
 
-	        if(H5Z_xform_eval(data_transform, type_info->tconv_buf, smine_nelmts, type_info->mem_type) < 0)
-		    HGOTO_ERROR(H5E_DATASET, H5E_BADVALUE, FAIL, "Error performing data transform")
-            } /* end if */
+                if(H5Z_xform_eval(data_transform, type_info->tconv_buf, smine_nelmts, type_info->mem_type) < 0)
+                    HGOTO_ERROR(H5E_DATASET, H5E_BADVALUE, FAIL, "Error performing data transform")
+            }
 
             /*
              * Perform datatype conversion.
diff --git a/src/H5Dselect.c b/src/H5Dselect.c
index 0ec3423..8b84c3e 100644
--- a/src/H5Dselect.c
+++ b/src/H5Dselect.c
@@ -11,7 +11,7 @@
  * help@hdfgroup.org.                                                        *
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
-/* Programmer:  Quincey Koziol <koziol@ncsa.uiuc.ued>
+/* Programmer:  Quincey Koziol
  *              Thursday, September 30, 2004
  *
  * Purpose:	Dataspace I/O functions.
@@ -227,6 +227,8 @@ H5D__select_io(const H5D_io_info_t *io_info, size_t elmt_size,
 
             /* Decrement number of elements left to process */
             HDassert(((size_t)tmp_file_len % elmt_size) == 0);
+            if(elmt_size == 0)
+                HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "Resulted in division by zero")
             nelmts -= ((size_t)tmp_file_len / elmt_size);
         } /* end while */
     } /* end else */
diff --git a/src/H5EAdbg.c b/src/H5EAdbg.c
index 46e87c5..4e033dc 100644
--- a/src/H5EAdbg.c
+++ b/src/H5EAdbg.c
@@ -13,9 +13,9 @@
 
 /*-------------------------------------------------------------------------
  *
- * Created:        H5EAdbg.c
- *            Sep 11 2008
- *            Quincey Koziol <koziol@hdfgroup.org>
+ * Created:         H5EAdbg.c
+ *                  Sep 11 2008
+ *                  Quincey Koziol
  *
  * Purpose:        Dump debugging information about an extensible array.
  *
@@ -37,9 +37,9 @@
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"        /* Generic Functions            */
-#include "H5Eprivate.h"        /* Error handling              */
-#include "H5EApkg.h"        /* Extensible Arrays            */
+#include "H5private.h"          /* Generic Functions            */
+#include "H5Eprivate.h"         /* Error handling               */
+#include "H5EApkg.h"            /* Extensible Arrays            */
 
 
 /****************/
@@ -77,17 +77,16 @@
 /*******************/
 
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5EA__hdr_debug
  *
- * Purpose:    Prints debugging info about a extensible array header.
+ * Purpose:     Prints debugging info about a extensible array header.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Quincey Koziol
- *        koziol@hdfgroup.org
- *        Sep 11 2008
+ * Programmer:  Quincey Koziol
+ *              Sep 11 2008
  *
  *-------------------------------------------------------------------------
  */
@@ -117,7 +116,7 @@ H5EA__hdr_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent,
 
     /* Load the extensible array header */
     if(NULL == (hdr = H5EA__hdr_protect(f, addr, dbg_ctx, H5AC__READ_ONLY_FLAG)))
-    H5E_THROW(H5E_CANTPROTECT, "unable to load extensible array header")
+        H5E_THROW(H5E_CANTPROTECT, "unable to load extensible array header")
 
     /* Print opening message */
     HDfprintf(stream, "%*sExtensible Array Header...\n", indent, "");
@@ -169,11 +168,11 @@ CATCH
     if(dbg_ctx && cls->dst_dbg_ctx(dbg_ctx) < 0)
         H5E_THROW(H5E_CANTRELEASE, "unable to release extensible array debugging context")
     if(hdr && H5EA__hdr_unprotect(hdr, H5AC__NO_FLAGS_SET) < 0)
-    H5E_THROW(H5E_CANTUNPROTECT, "unable to release extensible array header")
+        H5E_THROW(H5E_CANTUNPROTECT, "unable to release extensible array header")
 
 END_FUNC(PKG)   /* end H5EA__hdr_debug() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5EA__iblock_debug
  *
@@ -384,21 +383,20 @@ CATCH
     if(sblock && H5EA__sblock_unprotect(sblock, H5AC__NO_FLAGS_SET) < 0)
         H5E_THROW(H5E_CANTUNPROTECT, "unable to release extensible array super block")
     if(hdr && H5EA__hdr_unprotect(hdr, H5AC__NO_FLAGS_SET) < 0)
-    H5E_THROW(H5E_CANTUNPROTECT, "unable to release extensible array header")
+        H5E_THROW(H5E_CANTUNPROTECT, "unable to release extensible array header")
 
 END_FUNC(PKG)   /* end H5EA__sblock_debug() */
 
-
+
 /*-------------------------------------------------------------------------
  * Function:    H5EA__dblock_debug
  *
- * Purpose:    Prints debugging info about a extensible array data block.
+ * Purpose:     Prints debugging info about a extensible array data block.
  *
- * Return:    Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:    Quincey Koziol
- *        koziol@hdfgroup.org
- *        Sep 22 2008
+ * Programmer:  Quincey Koziol
+ *              Sep 22 2008
  *
  *-------------------------------------------------------------------------
  */
@@ -432,7 +430,7 @@ H5EA__dblock_debug(H5F_t *f, haddr_t addr, FILE *stream, int indent,
 
     /* Load the extensible array header */
     if(NULL == (hdr = H5EA__hdr_protect(f, hdr_addr, dbg_ctx, H5AC__READ_ONLY_FLAG)))
-    H5E_THROW(H5E_CANTPROTECT, "unable to load extensible array header")
+        H5E_THROW(H5E_CANTPROTECT, "unable to load extensible array header")
 
     /* Protect data block */
     /* (Note: setting parent of data block to 'hdr' for this operation should be OK -QAK) */
@@ -466,7 +464,7 @@ CATCH
     if(dblock && H5EA__dblock_unprotect(dblock, H5AC__NO_FLAGS_SET) < 0)
         H5E_THROW(H5E_CANTUNPROTECT, "unable to release extensible array data block")
     if(hdr && H5EA__hdr_unprotect(hdr, H5AC__NO_FLAGS_SET) < 0)
-    H5E_THROW(H5E_CANTUNPROTECT, "unable to release extensible array header")
+        H5E_THROW(H5E_CANTUNPROTECT, "unable to release extensible array header")
 
 END_FUNC(PKG)   /* end H5EA__dblock_debug() */
 
diff --git a/src/H5FL.c b/src/H5FL.c
index a662713..66d27fb 100644
--- a/src/H5FL.c
+++ b/src/H5FL.c
@@ -130,17 +130,23 @@ static H5FL_track_t *H5FL_out_head_g = NULL;
 #endif /* H5FL_TRACK */
 
 /* Forward declarations of local static functions */
+static void * H5FL__malloc(size_t mem_size);
+static herr_t H5FL__reg_init(H5FL_reg_head_t *head);
 static herr_t H5FL__reg_gc(void);
 static herr_t H5FL__reg_gc_list(H5FL_reg_head_t *head);
 static int H5FL__reg_term(void);
-static herr_t H5FL__arr_gc(void);
-static herr_t H5FL__arr_gc_list(H5FL_arr_head_t *head);
-static int H5FL__arr_term(void);
-static herr_t H5FL__blk_gc(void);
+static H5FL_blk_node_t *H5FL__blk_find_list(H5FL_blk_node_t **head, size_t size);
+static H5FL_blk_node_t *H5FL__blk_create_list(H5FL_blk_node_t **head, size_t size);
+static herr_t H5FL__blk_init(H5FL_blk_head_t *head);
 static herr_t H5FL__blk_gc_list(H5FL_blk_head_t *head);
+static herr_t H5FL__blk_gc(void);
 static int H5FL__blk_term(void);
-static herr_t H5FL__fac_gc(void);
+static herr_t H5FL__arr_init(H5FL_arr_head_t *head);
+static herr_t H5FL__arr_gc_list(H5FL_arr_head_t *head);
+static herr_t H5FL__arr_gc(void);
+static int H5FL__arr_term(void);
 static herr_t H5FL__fac_gc_list(H5FL_fac_head_t *head);
+static herr_t H5FL__fac_gc(void);
 static int H5FL__fac_term_all(void);
 
 /* Declare a free list to manage the H5FL_blk_node_t struct */
@@ -217,7 +223,7 @@ H5FL_term_package(void)
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FL_malloc
+ * Function:	H5FL__malloc
  *
  * Purpose:	Attempt to allocate space using malloc.  If malloc fails, garbage
  *      collect and try again.  If malloc fails again, then return NULL.
@@ -228,16 +234,14 @@ H5FL_term_package(void)
  * Programmer:	Quincey Koziol
  *              Tuesday, August 1, 2000
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static void *
-H5FL_malloc(size_t mem_size)
+H5FL__malloc(size_t mem_size)
 {
     void *ret_value = NULL;     /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /* Attempt to allocate the memory requested */
     if(NULL==(ret_value=H5MM_malloc(mem_size))) {
@@ -252,11 +256,11 @@ H5FL_malloc(size_t mem_size)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-}   /* end H5FL_malloc() */
+}   /* end H5FL__malloc() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FL_reg_init
+ * Function:	H5FL__reg_init
  *
  * Purpose:	Initialize a free list for a certain type.  Right now, this just
  *      adds the free list to the list of things to garbage collect.
@@ -267,17 +271,15 @@ done:
  * Programmer:	Quincey Koziol
  *              Friday, March 24, 2000
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FL_reg_init(H5FL_reg_head_t *head)
+H5FL__reg_init(H5FL_reg_head_t *head)
 {
     H5FL_reg_gc_node_t *new_node;   /* Pointer to the node for the new list to garbage collect */
     herr_t ret_value=SUCCEED;   /* return value*/
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /* Allocate a new garbage collection node */
     if(NULL == (new_node = (H5FL_reg_gc_node_t *)H5MM_malloc(sizeof(H5FL_reg_gc_node_t))))
@@ -304,7 +306,7 @@ H5FL_reg_init(H5FL_reg_head_t *head)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-}   /* end H5FL_reg_init() */
+} /* end H5FL__reg_init() */
 
 
 /*-------------------------------------------------------------------------
@@ -317,8 +319,6 @@ done:
  * Programmer:	Quincey Koziol
  *              Friday, March 24, 2000
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -403,8 +403,6 @@ done:
  * Programmer:	Quincey Koziol
  *              Friday, March 24, 2000
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -419,7 +417,7 @@ H5FL_reg_malloc(H5FL_reg_head_t *head H5FL_TRACK_PARAMS)
 
     /* Make certain the list is initialized first */
     if(!head->init)
-        if(H5FL_reg_init(head)<0)
+        if(H5FL__reg_init(head) < 0)
             HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, NULL, "can't initialize 'regular' blocks")
 
     /* Check for nodes available on the free list first */
@@ -438,7 +436,7 @@ H5FL_reg_malloc(H5FL_reg_head_t *head H5FL_TRACK_PARAMS)
     } /* end if */
     /* Otherwise allocate a node */
     else {
-        if (NULL==(ret_value = H5FL_malloc(head->size)))
+        if(NULL == (ret_value = H5FL__malloc(head->size)))
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
 
         /* Increment the number of blocks allocated in list */
@@ -480,8 +478,6 @@ done:
  * Programmer:	Quincey Koziol
  *              Monday, December 23, 2002
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -524,35 +520,34 @@ static herr_t
 H5FL__reg_gc_list(H5FL_reg_head_t *head)
 {
     H5FL_reg_node_t *free_list; /* Pointer to nodes in free list being garbage collected */
-    size_t total_mem;   /* Total memory used on list */
 
     FUNC_ENTER_STATIC_NOERR
 
-    /* Calculate the total memory used on this list */
-    total_mem = head->onlist * head->size;
-
     /* For each free list being garbage collected, walk through the nodes and free them */
     free_list = head->list;
     while(free_list != NULL) {
-        void *tmp;          /* Temporary node pointer */
+        H5FL_reg_node_t *tmp;          /* Temporary node pointer */
 
+        /* Get the pointer to the next node */
         tmp = free_list->next;
 
-        /* Decrement the count of nodes allocated and free the node */
-        head->allocated--;
-
+        /* Free the block */
         H5MM_free(free_list);
 
-        free_list = (H5FL_reg_node_t *)tmp;
+        /* Advance to the next node */
+        free_list = tmp;
     } /* end while */
 
+    /* Decrement the count of nodes allocated and free the node */
+    head->allocated -= head->onlist;
+
+    /* Decrement global count of free memory on "regular" lists */
+    H5FL_reg_gc_head.mem_freed -= (head->onlist * head->size);
+
     /* Indicate no free nodes on the free list */
     head->list = NULL;
     head->onlist = 0;
 
-    /* Decrement global count of free memory on "regular" lists */
-    H5FL_reg_gc_head.mem_freed -= total_mem;
-
     FUNC_LEAVE_NOAPI(SUCCEED)
 }   /* end H5FL__reg_gc_list() */
 
@@ -568,10 +563,6 @@ H5FL__reg_gc_list(H5FL_reg_head_t *head)
  * Programmer:	Quincey Koziol
  *              Friday, March 24, 2000
  *
- * Modifications:
- *  Broke into two parts, one for looping over all the free lists and
- *      another for freeing each list - QAK 7/25/00
- *
  *-------------------------------------------------------------------------
  */
 static herr_t
@@ -670,7 +661,7 @@ HDprintf("%s: head->name = %s, head->allocated = %d\n", FUNC, H5FL_reg_gc_head.f
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FL_blk_find_list
+ * Function:	H5FL__blk_find_list
  *
  * Purpose:	Finds the free list for blocks of a given size.  Also moves that
  *      free list node to the head of the priority queue (if it isn't there
@@ -684,16 +675,14 @@ HDprintf("%s: head->name = %s, head->allocated = %d\n", FUNC, H5FL_reg_gc_head.f
  * Programmer:	Quincey Koziol
  *		Thursday, March  23, 2000
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static H5FL_blk_node_t *
-H5FL_blk_find_list(H5FL_blk_node_t **head, size_t size)
+H5FL__blk_find_list(H5FL_blk_node_t **head, size_t size)
 {
     H5FL_blk_node_t *temp = NULL;  /* Temp. pointer to node in the native list */
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
     /* Find the correct free list */
     temp=*head;
@@ -729,11 +718,11 @@ H5FL_blk_find_list(H5FL_blk_node_t **head, size_t size)
     } /* end if */
 
     FUNC_LEAVE_NOAPI(temp)
-} /* end H5FL_blk_find_list() */
+} /* end H5FL__blk_find_list() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FL_blk_create_list
+ * Function:	H5FL__blk_create_list
  *
  * Purpose:	Creates a new free list for blocks of the given size at the
  *      head of the priority queue.
@@ -745,47 +734,38 @@ H5FL_blk_find_list(H5FL_blk_node_t **head, size_t size)
  * Programmer:	Quincey Koziol
  *		Thursday, March  23, 2000
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static H5FL_blk_node_t *
-H5FL_blk_create_list(H5FL_blk_node_t **head, size_t size)
+H5FL__blk_create_list(H5FL_blk_node_t **head, size_t size)
 {
-    H5FL_blk_node_t *temp;  /* Temp. pointer to node in the list */
     H5FL_blk_node_t *ret_value = NULL;          /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /* Allocate room for the new free list node */
-    if(NULL==(temp=H5FL_MALLOC(H5FL_blk_node_t)))
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for chunk info")
+    if(NULL == (ret_value = H5FL_CALLOC(H5FL_blk_node_t)))
+        HGOTO_ERROR(H5E_RESOURCE, H5E_CANTALLOC, NULL, "memory allocation failed for chunk info")
 
     /* Set the correct values for the new free list */
-    temp->size=size;
-    temp->list=NULL;
+    ret_value->size = size;
 
     /* Attach to head of priority queue */
-    if(*head==NULL) {
-        *head=temp;
-        temp->next=temp->prev=NULL;
-    } /* end if */
+    if(NULL == *head)
+        *head = ret_value;
     else {
-        temp->next=*head;
-        (*head)->prev=temp;
-        temp->prev=NULL;
-        *head=temp;
+        ret_value->next = *head;
+        (*head)->prev = ret_value;
+        *head = ret_value;
     } /* end else */
 
-    ret_value=temp;
-
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FL_blk_create_list() */
+} /* end H5FL__blk_create_list() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FL_blk_init
+ * Function:	H5FL__blk_init
  *
  * Purpose:	Initialize a priority queue of a certain type.  Right now, this just
  *      adds the PQ to the list of things to garbage collect.
@@ -796,17 +776,15 @@ done:
  * Programmer:	Quincey Koziol
  *              Saturday, March 25, 2000
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FL_blk_init(H5FL_blk_head_t *head)
+H5FL__blk_init(H5FL_blk_head_t *head)
 {
     H5FL_blk_gc_node_t *new_node;   /* Pointer to the node for the new list to garbage collect */
     herr_t ret_value=SUCCEED;       /* return value*/
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /* Allocate a new garbage collection node */
     if(NULL == (new_node = (H5FL_blk_gc_node_t *)H5MM_malloc(sizeof(H5FL_blk_gc_node_t))))
@@ -824,7 +802,7 @@ H5FL_blk_init(H5FL_blk_head_t *head)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-}   /* end H5FL_blk_init() */
+}   /* end H5FL__blk_init() */
 
 
 /*-------------------------------------------------------------------------
@@ -839,8 +817,6 @@ done:
  * Programmer:	Quincey Koziol
  *		Monday, December 16, 2002
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 htri_t
@@ -856,10 +832,11 @@ H5FL_blk_free_block_avail(H5FL_blk_head_t *head, size_t size)
 
     /* check if there is a free list for blocks of this size */
     /* and if there are any blocks available on the list */
-    if((free_list = H5FL_blk_find_list(&(head->head), size)) != NULL && free_list->list != NULL)
+    if((free_list = H5FL__blk_find_list(&(head->head), size)) != NULL && free_list->list != NULL)
         ret_value = TRUE;
     else
         ret_value = FALSE;
+
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5FL_blk_free_block_avail() */
 
@@ -878,8 +855,6 @@ H5FL_blk_free_block_avail(H5FL_blk_head_t *head, size_t size)
  * Programmer:	Quincey Koziol
  *		Thursday, March  23, 2000
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -897,31 +872,40 @@ H5FL_blk_malloc(H5FL_blk_head_t *head, size_t size H5FL_TRACK_PARAMS)
 
     /* Make certain the list is initialized first */
     if(!head->init)
-        if(H5FL_blk_init(head)<0)
+        if(H5FL__blk_init(head) < 0)
             HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, NULL, "can't initialize 'block' list")
 
     /* check if there is a free list for blocks of this size */
     /* and if there are any blocks available on the list */
-    if((free_list=H5FL_blk_find_list(&(head->head),size))!=NULL && free_list->list!=NULL) {
+    if(NULL != (free_list = H5FL__blk_find_list(&(head->head), size)) && NULL != free_list->list) {
         /* Remove the first node from the free list */
         temp=free_list->list;
         free_list->list=free_list->list->next;
 
         /* Decrement the number of blocks & memory used on free list */
+        free_list->onlist--;
         head->onlist--;
         head->list_mem-=size;
 
         /* Decrement the amount of global "block" free list memory in use */
         H5FL_blk_gc_head.mem_freed-=size;
-
     } /* end if */
     /* No free list available, or there are no nodes on the list, allocate a new node to give to the user */
     else {
+        /* Check if there was no free list for native blocks of this size */
+        if(NULL == free_list)
+            /* Create a new list node and insert it to the queue */
+            free_list = H5FL__blk_create_list(&(head->head), size);
+        HDassert(free_list);
+
         /* Allocate new node, with room for the page info header and the actual page data */
-        if(NULL == (temp = (H5FL_blk_list_t *)H5FL_malloc(sizeof(H5FL_blk_list_t) + H5FL_TRACK_SIZE + size)))
+        if(NULL == (temp = (H5FL_blk_list_t *)H5FL__malloc(sizeof(H5FL_blk_list_t) + H5FL_TRACK_SIZE + size)))
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for chunk")
 
-        /* Increment the number of blocks allocated */
+        /* Increment the number of blocks of this size */
+        free_list->allocated++;
+
+        /* Increment the total number of blocks allocated */
         head->allocated++;
     } /* end else */
 
@@ -970,8 +954,6 @@ done:
  * Programmer:	Quincey Koziol
  *		Monday, December 23, 2002
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -1011,8 +993,6 @@ done:
  * Programmer:	Quincey Koziol
  *		Thursday, March  23, 2000
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -1055,7 +1035,7 @@ H5FL_blk_free(H5FL_blk_head_t *head, void *block)
 #endif /* H5FL_TRACK */
 
     /* Get the pointer to the native block info header in front of the native block to free */
-    temp=(H5FL_blk_list_t *)((unsigned char *)block-sizeof(H5FL_blk_list_t)); /*lint !e826 Pointer-to-pointer cast is appropriate here */
+    temp = (H5FL_blk_list_t *)((void *)((unsigned char *)block - (sizeof(H5FL_blk_list_t) + H5FL_TRACK_SIZE))); /*lint !e826 Pointer-to-pointer cast is appropriate here */
 
     /* Save the block's size for later */
     free_size=temp->size;
@@ -1064,20 +1044,18 @@ H5FL_blk_free(H5FL_blk_head_t *head, void *block)
     HDmemset(temp,255,free_size + sizeof(H5FL_blk_list_t) + H5FL_TRACK_SIZE);
 #endif /* H5FL_DEBUG */
 
-    /* check if there is a free list for native blocks of this size */
-    if((free_list=H5FL_blk_find_list(&(head->head),free_size))==NULL) {
+    /* Check if there is a free list for native blocks of this size */
+    if(NULL == (free_list = H5FL__blk_find_list(&(head->head), free_size)))
         /* No free list available, create a new list node and insert it to the queue */
-        free_list=H5FL_blk_create_list(&(head->head),free_size);
-        HDassert(free_list);
-    } /* end if */
+        free_list = H5FL__blk_create_list(&(head->head), free_size);
+    HDassert(free_list);
 
     /* Prepend the free'd native block to the front of the free list */
-    if(free_list!=NULL) {
-        temp->next=free_list->list; /* Overwrites the size field in union */
-        free_list->list=temp;
-    } /* end if */
+    temp->next = free_list->list;       /* Note: Overwrites the size field in union */
+    free_list->list = temp;
 
     /* Increment the number of blocks on free list */
+    free_list->onlist++;
     head->onlist++;
     head->list_mem += free_size;
 
@@ -1113,8 +1091,6 @@ done:
  * Programmer:	Quincey Koziol
  *		Thursday, March  23, 2000
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -1133,7 +1109,7 @@ H5FL_blk_realloc(H5FL_blk_head_t *head, void *block, size_t new_size H5FL_TRACK_
         H5FL_blk_list_t *temp;      /* Temp. ptr to the new block node allocated */
 
         /* Get the pointer to the chunk info header in front of the chunk to free */
-        temp=(H5FL_blk_list_t *)((unsigned char *)block - (sizeof(H5FL_blk_list_t) + H5FL_TRACK_SIZE)); /*lint !e826 Pointer-to-pointer cast is appropriate here */
+        temp = (H5FL_blk_list_t *)((void *)((unsigned char *)block - (sizeof(H5FL_blk_list_t) + H5FL_TRACK_SIZE))); /*lint !e826 Pointer-to-pointer cast is appropriate here */
 
         /* check if we are actually changing the size of the buffer */
         if(new_size!=temp->size) {
@@ -1191,44 +1167,70 @@ done:
 static herr_t
 H5FL__blk_gc_list(H5FL_blk_head_t *head)
 {
+    H5FL_blk_node_t *blk_head;     /* Temp. ptr to the free list page node */
+
     FUNC_ENTER_STATIC_NOERR
 
     /* Loop through all the nodes in the block free list queue */
-    while(head->head != NULL) {
-        H5FL_blk_list_t *list; /* The free list of native nodes of a particular size */
-        void *temp;     /* Temp. ptr to the free list page node */
+    blk_head = head->head;
+    while(blk_head != NULL) {
+        H5FL_blk_node_t *blk_next;      /* Temp. ptr to the next free list node */
+        H5FL_blk_list_t *list;          /* The free list of native nodes of a particular size */
 
-        temp = head->head->next;
+        /* Sanity check */
+        HDassert((blk_head->onlist && blk_head->list) || (0 == blk_head->onlist && NULL == blk_head->list));
 
         /* Loop through all the blocks in the free list, freeing them */
-        list = head->head->list;
+        list = blk_head->list;
         while(list != NULL) {
-            void *next;     /* Temp. ptr to the free list list node */
+            H5FL_blk_list_t *next;     /* Temp. ptr to the free list list node */
 
+            /* Get the pointer to the next node */
             next = list->next;
 
-            /* Decrement the number of blocks & memory allocated from this PQ */
-            head->allocated--;
-            head->list_mem -= head->head->size;
-
-            /* Decrement global count of free memory on "block" lists */
-            H5FL_blk_gc_head.mem_freed -= head->head->size;
-
             /* Free the block */
             H5MM_free(list);
 
-            list = (H5FL_blk_list_t *)next;
+            /* Advance to the next node */
+            list = next;
         } /* end while */
 
-        /* Free the free list node */
-        head->head = H5FL_FREE(H5FL_blk_node_t, head->head);
+        /* Decrement the number of blocks allocated from this list */
+        blk_head->allocated -= blk_head->onlist;
+        head->allocated -= blk_head->onlist;
+
+        /* Decrement count of free memory on this "block" list */
+        head->list_mem -= (blk_head->onlist * blk_head->size);
+
+        /* Decrement global count of free memory on "block" lists */
+        H5FL_blk_gc_head.mem_freed -= (blk_head->onlist * blk_head->size);
+
+        /* Indicate no free nodes on the free list */
+        blk_head->list = NULL;
+        blk_head->onlist = 0;
 
-        /* Advance to the next free list */
-        head->head = (H5FL_blk_node_t *)temp;
+        /* Get pointer to next node */
+        blk_next = blk_head->next;
+
+        /* Check for list completely unused now */
+        if(0 == blk_head->allocated) {
+            /* Patch this node out of the PQ */
+            if(head->head == blk_head)
+                head->head = blk_head->next;
+            if(blk_head->prev)
+                blk_head->prev->next = blk_head->next;
+            if(blk_head->next)
+                blk_head->next->prev = blk_head->prev;
+
+            /* Free the free list node */
+            H5FL_FREE(H5FL_blk_node_t, blk_head);
+        } /* end if */
+
+        /* Advance to the next node */
+        blk_head = blk_next;
     } /* end while */
 
     /* Indicate no free nodes on the free list */
-    head->head = NULL;
     head->onlist = 0;
 
     /* Double check that all the memory on this list is recycled */
@@ -1257,7 +1259,7 @@ H5FL__blk_gc(void)
     H5FL_blk_gc_node_t *gc_node;    /* Pointer into the list of things to garbage collect */
     herr_t ret_value = SUCCEED;   /* return value*/
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /* Walk through all the free lists, free()'ing the nodes */
     gc_node = H5FL_blk_gc_head.first;
@@ -1341,7 +1343,7 @@ HDprintf("%s: head->name = %s, head->allocated = %d\n", FUNC, H5FL_blk_gc_head.f
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FL_arr_init
+ * Function:	H5FL__arr_init
  *
  * Purpose:	Initialize a free list for a arrays of certain type.  Right now,
  *      this just adds the free list to the list of things to garbage collect.
@@ -1352,18 +1354,16 @@ HDprintf("%s: head->name = %s, head->allocated = %d\n", FUNC, H5FL_blk_gc_head.f
  * Programmer:	Quincey Koziol
  *              Saturday, March 25, 2000
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FL_arr_init(H5FL_arr_head_t *head)
+H5FL__arr_init(H5FL_arr_head_t *head)
 {
     H5FL_gc_arr_node_t *new_node;   /* Pointer to the node for the new list to garbage collect */
     size_t u;                       /* Local index variable */
     herr_t ret_value=SUCCEED;       /* return value*/
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /* Allocate a new garbage collection node */
     if(NULL == (new_node = (H5FL_gc_arr_node_t *)H5MM_malloc(sizeof(H5FL_gc_arr_node_t))))
@@ -1389,7 +1389,7 @@ H5FL_arr_init(H5FL_arr_head_t *head)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-}   /* end H5FL_arr_init() */
+} /* end H5FL__arr_init() */
 
 
 /*-------------------------------------------------------------------------
@@ -1403,8 +1403,6 @@ done:
  * Programmer:	Quincey Koziol
  *              Friday, March 24, 2000
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -1430,7 +1428,7 @@ H5FL_arr_free(H5FL_arr_head_t *head, void *obj)
     HDassert(head->init);
 
     /* Get the pointer to the info header in front of the block to free */
-    temp=(H5FL_arr_list_t *)((unsigned char *)obj-sizeof(H5FL_arr_list_t)); /*lint !e826 Pointer-to-pointer cast is appropriate here */
+    temp = (H5FL_arr_list_t *)((void *)((unsigned char *)obj - sizeof(H5FL_arr_list_t))); /*lint !e826 Pointer-to-pointer cast is appropriate here */
 
     /* Get the number of elements */
     free_nelem=temp->nelem;
@@ -1481,8 +1479,6 @@ done:
  * Programmer:	Quincey Koziol
  *              Saturday, March 25, 2000
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -1500,7 +1496,7 @@ H5FL_arr_malloc(H5FL_arr_head_t *head, size_t elem)
 
     /* Make certain the list is initialized first */
     if(!head->init)
-        if(H5FL_arr_init(head)<0)
+        if(H5FL__arr_init(head) < 0)
             HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, NULL, "can't initialize 'array' blocks")
 
     /* Sanity check that the number of elements is supported */
@@ -1527,10 +1523,13 @@ H5FL_arr_malloc(H5FL_arr_head_t *head, size_t elem)
     } /* end if */
     /* Otherwise allocate a node */
     else {
-        if(NULL == (new_obj = (H5FL_arr_list_t *)H5FL_malloc(sizeof(H5FL_arr_list_t)+mem_size)))
+        if(NULL == (new_obj = (H5FL_arr_list_t *)H5FL__malloc(sizeof(H5FL_arr_list_t)+mem_size)))
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
 
-        /* Increment the number of blocks allocated in list */
+        /* Increment the number of blocks of this size */
+        head->list_arr[elem].allocated++;
+
+        /* Increment the number of blocks allocated in list, of all sizes */
         head->allocated++;
     } /* end else */
 
@@ -1556,8 +1555,6 @@ done:
  * Programmer:	Quincey Koziol
  *              Monday, December 23, 2002
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -1594,8 +1591,6 @@ done:
  * Programmer:	Quincey Koziol
  *              Saturday, March 25, 2000
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -1619,7 +1614,7 @@ H5FL_arr_realloc(H5FL_arr_head_t *head, void * obj, size_t new_elem)
         HDassert((int)new_elem <= head->maxelem);
 
         /* Get the pointer to the info header in front of the block to free */
-        temp = (H5FL_arr_list_t *)((unsigned char *)obj - sizeof(H5FL_arr_list_t)); /*lint !e826 Pointer-to-pointer cast is appropriate here */
+        temp = (H5FL_arr_list_t *)((void *)((unsigned char *)obj - sizeof(H5FL_arr_list_t))); /*lint !e826 Pointer-to-pointer cast is appropriate here */
 
         /* Check if the size is really changing */
         if(temp->nelem != new_elem) {
@@ -1667,34 +1662,35 @@ H5FL__arr_gc_list(H5FL_arr_head_t *head)
     for(u = 0; u < (unsigned)head->maxelem; u++) {
         if(head->list_arr[u].onlist > 0) {
             H5FL_arr_list_t *arr_free_list; /* Pointer to nodes in free list being garbage collected */
-            size_t total_mem;   /* Total memory used on list */
-
-            /* Calculate the total memory used on this list */
-            total_mem = head->list_arr[u].onlist * head->list_arr[u].size;
 
             /* For each free list being garbage collected, walk through the nodes and free them */
             arr_free_list = head->list_arr[u].list;
             while(arr_free_list != NULL) {
-                void *tmp;      /* Temporary node pointer */
+                H5FL_arr_list_t *tmp;      /* Temporary node pointer */
 
+                /* Get the pointer to the next node */
                 tmp = arr_free_list->next;
 
-                /* Decrement the count of nodes allocated and free the node */
-                head->allocated--;
+                /* Free the node */
                 H5MM_free(arr_free_list);
 
-                arr_free_list = (H5FL_arr_list_t *)tmp;
+                /* Advance to the next node */
+                arr_free_list = tmp;
             } /* end while */
 
-            /* Indicate no free nodes on the free list */
-            head->list_arr[u].list = NULL;
-            head->list_arr[u].onlist = 0;
+            /* Decrement the count of nodes allocated */
+            head->list_arr[u].allocated -= head->list_arr[u].onlist;
+            head->allocated -= head->list_arr[u].onlist;
 
             /* Decrement count of free memory on this "array" list */
-            head->list_mem -= total_mem;
+            head->list_mem -= (head->list_arr[u].onlist * head->list_arr[u].size);
 
             /* Decrement global count of free memory on "array" lists */
-            H5FL_arr_gc_head.mem_freed -= total_mem;
+            H5FL_arr_gc_head.mem_freed -= (head->list_arr[u].onlist * head->list_arr[u].size);
+
+            /* Indicate no free nodes on the free list */
+            head->list_arr[u].list = NULL;
+            head->list_arr[u].onlist = 0;
         } /* end if */
     } /* end for */
 
@@ -1820,8 +1816,6 @@ HDprintf("%s: head->name = %s, head->allocated = %d\n", FUNC, H5FL_arr_gc_head.f
  * Programmer:	Quincey Koziol
  *              Saturday, April 3, 2004
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -1856,8 +1850,6 @@ H5FL_seq_free(H5FL_seq_head_t *head, void *obj)
  * Programmer:	Quincey Koziol
  *              Saturday, April 3, 2004
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -1889,8 +1881,6 @@ H5FL_seq_malloc(H5FL_seq_head_t *head, size_t elem H5FL_TRACK_PARAMS)
  * Programmer:	Quincey Koziol
  *              Saturday, April 3, 2004
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -1922,8 +1912,6 @@ H5FL_seq_calloc(H5FL_seq_head_t *head, size_t elem H5FL_TRACK_PARAMS)
  * Programmer:	Quincey Koziol
  *              Saturday, April 3, 2004
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -1955,11 +1943,6 @@ H5FL_seq_realloc(H5FL_seq_head_t *head, void * obj, size_t new_elem H5FL_TRACK_P
  * Programmer:	Quincey Koziol
  *              Wednesday, February 2, 2005
  *
- * Modifications:
- *              Neil Fortner
- *              Friday, December 19, 2008
- *              Totally rewritten to support new factory implementation
- *
  *-------------------------------------------------------------------------
  */
 H5FL_fac_head_t *
@@ -2032,11 +2015,6 @@ done:
  * Programmer:	Quincey Koziol
  *              Wednesday, February 2, 2005
  *
- * Modifications:
- *              Neil Fortner
- *              Friday, December 19, 2008
- *              Totally rewritten to support new factory implementation
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -2120,11 +2098,6 @@ done:
  * Programmer:	Quincey Koziol
  *              Wednesday, February 2, 2005
  *
- * Modifications:
- *              Neil Fortner
- *              Friday, December 19, 2008
- *              Totally rewritten to support new factory implementation
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -2155,7 +2128,7 @@ H5FL_fac_malloc(H5FL_fac_head_t *head H5FL_TRACK_PARAMS)
     } /* end if */
     /* Otherwise allocate a node */
     else {
-        if (NULL==(ret_value = H5FL_malloc(head->size)))
+        if(NULL == (ret_value = H5FL__malloc(head->size)))
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
 
         /* Increment the number of blocks allocated in list */
@@ -2197,11 +2170,6 @@ done:
  * Programmer:	Quincey Koziol
  *              Wednesday, February 2, 2005
  *
- * Modifications:
- *              Neil Fortner
- *              Friday, December 19, 2008
- *              Totally rewritten to support new factory implementation
- *
  *-------------------------------------------------------------------------
  */
 void *
@@ -2245,35 +2213,34 @@ static herr_t
 H5FL__fac_gc_list(H5FL_fac_head_t *head)
 {
     H5FL_fac_node_t *free_list; /* Pointer to nodes in free list being garbage collected */
-    size_t total_mem;   /* Total memory used on list */
 
     FUNC_ENTER_STATIC_NOERR
 
-    /* Calculate the total memory used on this list */
-    total_mem = head->onlist * head->size;
-
     /* For each free list being garbage collected, walk through the nodes and free them */
     free_list = head->list;
     while(free_list != NULL) {
-        void *tmp;          /* Temporary node pointer */
+        H5FL_fac_node_t *tmp;   /* Temporary node pointer */
 
+        /* Get the pointer to the next node */
         tmp = free_list->next;
 
-        /* Decrement the count of nodes allocated and free the node */
-        head->allocated--;
-
+        /* Free the block */
         H5MM_free(free_list);
 
-        free_list = (H5FL_fac_node_t *)tmp;
+        /* Advance to the next node */
+        free_list = tmp;
     } /* end while */
 
+    /* Decrement the count of nodes allocated and free the node */
+    head->allocated -= head->onlist;
+
+    /* Decrement global count of free memory on "factory" lists */
+    H5FL_fac_gc_head.mem_freed -= (head->onlist * head->size);
+
     /* Indicate no free nodes on the free list */
     head->list = NULL;
     head->onlist = 0;
 
-    /* Decrement global count of free memory on "factory" lists */
-    H5FL_fac_gc_head.mem_freed -= total_mem;
-
     FUNC_LEAVE_NOAPI(SUCCEED)
 }   /* end H5FL__fac_gc_list() */
 
@@ -2329,11 +2296,6 @@ done:
  * Programmer:	Quincey Koziol
  *              Wednesday, February 2, 2005
  *
- * Modifications:
- *              Neil Fortner
- *              Friday, December 19, 2008
- *              Totally rewritten to support new factory implementation
- *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -2438,8 +2400,6 @@ HDprintf("%s: head->size = %d, head->allocated = %d\n", FUNC, (int)H5FL_fac_gc_h
  * Programmer:	Quincey Koziol
  *              Friday, March 24, 2000
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -2495,10 +2455,6 @@ done:
  * Programmer:	Quincey Koziol
  *              Wednesday, August 2, 2000
  *
- * Modifications:   Neil Fortner
- *                  Wednesday, April 8, 2009
- *                  Added support for factory free lists
- *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -2531,3 +2487,127 @@ H5FL_set_free_list_limits(int reg_global_lim, int reg_list_lim, int arr_global_l
     FUNC_LEAVE_NOAPI(ret_value)
 }   /* end H5FL_set_free_list_limits() */
 
+
+/*-------------------------------------------------------------------------
+ * Function:	H5FL_get_free_list_sizes
+ *
+ * Purpose:	Gets the current size of the different kinds of free lists.
+ *      These lists are global for the entire library.  The size returned
+ *      included nodes that are freed and awaiting garbage collection /
+ *      reallocation.
+ *
+ * Parameters:
+ *  size_t *reg_size;    OUT: The current size of all "regular" free list memory used
+ *  size_t *arr_size;    OUT: The current size of all "array" free list memory used
+ *  size_t *blk_size;    OUT: The current size of all "block" free list memory used
+ *  size_t *fac_size;    OUT: The current size of all "factory" free list memory used
+ *
+ * Return:	Success:	non-negative
+ *		Failure:	negative
+ *
+ * Programmer:	Quincey Koziol
+ *              Friday, March 6, 2020
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5FL_get_free_list_sizes(size_t *reg_size, size_t *arr_size, size_t *blk_size,
+    size_t *fac_size)
+{
+    FUNC_ENTER_NOAPI_NOERR
+
+    /* Retrieve the amount of "regular" memory used */
+    if(reg_size) {
+        H5FL_reg_gc_node_t *gc_node;    /* Pointer into the list of lists */
+
+        /* Walk through all the free lists, counting the amount of memory */
+        *reg_size = 0;
+        gc_node = H5FL_reg_gc_head.first;
+        while(gc_node != NULL) {
+            H5FL_reg_head_t *reg_list = gc_node->list;  /* Head of list */
+
+            /* Sanity check */
+            HDassert(reg_list->init);
+
+            /* Add the amount of memory for this list */
+            *reg_size += (reg_list->size * reg_list->allocated);
+
+            /* Go on to the next free list */
+            gc_node = gc_node->next;
+        } /* end while */
+    } /* end if */
+
+    /* Retrieve the amount of "array" memory used */
+    if(arr_size) {
+        H5FL_gc_arr_node_t *gc_arr_node;    /* Pointer into the list of things to garbage collect */
+
+        /* Walk through all the free lists, counting the amount of memory */
+        *arr_size = 0;
+        gc_arr_node = H5FL_arr_gc_head.first;
+        while(gc_arr_node != NULL) {
+            H5FL_arr_head_t *head = gc_arr_node->list;  /* Head of array list elements */
+
+            /* Sanity check */
+            HDassert(head->init);
+
+            /* Check for any allocated elements in this list */
+            if(head->allocated > 0) {
+                unsigned u;
+
+                /* Walk through the free lists for array sizes */
+                for(u = 0; u < (unsigned)head->maxelem; u++)
+                    /* Add the amount of memory for this size */
+                    *arr_size += head->list_arr[u].allocated * head->list_arr[u].size;
+            } /* end if */
+
+            /* Go on to the next free list */
+            gc_arr_node = gc_arr_node->next;
+        } /* end while */
+    } /* end if */
+
+    /* Retrieve the amount of "block" memory used */
+    if(blk_size) {
+        H5FL_blk_gc_node_t *gc_blk_node;    /* Pointer into the list of things */
+
+        /* Walk through all the free lists */
+        gc_blk_node = H5FL_blk_gc_head.first;
+        *blk_size = 0;
+        while(gc_blk_node != NULL) {
+            H5FL_blk_node_t *blk_head;  /* Temp. ptr to the free list block node */
+
+            /* Loop through all the nodes in the block free list queue */
+            blk_head = gc_blk_node->pq->head;
+            while(blk_head != NULL) {
+                /* Add size of blocks on this list */
+                *blk_size += (blk_head->allocated * blk_head->size);
+
+                /* Get pointer to next node */
+                blk_head = blk_head->next;
+            } /* end while */
+
+            /* Go on to the next free list */
+            gc_blk_node = gc_blk_node->next;
+        } /* end while */
+    } /* end if */
+
+    /* Retrieve the amount of "factory" memory used */
+    if(fac_size) {
+        H5FL_fac_gc_node_t *gc_fac_node;    /* Pointer into the list of things to garbage collect */
+
+        /* Walk through all the free lists */
+        gc_fac_node = H5FL_fac_gc_head.first;
+        *fac_size = 0;
+        while(gc_fac_node != NULL) {
+            H5FL_fac_head_t *fac_head = gc_fac_node->list;      /* Head node for factory list */
+
+            /* Add size of blocks on this list */
+            *fac_size += (fac_head->allocated * fac_head->size);
+
+            /* Go on to the next free list to garbage collect */
+            gc_fac_node = gc_fac_node->next;
+        } /* end while */
+    } /* end if */
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* end H5FL_get_free_list_sizes() */
+
diff --git a/src/H5FLprivate.h b/src/H5FLprivate.h
index 4aa44f9..94a51e5 100644
--- a/src/H5FLprivate.h
+++ b/src/H5FLprivate.h
@@ -157,6 +157,8 @@ typedef union H5FL_blk_list_t {
 /* Data structure for priority queue node of block free lists */
 typedef struct H5FL_blk_node_t {
     size_t size;                /* Size of the blocks in the list */
+    unsigned allocated;         /* Number of blocks of this size allocated */
+    unsigned onlist;            /* Number of blocks on free list */
     H5FL_blk_list_t *list;      /* List of free blocks */
     struct H5FL_blk_node_t *next;    /* Pointer to next free list in queue */
     struct H5FL_blk_node_t *prev;    /* Pointer to previous free list in queue */
@@ -165,9 +167,9 @@ typedef struct H5FL_blk_node_t {
 /* Data structure for priority queue of native block free lists */
 typedef struct H5FL_blk_head_t {
     hbool_t init;       /* Whether the free list has been initialized */
-    unsigned allocated; /* Number of blocks allocated */
-    unsigned onlist;    /* Number of blocks on free list */
-    size_t list_mem;    /* Amount of memory in block on free list */
+    unsigned allocated; /* Total number of blocks allocated */
+    unsigned onlist;    /* Total number of blocks on free list */
+    size_t list_mem;    /* Total amount of memory in blocks on free list */
     const char *name;   /* Name of the type */
     H5FL_blk_node_t *head;  /* Pointer to first free list in queue */
 } H5FL_blk_head_t;
@@ -189,10 +191,10 @@ typedef struct H5FL_blk_head_t {
 /* Declare a static free list to manage objects of type 't' */
 #define H5FL_BLK_DEFINE_STATIC(t)  static H5FL_BLK_DEFINE_COMMON(t)
 
-/* Allocate an block of type 't' */
+/* Allocate a block of type 't' */
 #define H5FL_BLK_MALLOC(t,size) (uint8_t *)H5FL_blk_malloc(&(H5FL_BLK_NAME(t)),size H5FL_TRACK_INFO)
 
-/* Allocate an block of type 't' and clear it to zeros */
+/* Allocate a block of type 't' and clear it to zeros */
 #define H5FL_BLK_CALLOC(t,size) (uint8_t *)H5FL_blk_calloc(&(H5FL_BLK_NAME(t)),size H5FL_TRACK_INFO)
 
 /* Free a block of type 't' */
@@ -228,7 +230,9 @@ typedef union H5FL_arr_list_t {
 
 /* Data structure for each size of array element */
 typedef struct H5FL_arr_node_t {
-    size_t size;                /* Size of the blocks in the list */
+    size_t size;                /* Size of the blocks in the list (in bytes) */
+                                /* (Note: base_size + <# of elem> * elem_size) */
+    unsigned allocated;         /* Number of blocks allocated of this element size */
     unsigned onlist;            /* Number of blocks on free list */
     H5FL_arr_list_t *list;      /* List of free blocks */
 } H5FL_arr_node_t;
@@ -236,7 +240,7 @@ typedef struct H5FL_arr_node_t {
 /* Data structure for free list of array blocks */
 typedef struct H5FL_arr_head_t {
     hbool_t init;          /* Whether the free list has been initialized */
-    unsigned allocated;    /* Number of blocks allocated */
+    unsigned allocated;    /* Total number of blocks allocated */
     size_t list_mem;       /* Amount of memory in block on free list */
     const char *name;      /* Name of the type */
     int  maxelem;          /* Maximum number of elements in an array */
@@ -423,6 +427,8 @@ H5_DLL herr_t H5FL_garbage_coll(void);
 H5_DLL herr_t H5FL_set_free_list_limits(int reg_global_lim, int reg_list_lim,
     int arr_global_lim, int arr_list_lim, int blk_global_lim, int blk_list_lim,
     int fac_global_lim, int fac_list_lim);
+H5_DLL herr_t H5FL_get_free_list_sizes(size_t *reg_size, size_t *arr_size,
+    size_t *blk_size, size_t *fac_size);
 H5_DLL int   H5FL_term_interface(void);
 
 #endif
diff --git a/src/H5MM.c b/src/H5MM.c
index 7eb1023..cceac4f 100644
--- a/src/H5MM.c
+++ b/src/H5MM.c
@@ -154,7 +154,7 @@ H5MM__is_our_block(void *mem)
  *
  *-------------------------------------------------------------------------
  */
-H5_ATTR_PURE static void
+static void
 H5MM__sanity_check_block(const H5MM_block_t *block)
 {
     HDassert(block->u.info.size > 0);
@@ -180,7 +180,7 @@ H5MM__sanity_check_block(const H5MM_block_t *block)
  *
  *-------------------------------------------------------------------------
  */
-H5_ATTR_PURE static void
+static void
 H5MM__sanity_check(void *mem)
 {
     H5MM_block_t *block = H5MM_BLOCK_FROM_BUF(mem);
@@ -201,7 +201,7 @@ H5MM__sanity_check(void *mem)
  *
  *-------------------------------------------------------------------------
  */
-H5_ATTR_PURE void
+void
 H5MM_sanity_check_all(void)
 {
     H5MM_block_t *curr = NULL;
@@ -226,7 +226,7 @@ H5MM_sanity_check_all(void)
  *
  *-------------------------------------------------------------------------
  */
-H5_ATTR_PURE void
+void
 H5MM_final_sanity_check(void)
 {
     HDassert(0 == H5MM_curr_alloc_bytes_s);
@@ -235,7 +235,7 @@ H5MM_final_sanity_check(void)
     HDassert(H5MM_block_head_s.prev == &H5MM_block_head_s);
 #ifdef H5MM_PRINT_MEMORY_STATS
     HDfprintf(stderr, "%s: H5MM_total_alloc_bytes_s = %llu\n", __func__, H5MM_total_alloc_bytes_s);
-    HDfprintf(stderr, "%s: H5MM_peak_alloc_bytes_s = %llu\n", __func__, H5MM_peak_alloc_bytes_s);
+    HDfprintf(stderr, "%s: H5MM_peak_alloc_bytes_s = %zu\n", __func__, H5MM_peak_alloc_bytes_s);
     HDfprintf(stderr, "%s: H5MM_max_block_size_s = %zu\n", __func__, H5MM_max_block_size_s);
     HDfprintf(stderr, "%s: H5MM_total_alloc_blocks_count_s = %zu\n", __func__, H5MM_total_alloc_blocks_count_s);
     HDfprintf(stderr, "%s: H5MM_peak_alloc_blocks_count_s = %zu\n", __func__, H5MM_peak_alloc_blocks_count_s);
@@ -625,4 +625,46 @@ H5MM_memcpy(void *dest, const void *src, size_t n)
 
 } /* end H5MM_memcpy() */
 
+
+/*-------------------------------------------------------------------------
+ * Function:	H5MM_get_alloc_stats
+ *
+ * Purpose:	Gets the memory allocation statistics for the library, if the
+ *	H5_MEMORY_ALLOC_SANITY_CHECK macro is defined.  If the macro is not
+ *	defined, zeros are returned.  These statistics are global for the
+ *	entire library.
+ *
+ * Parameters:
+ *  H5_alloc_stats_t *stats;            OUT: Memory allocation statistics
+ *
+ * Return:	Success:	non-negative
+ *		Failure:	negative
+ *
+ * Programmer:  Quincey Koziol
+ *              Saturday, March 7, 2020
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5MM_get_alloc_stats(H5_alloc_stats_t *stats)
+{
+    FUNC_ENTER_NOAPI_NOERR
+
+#if defined H5_MEMORY_ALLOC_SANITY_CHECK
+    if(stats) {
+        stats->total_alloc_bytes = H5MM_total_alloc_bytes_s;
+        stats->curr_alloc_bytes = H5MM_curr_alloc_bytes_s;
+        stats->peak_alloc_bytes = H5MM_peak_alloc_bytes_s;
+        stats->max_block_size = H5MM_max_block_size_s;
+        stats->total_alloc_blocks_count = H5MM_total_alloc_blocks_count_s;
+        stats->curr_alloc_blocks_count = H5MM_curr_alloc_blocks_count_s;
+        stats->peak_alloc_blocks_count = H5MM_peak_alloc_blocks_count_s;
+    } /* end if */
+#else /* H5_MEMORY_ALLOC_SANITY_CHECK */
+    if(stats)
+        HDmemset(stats, 0, sizeof(H5_alloc_stats_t));
+#endif /* H5_MEMORY_ALLOC_SANITY_CHECK */
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+}   /* end H5MM_get_alloc_stats() */
 
diff --git a/src/H5MMprivate.h b/src/H5MMprivate.h
index 240b931..0787eb2 100644
--- a/src/H5MMprivate.h
+++ b/src/H5MMprivate.h
@@ -47,6 +47,7 @@ H5_DLL char *H5MM_strdup(const char *s);
 H5_DLL void *H5MM_xfree(void *mem);
 H5_DLL void *H5MM_xfree_const(const void *mem);
 H5_DLL void *H5MM_memcpy(void *dest, const void *src, size_t n);
+H5_DLL herr_t H5MM_get_alloc_stats(H5_alloc_stats_t *stats);
 #if defined H5_MEMORY_ALLOC_SANITY_CHECK
 H5_DLL void H5MM_sanity_check_all(void);
 H5_DLL void H5MM_final_sanity_check(void);
diff --git a/src/H5Pdcpl.c b/src/H5Pdcpl.c
index d72a704..448d512 100644
--- a/src/H5Pdcpl.c
+++ b/src/H5Pdcpl.c
@@ -827,7 +827,7 @@ H5P__dcrt_layout_cmp(const void *_layout1, const void *_layout2,
                     if((equal = H5S_extent_equal(layout1->storage.u.virt.list[u].source_dset.virtual_select, layout2->storage.u.virt.list[u].source_dset.virtual_select)) < 0) HGOTO_DONE(-1)
                     if(!equal)
                         HGOTO_DONE(1)
-                    if((equal = H5S_select_shape_same(layout1->storage.u.virt.list[u].source_dset.virtual_select, layout2->storage.u.virt.list[u].source_dset.virtual_select)) < 0) HGOTO_DONE(-1)
+                    if((equal = H5S_SELECT_SHAPE_SAME(layout1->storage.u.virt.list[u].source_dset.virtual_select, layout2->storage.u.virt.list[u].source_dset.virtual_select)) < 0) HGOTO_DONE(-1)
                     if(!equal)
                         HGOTO_DONE(1)
 
@@ -847,7 +847,7 @@ H5P__dcrt_layout_cmp(const void *_layout1, const void *_layout2,
                     if((equal = H5S_extent_equal(layout1->storage.u.virt.list[u].source_select, layout2->storage.u.virt.list[u].source_select)) < 0) HGOTO_DONE(-1)
                     if(!equal)
                         HGOTO_DONE(1)
-                    if((equal = H5S_select_shape_same(layout1->storage.u.virt.list[u].source_select, layout2->storage.u.virt.list[u].source_select)) < 0) HGOTO_DONE(-1)
+                    if((equal = H5S_SELECT_SHAPE_SAME(layout1->storage.u.virt.list[u].source_select, layout2->storage.u.virt.list[u].source_select)) < 0) HGOTO_DONE(-1)
                     if(!equal)
                         HGOTO_DONE(1)
                 } /* end for */
diff --git a/src/H5S.c b/src/H5S.c
index c6f81f8..c42c952 100644
--- a/src/H5S.c
+++ b/src/H5S.c
@@ -1836,49 +1836,6 @@ done:
 } /* end H5Sset_extent_none() */
 
 
-/*--------------------------------------------------------------------------
- NAME
-    H5Soffset_simple
- PURPOSE
-    Changes the offset of a selection within a simple dataspace extent
- USAGE
-    herr_t H5Soffset_simple(space_id, offset)
-        hid_t space_id;	        IN: Dataspace object to reset
-        const hssize_t *offset; IN: Offset to position the selection at
- RETURNS
-    Non-negative on success/Negative on failure
- DESCRIPTION
-	This function creates an offset for the selection within an extent, allowing
-    the same shaped selection to be moved to different locations within a
-    dataspace without requiring it to be re-defined.
---------------------------------------------------------------------------*/
-herr_t
-H5Soffset_simple(hid_t space_id, const hssize_t *offset)
-{
-    H5S_t		   *space;	/* dataspace to modify */
-    herr_t                  ret_value=SUCCEED;  /* Return value */
-
-    FUNC_ENTER_API(FAIL)
-    H5TRACE2("e", "i*Hs", space_id, offset);
-
-    /* Check args */
-    if (NULL == (space = (H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE)))
-        HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "not a dataspace")
-    if (space->extent.rank==0 || (H5S_GET_EXTENT_TYPE(space)==H5S_SCALAR
-            || H5S_GET_EXTENT_TYPE(space)==H5S_NULL))
-        HGOTO_ERROR(H5E_ATOM, H5E_UNSUPPORTED, FAIL, "can't set offset on scalar or null dataspace")
-    if (offset == NULL)
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no offset specified")
-
-    /* Set the selection offset */
-    if(H5S_select_offset(space,offset)<0)
-        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "can't set offset")
-
-done:
-    FUNC_LEAVE_API(ret_value)
-}   /* end H5Soffset_simple() */
-
-
 /*-------------------------------------------------------------------------
  * Function:    H5S_set_extent
  *
diff --git a/src/H5Sall.c b/src/H5Sall.c
index da466d0..08fbb5c 100644
--- a/src/H5Sall.c
+++ b/src/H5Sall.c
@@ -65,10 +65,10 @@ static int H5S__all_unlim_dim(const H5S_t *space);
 static htri_t H5S__all_is_contiguous(const H5S_t *space);
 static htri_t H5S__all_is_single(const H5S_t *space);
 static htri_t H5S__all_is_regular(const H5S_t *space);
-static void H5S__all_adjust_u(H5S_t *space, const hsize_t *offset);
+static herr_t H5S__all_adjust_u(H5S_t *space, const hsize_t *offset);
 static herr_t H5S__all_project_scalar(const H5S_t *space, hsize_t *offset);
 static herr_t H5S__all_project_simple(const H5S_t *space, H5S_t *new_space, hsize_t *offset);
-static herr_t H5S__all_iter_init(H5S_sel_iter_t *iter, const H5S_t *space);
+static herr_t H5S__all_iter_init(const H5S_t *space, H5S_sel_iter_t *iter);
 
 /* Selection iteration callbacks */
 static herr_t H5S__all_iter_coords(const H5S_sel_iter_t *iter, hsize_t *coords);
@@ -148,7 +148,7 @@ static const H5S_sel_iter_class_t H5S_sel_iter_all[1] = {{
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5S__all_iter_init(H5S_sel_iter_t *iter, const H5S_t *space)
+H5S__all_iter_init(const H5S_t *space, H5S_sel_iter_t *iter)
 {
     FUNC_ENTER_STATIC_NOERR
 
@@ -850,11 +850,11 @@ H5S__all_is_regular(const H5S_t H5_ATTR_UNUSED *space)
  PURPOSE
     Adjust an "all" selection by subtracting an offset
  USAGE
-    void H5S__all_adjust_u(space, offset)
+    herr_t H5S__all_adjust_u(space, offset)
         H5S_t *space;           IN/OUT: Pointer to dataspace to adjust
         const hsize_t *offset; IN: Offset to subtract
  RETURNS
-    None
+    Non-negative on success, negative on failure
  DESCRIPTION
     Moves selection by subtracting an offset from it.
  GLOBAL VARIABLES
@@ -862,7 +862,7 @@ H5S__all_is_regular(const H5S_t H5_ATTR_UNUSED *space)
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
-static void
+static herr_t
 H5S__all_adjust_u(H5S_t H5_ATTR_UNUSED *space, const hsize_t H5_ATTR_UNUSED *offset)
 {
     FUNC_ENTER_STATIC_NOERR
@@ -871,7 +871,7 @@ H5S__all_adjust_u(H5S_t H5_ATTR_UNUSED *space, const hsize_t H5_ATTR_UNUSED *off
     HDassert(space);
     HDassert(offset);
 
-    FUNC_LEAVE_NOAPI_VOID
+    FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5S__all_adjust_u() */
 
 
diff --git a/src/H5Shyper.c b/src/H5Shyper.c
index e94c66e..6023205 100644
--- a/src/H5Shyper.c
+++ b/src/H5Shyper.c
@@ -114,10 +114,10 @@ static herr_t H5S__hyper_num_elem_non_unlim(const H5S_t *space,
 static htri_t H5S__hyper_is_contiguous(const H5S_t *space);
 static htri_t H5S__hyper_is_single(const H5S_t *space);
 static htri_t H5S__hyper_is_regular(const H5S_t *space);
-static void H5S__hyper_adjust_u(H5S_t *space, const hsize_t *offset);
+static herr_t H5S__hyper_adjust_u(H5S_t *space, const hsize_t *offset);
 static herr_t H5S__hyper_project_scalar(const H5S_t *space, hsize_t *offset);
 static herr_t H5S__hyper_project_simple(const H5S_t *space, H5S_t *new_space, hsize_t *offset);
-static herr_t H5S__hyper_iter_init(H5S_sel_iter_t *iter, const H5S_t *space);
+static herr_t H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter);
 
 /* Selection iteration callbacks */
 static herr_t H5S__hyper_iter_coords(const H5S_sel_iter_t *iter, hsize_t *coords);
@@ -181,19 +181,17 @@ static const H5S_sel_iter_class_t H5S_sel_iter_hyper[1] = {{
     H5S__hyper_iter_release,
 }};
 
-/* Static variables */
-
 /* Arrays for default stride, block, etc. */
-static const hsize_t H5S_hyper_zeros_g[H5O_LAYOUT_NDIMS] = {
+static const hsize_t H5S_hyper_zeros_g[H5S_MAX_RANK] = {
     0,0,0,0, 0,0,0,0,
     0,0,0,0, 0,0,0,0,
     0,0,0,0, 0,0,0,0,
-    0,0,0,0, 0,0,0,0,0};
-static const hsize_t H5S_hyper_ones_g[H5O_LAYOUT_NDIMS] = {
+    0,0,0,0, 0,0,0,0};
+static const hsize_t H5S_hyper_ones_g[H5S_MAX_RANK] = {
     1,1,1,1, 1,1,1,1,
     1,1,1,1, 1,1,1,1,
     1,1,1,1, 1,1,1,1,
-    1,1,1,1, 1,1,1,1,1};
+    1,1,1,1, 1,1,1,1};
 
 /* Declare a free list to manage the H5S_hyper_sel_t struct */
 H5FL_DEFINE_STATIC(H5S_hyper_sel_t);
@@ -207,6 +205,7 @@ H5FL_DEFINE_STATIC(H5S_hyper_span_info_t);
 /* Declare extern free list to manage the H5S_sel_iter_t struct */
 H5FL_EXTERN(H5S_sel_iter_t);
 
+/* Uncomment this to provide the debugging routines for printing selection info */
 /* #define H5S_HYPER_DEBUG */
 #ifdef H5S_HYPER_DEBUG
 static herr_t
@@ -290,13 +289,13 @@ H5S__hyper_print_diminfo(FILE *f, const H5S_t *space)
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5S__hyper_iter_init
+ * Function:    H5S__hyper_iter_init
  *
- * Purpose:	Initializes iteration information for hyperslab span tree selection.
+ * Purpose:     Initializes iteration information for hyperslab span tree selection.
  *
- * Return:	non-negative on success, negative on failure.
+ * Return:      Non-negative on success, negative on failure.
  *
- * Programmer:	Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Saturday, February 24, 2001
  *
  * Notes:       If the 'elmt_size' parameter is set to zero, the regular
@@ -307,13 +306,13 @@ H5S__hyper_print_diminfo(FILE *f, const H5S_t *space)
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5S__hyper_iter_init(H5S_sel_iter_t *iter, const H5S_t *space)
+H5S__hyper_iter_init(const H5S_t *space, H5S_sel_iter_t *iter)
 {
     const H5S_hyper_dim_t *tdiminfo;    /* Temporary pointer to diminfo information */
     H5S_hyper_span_info_t *spans;   /* Pointer to hyperslab span info node */
-    unsigned rank;                  /* Dataspace's dimension rank */
-    unsigned u;                     /* Index variable */
-    int i;                          /* Index variable */
+    unsigned rank;              /* Dataspace's dimension rank */
+    unsigned u;                 /* Index variable */
+    int i;                      /* Index variable */
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -484,14 +483,14 @@ H5S__hyper_iter_init(H5S_sel_iter_t *iter, const H5S_t *space)
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5S__hyper_iter_coords
+ * Function:    H5S__hyper_iter_coords
  *
- * Purpose:	Retrieve the current coordinates of iterator for current
+ * Purpose:     Retrieve the current coordinates of iterator for current
  *              selection
  *
- * Return:	non-negative on success, negative on failure
+ * Return:      Non-negative on success, negative on failure
  *
- * Programmer:	Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Tuesday, April 22, 2003
  *
  *-------------------------------------------------------------------------
@@ -604,16 +603,14 @@ H5S__hyper_iter_block(const H5S_sel_iter_t *iter, hsize_t *start, hsize_t *end)
         for(u = 0; u < iter->rank; u++) {
             start[u] = iter->u.hyp.off[u];
             end[u] = (start[u] + iter->u.hyp.diminfo[u].block) - 1;
-        } /* end for */
+        }
     } /* end if */
     else {
-        /* Copy the start of the block */
-        for(u = 0; u < iter->rank; u++)
+        /* Copy the start & end of the block */
+        for(u = 0; u < iter->rank; u++) {
             start[u] = iter->u.hyp.span[u]->low;
-
-        /* Copy the end of the block */
-        for(u = 0; u < iter->rank; u++)
             end[u] = iter->u.hyp.span[u]->high;
+        }
     } /* end else */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
@@ -727,8 +724,8 @@ H5S__hyper_iter_next(H5S_sel_iter_t *iter, size_t nelem)
     /* (i.e. a regular hyperslab selection */
     if(iter->u.hyp.diminfo_valid) {
         const H5S_hyper_dim_t *tdiminfo;    /* Temporary pointer to diminfo information */
-        hsize_t iter_offset[H5O_LAYOUT_NDIMS];
-        hsize_t iter_count[H5O_LAYOUT_NDIMS];
+        hsize_t iter_offset[H5S_MAX_RANK];
+        hsize_t iter_count[H5S_MAX_RANK];
         int temp_dim;  /* Temporary rank holder */
 
         /* Check if this is a "flattened" regular hyperslab selection */
@@ -934,8 +931,8 @@ H5S__hyper_iter_next_block(H5S_sel_iter_t *iter)
     /* (i.e. a regular hyperslab selection) */
     if(iter->u.hyp.diminfo_valid) {
         const H5S_hyper_dim_t *tdiminfo;    /* Temporary pointer to diminfo information */
-        hsize_t iter_offset[H5O_LAYOUT_NDIMS];
-        hsize_t iter_count[H5O_LAYOUT_NDIMS];
+        hsize_t iter_offset[H5S_MAX_RANK];
+        hsize_t iter_count[H5S_MAX_RANK];
         int temp_dim;  /* Temporary rank holder */
 
         /* Check if this is a "flattened" regular hyperslab selection */
@@ -2180,7 +2177,7 @@ H5S__hyper_serialize_helper(const H5S_hyper_span_info_t *spans,
     HDassert(spans);
     HDassert(start);
     HDassert(end);
-    HDassert(rank < H5O_LAYOUT_NDIMS);
+    HDassert(rank < H5S_MAX_RANK);
     HDassert(p && pp);
 
     /* Walk through the list of spans, recursing or outputting them */
@@ -2250,13 +2247,13 @@ H5S__hyper_serialize_helper(const H5S_hyper_span_info_t *spans,
 static herr_t
 H5S__hyper_serialize(const H5S_t *space, uint8_t **p)
 {
-    const H5S_hyper_dim_t *diminfo;         /* Alias for dataspace's diminfo information */
-    uint8_t *pp;            /* Local pointer for encoding */
-    hsize_t tmp_count[H5O_LAYOUT_NDIMS];    /* Temporary hyperslab counts */
-    hsize_t offset[H5O_LAYOUT_NDIMS];       /* Offset of element in dataspace */
-    hsize_t start[H5O_LAYOUT_NDIMS];   /* Location of start of hyperslab */
-    hsize_t end[H5O_LAYOUT_NDIMS];     /* Location of end of hyperslab */
-    uint8_t *lenp;          /* pointer to length location for later storage */
+    const H5S_hyper_dim_t *diminfo;     /* Alias for dataspace's diminfo information */
+    hsize_t tmp_count[H5S_MAX_RANK];    /* Temporary hyperslab counts */
+    hsize_t offset[H5S_MAX_RANK];       /* Offset of element in dataspace */
+    hsize_t start[H5S_MAX_RANK];        /* Location of start of hyperslab */
+    hsize_t end[H5S_MAX_RANK];          /* Location of end of hyperslab */
+    uint8_t *pp;                        /* Local pointer for encoding */
+    uint8_t *lenp = NULL;   /* pointer to length location for later storage */
     uint32_t len = 0;       /* number of bytes used */
     uint32_t version;       /* Version number */
     uint8_t flags = 0;      /* Flags for message */
@@ -2526,8 +2523,8 @@ H5S__hyper_deserialize(H5S_t **space, const uint8_t **p)
             HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "rank of serialized selection does not match dataspace")
 
     if(flags & H5S_HYPER_REGULAR) {
-        hsize_t stride[H5O_LAYOUT_NDIMS];	/* Hyperslab stride information */
-        hsize_t count[H5O_LAYOUT_NDIMS];	/* Hyperslab count information */
+        hsize_t stride[H5S_MAX_RANK];   /* Hyperslab stride information */
+        hsize_t count[H5S_MAX_RANK];    /* Hyperslab count information */
 
         /* Sanity checks */
         HDassert(H5S_UNLIMITED == HSIZE_UNDEF);
@@ -2549,12 +2546,12 @@ H5S__hyper_deserialize(H5S_t **space, const uint8_t **p)
     else {
         const hsize_t *stride;  /* Hyperslab stride information */
         const hsize_t *count;   /* Hyperslab count information */
-        hsize_t end[H5O_LAYOUT_NDIMS];	/* Hyperslab end information */
-        hsize_t *tstart;	/* Temporary hyperslab pointers */
-        hsize_t *tend;		/* Temporary hyperslab pointers */
-        hsize_t *tblock;	/* Temporary hyperslab pointers */
-        size_t num_elem;      	/* Number of elements in selection */
-        unsigned v;            	/* Local counting variable */
+        hsize_t end[H5S_MAX_RANK];  /* Hyperslab end information */
+        hsize_t *tstart;        /* Temporary hyperslab pointers */
+        hsize_t *tend;          /* Temporary hyperslab pointers */
+        hsize_t *tblock;        /* Temporary hyperslab pointers */
+        size_t num_elem;        /* Number of elements in selection */
+        unsigned v;             /* Local counting variable */
 
         /* Decode the number of points */
         UINT32DECODE(pp, num_elem);
@@ -2645,7 +2642,7 @@ H5S__hyper_span_blocklist(const H5S_hyper_span_info_t *spans, hsize_t start[],
 
     /* Sanity checks */
     HDassert(spans);
-    HDassert(rank < H5O_LAYOUT_NDIMS);
+    HDassert(rank < H5S_MAX_RANK);
     HDassert(start);
     HDassert(end);
     HDassert(startblock);
@@ -2749,8 +2746,8 @@ H5S__get_select_hyper_blocklist(H5S_t *space, hbool_t internal, hsize_t startblo
     /* Check for a "regular" hyperslab selection */
     if(space->select.sel_info.hslab->diminfo_valid) {
         const H5S_hyper_dim_t *diminfo; /* Alias for dataspace's diminfo information */
-        hsize_t tmp_count[H5O_LAYOUT_NDIMS];    /* Temporary hyperslab counts */
-        hsize_t offset[H5O_LAYOUT_NDIMS];      /* Offset of element in dataspace */
+        hsize_t tmp_count[H5S_MAX_RANK]; /* Temporary hyperslab counts */
+        hsize_t offset[H5S_MAX_RANK];   /* Offset of element in dataspace */
         unsigned fast_dim;          /* Rank of the fastest changing dimension for the dataspace */
         unsigned ndims;             /* Rank of the dataspace */
         hbool_t done;               /* Whether we are done with the iteration */
@@ -2860,8 +2857,8 @@ H5S__get_select_hyper_blocklist(H5S_t *space, hbool_t internal, hsize_t startblo
         } /* end while */
     } /* end if */
     else {
-        hsize_t start[H5O_LAYOUT_NDIMS];   /* Location of start of hyperslab */
-        hsize_t end[H5O_LAYOUT_NDIMS];     /* Location of end of hyperslab */
+        hsize_t start[H5S_MAX_RANK];    /* Location of start of hyperslab */
+        hsize_t end[H5S_MAX_RANK];      /* Location of end of hyperslab */
 
         ret_value = H5S__hyper_span_blocklist(space->select.sel_info.hslab->span_lst, start, end, (hsize_t)0, &startblock, &numblocks, &buf);
     } /* end else */
@@ -2969,7 +2966,7 @@ H5S_hyper_bounds_helper(const H5S_hyper_span_info_t *spans, const hssize_t *offs
 
     HDassert(spans);
     HDassert(offset);
-    HDassert(rank < H5O_LAYOUT_NDIMS);
+    HDassert(rank < H5S_MAX_RANK);
     HDassert(start);
     HDassert(end);
 
@@ -3273,7 +3270,7 @@ done:
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
-static htri_t
+static H5_ATTR_PURE htri_t
 H5S__hyper_is_contiguous(const H5S_t *space)
 {
     hbool_t small_contiguous,       /* Flag for small contiguous block */
@@ -3303,8 +3300,8 @@ H5S__hyper_is_contiguous(const H5S_t *space)
          */
 
         /* Initialize flags */
-        large_contiguous = TRUE;	/* assume true and reset if the dimensions don't match */
-        small_contiguous = FALSE;	/* assume false initially */
+        large_contiguous = TRUE;    /* assume true and reset if the dimensions don't match */
+        small_contiguous = FALSE;   /* assume false initially */
 
         /* Check for a "large contigous" block */
         for(u = 0; u < space->extent.rank; u++) {
@@ -3343,14 +3340,14 @@ H5S__hyper_is_contiguous(const H5S_t *space)
 
         /*
          * For a hyperslab to be contiguous, it must have only one block and
-         * (either it's size must be the same as the dataspace extent's in all
-         * but the slowest changing dimension
-         * OR
-         * block size must be 1 in all but the fastest changing dimension).
+         * either it's size must be the same as the dataspace extent's in all
+         *      but the slowest changing dimension
+         *   OR
+         *      block size must be 1 in all but the fastest changing dimension.
          */
         /* Initialize flags */
-        large_contiguous = TRUE;	/* assume true and reset if the dimensions don't match */
-        small_contiguous = FALSE;	/* assume false initially */
+        large_contiguous = TRUE;    /* assume true and reset if the dimensions don't match */
+        small_contiguous = FALSE;   /* assume false initially */
 
         /* Get information for slowest changing information */
         spans = space->select.sel_info.hslab->span_lst;
@@ -3458,7 +3455,7 @@ H5S__hyper_is_contiguous(const H5S_t *space)
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
-static htri_t
+static H5_ATTR_PURE htri_t
 H5S__hyper_is_single(const H5S_t *space)
 {
     htri_t ret_value = TRUE;        /* return value */
@@ -3477,10 +3474,9 @@ H5S__hyper_is_single(const H5S_t *space)
          */
 
         /* Check for a single block */
-        for(u = 0; u < space->extent.rank; u++) {
+        for(u = 0; u < space->extent.rank; u++)
             if(space->select.sel_info.hslab->opt_diminfo[u].count > 1)
                 HGOTO_DONE(FALSE)
-        } /* end for */
     } /* end if */
     else {
         H5S_hyper_span_info_t *spans;   /* Hyperslab span info node */
@@ -3567,11 +3563,6 @@ H5S__hyper_is_regular(const H5S_t *space)
  COMMENTS, BUGS, ASSUMPTIONS
  EXAMPLES
  REVISION LOG
- * 	Robb Matzke, 1998-08-25
- *	The fields which are freed are set to NULL to prevent them from being
- *	freed again later.  This fixes some allocation problems where
- *	changing the hyperslab selection of one dataspace causes a core dump
- *	when closing some other dataspace.
 --------------------------------------------------------------------------*/
 static herr_t
 H5S__hyper_release(H5S_t *space)
@@ -3639,7 +3630,7 @@ H5S__hyper_recover_span(hbool_t *recover, H5S_hyper_span_t **curr_span, H5S_hype
     *curr_span = next_span;
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-}   /* H5S__hyper_recover_span() */
+} /* end H5S__hyper_recover_span() */
 
 
 /*--------------------------------------------------------------------------
@@ -4087,125 +4078,6 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S_hyper_convert() */
 
-#ifdef LATER
-
-/*--------------------------------------------------------------------------
- NAME
-    H5S_hyper_intersect_helper
- PURPOSE
-    Helper routine to detect intersections in span trees
- USAGE
-    htri_t H5S_hyper_intersect_helper(spans1, spans2)
-        H5S_hyper_span_info_t *spans1;     IN: First span tree to operate with
-        H5S_hyper_span_info_t *spans2;     IN: Second span tree to operate with
- RETURNS
-    Non-negative on success, negative on failure
- DESCRIPTION
-    Quickly detect intersections between two span trees
- GLOBAL VARIABLES
- COMMENTS, BUGS, ASSUMPTIONS
- EXAMPLES
- REVISION LOG
---------------------------------------------------------------------------*/
-static htri_t
-H5S_hyper_intersect_helper (H5S_hyper_span_info_t *spans1, H5S_hyper_span_info_t *spans2)
-{
-    H5S_hyper_span_t *curr1;    /* Pointer to current span in 1st span tree */
-    H5S_hyper_span_t *curr2;    /* Pointer to current span in 2nd span tree */
-    htri_t status;              /* Status from recursive call */
-    htri_t ret_value=FALSE;     /* Return value */
-
-    FUNC_ENTER_NOAPI_NOINIT
-
-    /* Sanity check */
-    HDassert((spans1 && spans2) || (spans1 == NULL && spans2 == NULL));
-
-    /* "NULL" span trees compare as overlapping */
-    if(spans1==NULL && spans2==NULL)
-        HGOTO_DONE(TRUE);
-
-    /* Get the span lists for each span in this tree */
-    curr1=spans1->head;
-    curr2=spans2->head;
-
-    /* Iterate over the spans in each tree */
-    while(curr1!=NULL && curr2!=NULL) {
-        /* Check for 1st span entirely before 2nd span */
-        if(curr1->high<curr2->low)
-            curr1=curr1->next;
-        /* Check for 2nd span entirely before 1st span */
-        else if(curr2->high<curr1->low)
-            curr2=curr2->next;
-        /* Spans must overlap */
-        else {
-            /* Recursively check spans in next dimension down */
-            if((status=H5S_hyper_intersect_helper(curr1->down,curr2->down))<0)
-                HGOTO_ERROR(H5E_DATASPACE, H5E_BADSELECT, FAIL, "can't perform hyperslab intersection check")
-
-            /* If there is a span intersection in the down dimensions, the span trees overlap */
-            if(status==TRUE)
-                HGOTO_DONE(TRUE);
-
-            /* No intersection in down dimensions, advance to next span */
-            if(curr1->high<curr2->high)
-                curr1=curr1->next;
-            else
-                curr2=curr2->next;
-        } /* end else */
-    } /* end while */
-
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-}   /* H5S_hyper_intersect_helper() */
-
-
-/*--------------------------------------------------------------------------
- NAME
-    H5S_hyper_intersect
- PURPOSE
-    Detect intersections in span trees
- USAGE
-    htri_t H5S_hyper_intersect(space1, space2)
-        H5S_t *space1;     IN: First dataspace to operate on span tree
-        H5S_t *space2;     IN: Second dataspace to operate on span tree
- RETURNS
-    Non-negative on success, negative on failure
- DESCRIPTION
-    Quickly detect intersections between two span trees
- GLOBAL VARIABLES
- COMMENTS, BUGS, ASSUMPTIONS
- EXAMPLES
- REVISION LOG
---------------------------------------------------------------------------*/
-htri_t
-H5S_hyper_intersect (H5S_t *space1, H5S_t *space2)
-{
-    htri_t ret_value=FAIL;      /* Return value */
-
-    FUNC_ENTER_NOAPI_NOINIT
-
-    /* Sanity check */
-    HDassert(space1);
-    HDassert(space2);
-
-    /* Check that the space selections both have span trees */
-    if(space1->select.sel_info.hslab->span_lst==NULL ||
-            space2->select.sel_info.hslab->span_lst==NULL)
-        HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "dataspace does not have span tree")
-
-    /* Check that the dataspaces are both the same rank */
-    if(space1->extent.rank!=space2->extent.rank)
-        HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "dataspace ranks don't match")
-
-    /* Perform the span-by-span intersection check */
-    if((ret_value=H5S_hyper_intersect_helper(space1->select.sel_info.hslab->span_lst,space2->select.sel_info.hslab->span_lst))<0)
-        HGOTO_ERROR(H5E_DATASPACE, H5E_BADSELECT, FAIL, "can't perform hyperslab intersection check")
-
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-}   /* H5S_hyper_intersect() */
-#endif /* LATER */
-
 
 /*--------------------------------------------------------------------------
  NAME
@@ -4397,7 +4269,7 @@ H5S__hyper_adjust_u_helper(H5S_hyper_span_info_t *spans,
         H5S_t *space;           IN/OUT: Pointer to dataspace to adjust
         const hsize_t *offset; IN: Offset to subtract
  RETURNS
-    None
+    Non-negative on success, negative on failure
  DESCRIPTION
     Moves a hyperslab selection by subtracting an offset from it.
  GLOBAL VARIABLES
@@ -4405,34 +4277,45 @@ H5S__hyper_adjust_u_helper(H5S_hyper_span_info_t *spans,
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
-static void
+static herr_t
 H5S__hyper_adjust_u(H5S_t *space, const hsize_t *offset)
 {
+    hbool_t non_zero_offset = FALSE;    /* Whether any offset is non-zero */
+    unsigned u;                         /* Local index variable */
+
     FUNC_ENTER_STATIC_NOERR
 
     /* Sanity check */
     HDassert(space);
     HDassert(offset);
 
-    /* Subtract the offset from the "regular" coordinates, if they exist */
-    if(space->select.sel_info.hslab->diminfo_valid) {
-        unsigned u;                         /* Local index variable */
+    /* Check for an all-zero offset vector */
+    for(u = 0; u < space->extent.rank; u++)
+        if(0 != offset[u]) {
+            non_zero_offset = TRUE;
+            break;
+        }
 
-        for(u = 0; u < space->extent.rank; u++) {
-            HDassert(space->select.sel_info.hslab->opt_diminfo[u].start >= offset[u]);
-            space->select.sel_info.hslab->opt_diminfo[u].start -= offset[u];
-        } /* end for */
-    } /* end if */
+    /* Only perform operation if the offset is non-zero */
+    if(non_zero_offset) {
+        /* Subtract the offset from the "regular" coordinates, if they exist */
+        if(space->select.sel_info.hslab->diminfo_valid) {
+            for(u = 0; u < space->extent.rank; u++) {
+                HDassert(space->select.sel_info.hslab->opt_diminfo[u].start >= offset[u]);
+                space->select.sel_info.hslab->opt_diminfo[u].start -= offset[u];
+            } /* end for */
+        } /* end if */
 
-    /* Subtract the offset from the span tree coordinates, if they exist */
-    if(space->select.sel_info.hslab->span_lst) {
-        H5S__hyper_adjust_u_helper(space->select.sel_info.hslab->span_lst, offset);
+        /* Subtract the offset from the span tree coordinates, if they exist */
+        if(space->select.sel_info.hslab->span_lst) {
+            H5S__hyper_adjust_u_helper(space->select.sel_info.hslab->span_lst, offset);
 
-        /* Reset the scratch pointers for the next routine which needs them */
-        H5S__hyper_span_scratch(space->select.sel_info.hslab->span_lst);
+            /* Reset the scratch pointers for the next routine which needs them */
+            H5S__hyper_span_scratch(space->select.sel_info.hslab->span_lst);
+        } /* end if */
     } /* end if */
 
-    FUNC_LEAVE_NOAPI_VOID
+    FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5S__hyper_adjust_u() */
 
 
@@ -6332,7 +6215,7 @@ done:
 static hbool_t
 H5S__hyper_rebuild(H5S_t *space)
 {
-    H5S_hyper_dim_t top_span_slab_info[H5O_LAYOUT_NDIMS];
+    H5S_hyper_dim_t top_span_slab_info[H5S_MAX_RANK];
     unsigned rank, curr_dim;
     hbool_t ret_value = TRUE;      /* Return value */
 
@@ -6394,12 +6277,12 @@ done:
 static herr_t
 H5S__hyper_generate_spans(H5S_t *space)
 {
-    hsize_t tmp_start[H5O_LAYOUT_NDIMS];    /* Temporary start information */
-    hsize_t tmp_stride[H5O_LAYOUT_NDIMS];   /* Temporary stride information */
-    hsize_t tmp_count[H5O_LAYOUT_NDIMS];    /* Temporary count information */
-    hsize_t tmp_block[H5O_LAYOUT_NDIMS];    /* Temporary block information */
-    unsigned u;                             /* Local index variable */
-    herr_t ret_value = SUCCEED;             /* Return value */
+    hsize_t tmp_start[H5S_MAX_RANK];    /* Temporary start information */
+    hsize_t tmp_stride[H5S_MAX_RANK];   /* Temporary stride information */
+    hsize_t tmp_count[H5S_MAX_RANK];    /* Temporary count information */
+    hsize_t tmp_block[H5S_MAX_RANK];    /* Temporary block information */
+    unsigned u;                         /* Local index variable */
+    herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -6417,10 +6300,10 @@ H5S__hyper_generate_spans(H5S_t *space)
         if(space->select.sel_info.hslab->opt_diminfo[u].block == H5S_UNLIMITED)
             HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "can't generate spans with unlimited block")
 
-        tmp_start[u]=space->select.sel_info.hslab->opt_diminfo[u].start;
-        tmp_stride[u]=space->select.sel_info.hslab->opt_diminfo[u].stride;
-        tmp_count[u]=space->select.sel_info.hslab->opt_diminfo[u].count;
-        tmp_block[u]=space->select.sel_info.hslab->opt_diminfo[u].block;
+        tmp_start[u] = space->select.sel_info.hslab->opt_diminfo[u].start;
+        tmp_stride[u] = space->select.sel_info.hslab->opt_diminfo[u].stride;
+        tmp_count[u] = space->select.sel_info.hslab->opt_diminfo[u].count;
+        tmp_block[u] = space->select.sel_info.hslab->opt_diminfo[u].block;
     } /* end for */
 
     /* Build the hyperslab information also */
@@ -6434,27 +6317,22 @@ done:
 #ifndef NEW_HYPERSLAB_API
 
 /*-------------------------------------------------------------------------
- * Function:	H5S__generate_hyperlab
+ * Function:    H5S__generate_hyperlab
  *
- * Purpose:	Generate hyperslab information from H5S_select_hyperslab()
+ * Purpose:     Generate hyperslab information from H5S_select_hyperslab()
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:	Quincey Koziol (split from HS_select_hyperslab()).
+ * Programmer:  Quincey Koziol
  *              Tuesday, September 12, 2000
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5S__generate_hyperslab (H5S_t *space, H5S_seloper_t op,
-		      const hsize_t start[],
-		      const hsize_t stride[],
-		      const hsize_t count[],
-		      const hsize_t block[])
+H5S__generate_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
+    const hsize_t stride[], const hsize_t count[], const hsize_t block[])
 {
-    H5S_hyper_span_info_t *new_spans=NULL;  /* Span tree for new hyperslab */
+    H5S_hyper_span_info_t *new_spans = NULL;    /* Span tree for new hyperslab */
     H5S_hyper_span_info_t *a_not_b = NULL;      /* Span tree for hyperslab spans in old span tree and not in new span tree */
     H5S_hyper_span_info_t *a_and_b = NULL;      /* Span tree for hyperslab spans in both old and new span trees */
     H5S_hyper_span_info_t *b_not_a = NULL;      /* Span tree for hyperslab spans in new span tree and not in old span tree */
@@ -6475,7 +6353,7 @@ H5S__generate_hyperslab (H5S_t *space, H5S_seloper_t op,
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't create hyperslab information")
 
     /* Generate list of blocks to add/remove based on selection operation */
-    if(op==H5S_SELECT_SET) {
+    if(op == H5S_SELECT_SET) {
         /* Add new spans to current selection */
         if(H5S__hyper_merge_spans(space,new_spans,TRUE)<0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs")
@@ -6484,10 +6362,10 @@ H5S__generate_hyperslab (H5S_t *space, H5S_seloper_t op,
         space->select.num_elem = H5S__hyper_spans_nelem(new_spans);
 
         /* Indicate that the new_spans are owned */
-        new_spans=NULL;
+        new_spans = NULL;
     } /* end if */
     else {
-        hbool_t updated_spans = FALSE;  /* Whether the spans in the selection were modified */
+        hbool_t updated_spans = FALSE;
 
         /* Generate lists of spans which overlap and don't overlap */
         if(H5S__hyper_clip_spans(space->select.sel_info.hslab->span_lst,new_spans,&a_not_b,&a_and_b,&b_not_a)<0)
@@ -6678,13 +6556,13 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5S_select_hyperslab
+ * Function:    H5S_select_hyperslab
  *
- * Purpose:	Internal version of H5Sselect_hyperslab().
+ * Purpose:     Internal version of H5Sselect_hyperslab().
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:	Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Wednesday, January 10, 2001
  *
  *-------------------------------------------------------------------------
@@ -6693,9 +6571,9 @@ herr_t
 H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
     const hsize_t *stride, const hsize_t count[], const hsize_t *block)
 {
-    hsize_t int_stride[H5O_LAYOUT_NDIMS];   /* Internal storage for stride information */
-    hsize_t int_count[H5O_LAYOUT_NDIMS];    /* Internal storage for count information */
-    hsize_t int_block[H5O_LAYOUT_NDIMS];    /* Internal storage for block information */
+    hsize_t int_stride[H5S_MAX_RANK];   /* Internal storage for stride information */
+    hsize_t int_count[H5S_MAX_RANK];    /* Internal storage for count information */
+    hsize_t int_block[H5S_MAX_RANK];    /* Internal storage for block information */
     const hsize_t *opt_stride;      /* Optimized stride information */
     const hsize_t *opt_count;       /* Optimized count information */
     const hsize_t *opt_block;       /* Optimized block information */
@@ -6719,9 +6597,7 @@ H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
     if(block == NULL)
         block = H5S_hyper_ones_g;
 
-    /*
-     * Check new selection.
-     */
+    /* Check new selection */
     for(u = 0; u < space->extent.rank; u++) {
         /* Check for overlapping hyperslab blocks in new selection. */
         if(count[u] > 1 && stride[u] < block[u])
@@ -6757,7 +6633,7 @@ H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
             if(unlim_dim >= 0)
                 HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "cannot have more than one unlimited dimension in selection")
             else {
-                if(count[u] == block[u] /* == H5S_UNLIMITED */)
+                if(count[u] == block[u]) /* Both are H5S_UNLIMITED */
                     HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "count and block cannot both be unlimited")
                 unlim_dim = (int)u;
             } /* end else */
@@ -6907,6 +6783,7 @@ H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
             if(op == H5S_SELECT_SET)      /* Allow only "set" operation to proceed */
                 break;
             /* Else fall through to error */
+            H5_ATTR_FALLTHROUGH
 
         case H5S_SEL_ERROR:
         case H5S_SEL_N:
@@ -7387,9 +7264,9 @@ H5S_select_hyperslab (H5S_t *space, H5S_seloper_t op,
 		      const hsize_t count[],
 		      const hsize_t *block)
 {
-    hsize_t int_stride[H5O_LAYOUT_NDIMS];   /* Internal storage for stride information */
-    hsize_t int_count[H5O_LAYOUT_NDIMS];    /* Internal storage for count information */
-    hsize_t int_block[H5O_LAYOUT_NDIMS];    /* Internal storage for block information */
+    hsize_t int_stride[H5S_MAX_RANK];   /* Internal storage for stride information */
+    hsize_t int_count[H5S_MAX_RANK];    /* Internal storage for count information */
+    hsize_t int_block[H5S_MAX_RANK];    /* Internal storage for block information */
     const hsize_t *opt_stride;      /* Optimized stride information */
     const hsize_t *opt_count;       /* Optimized count information */
     const hsize_t *opt_block;       /* Optimized block information */
@@ -7558,10 +7435,10 @@ H5S_select_hyperslab (H5S_t *space, H5S_seloper_t op,
                     /* Convert current "all" selection to "real" hyperslab selection */
                     /* Then allow operation to proceed */
                     {
-                        hsize_t tmp_start[H5O_LAYOUT_NDIMS];   /* Temporary start information */
-                        hsize_t tmp_stride[H5O_LAYOUT_NDIMS];   /* Temporary stride information */
-                        hsize_t tmp_count[H5O_LAYOUT_NDIMS];    /* Temporary count information */
-                        hsize_t tmp_block[H5O_LAYOUT_NDIMS];    /* Temporary block information */
+                        hsize_t tmp_start[H5S_MAX_RANK];   /* Temporary start information */
+                        hsize_t tmp_stride[H5S_MAX_RANK];   /* Temporary stride information */
+                        hsize_t tmp_count[H5S_MAX_RANK];    /* Temporary count information */
+                        hsize_t tmp_block[H5S_MAX_RANK];    /* Temporary block information */
 
                         /* Fill in temporary information for the dimensions */
                         for(u=0; u<space->extent.rank; u++) {
@@ -7806,32 +7683,32 @@ hid_t
 H5Scombine_hyperslab(hid_t space_id, H5S_seloper_t op, const hsize_t start[],
     const hsize_t stride[], const hsize_t count[], const hsize_t block[])
 {
-    H5S_t	*space;                 /* Dataspace to modify selection of */
-    H5S_t	*new_space = NULL;      /* New dataspace created */
-    hid_t	ret_value;              /* Return value */
+    H5S_t   *space;                 /* Dataspace to modify selection of */
+    H5S_t   *new_space = NULL;      /* New dataspace created */
+    hid_t   ret_value;              /* Return value */
 
-    FUNC_ENTER_API(FAIL)
+    FUNC_ENTER_API(H5I_INVALID_HID)
     H5TRACE6("i", "iSs*h*h*h*h", space_id, op, start, stride, count, block);
 
     /* Check args */
     if(NULL == (space = (H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, H5I_INVALID_HID, "not a dataspace")
     if(start == NULL || count == NULL)
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hyperslab not specified")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, H5I_INVALID_HID, "hyperslab not specified")
     if(!(op >= H5S_SELECT_SET && op <= H5S_SELECT_NOTA))
-        HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
+        HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, H5I_INVALID_HID, "invalid selection operation")
 
     /* Copy the first dataspace */
     if (NULL == (new_space = H5S_copy (space, TRUE, TRUE)))
-        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, NULL, "unable to copy dataspace")
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, H5I_INVALID_HID, "unable to copy dataspace")
 
     /* Go modify the selection in the new dataspace */
     if (H5S_select_hyperslab(new_space, op, start, stride, count, block)<0)
-        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to set hyperslab selection")
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, H5I_INVALID_HID, "unable to set hyperslab selection")
 
     /* Atomize */
     if((ret_value = H5I_register(H5I_DATASPACE, new_space, TRUE)) < 0)
-        HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register dataspace atom")
+        HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, H5I_INVALID_HID, "unable to register dataspace atom")
 
 done:
     if(ret_value < 0 && new_space)
@@ -7858,7 +7735,7 @@ H5S__combine_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2)
 {
     H5S_t *new_space = NULL;    /* New dataspace generated */
     hbool_t span2_owned=FALSE;          /* Flag to indicate that span2 was used in H5S_operate_hyperslab() */
-    H5S_t *ret_value;         /* return value */
+    H5S_t *ret_value = NULL;    /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -8127,7 +8004,7 @@ H5S__hyper_get_seq_list_gen(const H5S_t *space, H5S_sel_iter_t *iter,
 {
     H5S_hyper_span_t *curr_span;    /* Current hyperslab span node */
     H5S_hyper_span_t **ispan;       /* Iterator's hyperslab span nodes */
-    hsize_t slab[H5O_LAYOUT_NDIMS]; /* Cumulative size of each dimension in bytes */
+    hsize_t slab[H5S_MAX_RANK]; /* Cumulative size of each dimension in bytes */
     hsize_t acc;       /* Accumulator for computing cumulative sizes */
     hsize_t loc_off;   /* Element offset in the dataspace */
     hsize_t last_span_end = 0; /* The offset of the end of the last span */
@@ -8547,13 +8424,13 @@ H5S__hyper_get_seq_list_opt(const H5S_t *space, H5S_sel_iter_t *iter,
     hsize_t *off, size_t *len)
 {
     hsize_t *mem_size;                  /* Size of the source buffer */
-    hsize_t slab[H5O_LAYOUT_NDIMS];     /* Hyperslab size */
+    hsize_t slab[H5S_MAX_RANK];     /* Hyperslab size */
     const hssize_t *sel_off;            /* Selection offset in dataspace */
-    hsize_t offset[H5O_LAYOUT_NDIMS];   /* Coordinate offset in dataspace */
-    hsize_t tmp_count[H5O_LAYOUT_NDIMS];/* Temporary block count */
-    hsize_t tmp_block[H5O_LAYOUT_NDIMS];/* Temporary block offset */
-    hsize_t wrap[H5O_LAYOUT_NDIMS];     /* Bytes to wrap around at the end of a row */
-    hsize_t skip[H5O_LAYOUT_NDIMS];     /* Bytes to skip between blocks */
+    hsize_t offset[H5S_MAX_RANK];   /* Coordinate offset in dataspace */
+    hsize_t tmp_count[H5S_MAX_RANK];/* Temporary block count */
+    hsize_t tmp_block[H5S_MAX_RANK];/* Temporary block offset */
+    hsize_t wrap[H5S_MAX_RANK];     /* Bytes to wrap around at the end of a row */
+    hsize_t skip[H5S_MAX_RANK];     /* Bytes to skip between blocks */
     const H5S_hyper_dim_t *tdiminfo;    /* Temporary pointer to diminfo information */
     hsize_t fast_dim_start,    /* Local copies of fastest changing dimension info */
         fast_dim_stride,
@@ -8996,9 +8873,9 @@ H5S__hyper_get_seq_list_single(const H5S_t *space, H5S_sel_iter_t *iter,
     const H5S_hyper_dim_t *tdiminfo;    /* Temporary pointer to diminfo information */
     const hssize_t *sel_off;    /* Selection offset in dataspace */
     hsize_t *mem_size;      /* Size of the source buffer */
-    hsize_t base_offset[H5O_LAYOUT_NDIMS];   /* Base coordinate offset in dataspace */
-    hsize_t offset[H5O_LAYOUT_NDIMS];   /* Coordinate offset in dataspace */
-    hsize_t slab[H5O_LAYOUT_NDIMS];     /* Hyperslab size */
+    hsize_t base_offset[H5S_MAX_RANK];   /* Base coordinate offset in dataspace */
+    hsize_t offset[H5S_MAX_RANK];   /* Coordinate offset in dataspace */
+    hsize_t slab[H5S_MAX_RANK];     /* Hyperslab size */
     hsize_t fast_dim_block;     /* Local copies of fastest changing dimension info */
     hsize_t acc;	        /* Accumulator */
     hsize_t loc;                /* Coordinate offset */
@@ -9138,8 +9015,8 @@ H5S__hyper_get_seq_list_single(const H5S_t *space, H5S_sel_iter_t *iter,
                 offset[skip_dim] += tot_blk_count;
             } /* end if */
             else {
-                hsize_t tmp_block[H5O_LAYOUT_NDIMS];/* Temporary block offset */
-                hsize_t skip[H5O_LAYOUT_NDIMS];     /* Bytes to skip between blocks */
+                hsize_t tmp_block[H5S_MAX_RANK];/* Temporary block offset */
+                hsize_t skip[H5S_MAX_RANK];     /* Bytes to skip between blocks */
                 int temp_dim;               /* Temporary rank holder */
 
                 /* Set the starting block location */
@@ -9333,7 +9210,7 @@ H5S__hyper_get_seq_list(const H5S_t *space, unsigned H5_ATTR_UNUSED flags, H5S_s
         /* Check if we stopped in the middle of a sequence of elements */
         if((iter->u.hyp.off[fast_dim] - tdiminfo[fast_dim].start) % tdiminfo[fast_dim].stride != 0 ||
                 ((iter->u.hyp.off[fast_dim] != tdiminfo[fast_dim].start) && tdiminfo[fast_dim].count == 1)) {
-            hsize_t slab[H5O_LAYOUT_NDIMS];     /* Hyperslab size */
+            hsize_t slab[H5S_MAX_RANK];     /* Hyperslab size */
             hsize_t loc;                /* Coordinate offset */
             hsize_t acc;	        /* Accumulator */
             size_t leftover;            /* The number of elements left over from the last sequence */
diff --git a/src/H5Smpio.c b/src/H5Smpio.c
index 3f41be5..28bd253 100644
--- a/src/H5Smpio.c
+++ b/src/H5Smpio.c
@@ -31,12 +31,7 @@
 #include "H5private.h"		/* Generic Functions			*/
 #include "H5Dprivate.h"		/* Datasets				*/
 #include "H5Eprivate.h"		/* Error handling		  	*/
-#include "H5Fprivate.h"		/* File access				*/
-#include "H5FDprivate.h"	/* File drivers				*/
-#include "H5Iprivate.h"		/* IDs			  		*/
 #include "H5MMprivate.h"        /* Memory management                    */
-#include "H5Oprivate.h"		/* Object headers		  	*/
-#include "H5Pprivate.h"         /* Property lists                       */
 #include "H5Spkg.h"		/* Dataspaces 				*/
 #include "H5VMprivate.h"        /* Vector and array functions		*/
 
@@ -198,10 +193,15 @@ H5S__mpio_create_point_datatype(size_t elmt_size, hsize_t num_points,
 {
     MPI_Datatype   elmt_type;           /* MPI datatype for individual element */
     hbool_t        elmt_type_created = FALSE;   /* Whether the element MPI datatype was created */
-    int            mpi_code;            /* MPI error code */
+    int            *inner_blocks = NULL;        /* Arrays for MPI datatypes when "large" datatype needed */
+    MPI_Aint       *inner_disps = NULL;
+    MPI_Datatype   *inner_types = NULL;
+#if MPI_VERSION < 3
     int            *blocks = NULL;      /* Array of block sizes for MPI hindexed create call */
     hsize_t        u;                   /* Local index variable */
+#endif
     hsize_t        bigio_count;         /* Transition point to create derived type */
+    int            mpi_code;            /* MPI error code */
     herr_t	   ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
@@ -246,10 +246,6 @@ H5S__mpio_create_point_datatype(size_t elmt_size, hsize_t num_points,
         int num_big_types;
         hsize_t leftover;
 
-        int *inner_blocks;
-        MPI_Aint *inner_disps;
-        MPI_Datatype *inner_types = NULL;
-
         /* Calculate how many Big MPI datatypes are needed to represent the buffer */
         num_big_types = (int)(num_points / bigio_count);
 
@@ -279,8 +275,8 @@ H5S__mpio_create_point_datatype(size_t elmt_size, hsize_t num_points,
 
         for(i = 0; i < num_big_types; i++) {
 #if MPI_VERSION >= 3
-            if(MPI_SUCCESS != (mpi_code = MPI_Type_create_hindexed_block(bigio_count,
-                    1, &disp[i*bigio_count], elmt_type, &inner_types[i])))
+            if(MPI_SUCCESS != (mpi_code = MPI_Type_create_hindexed_block((int)bigio_count,
+                    1, &disp[(hsize_t)i*bigio_count], elmt_type, &inner_types[i])))
                 HMPI_GOTO_ERROR(FAIL, "MPI_Type_create_hindexed_block failed", mpi_code);
 #else
             if(MPI_SUCCESS != (mpi_code = MPI_Type_create_hindexed((int)bigio_count,
@@ -294,7 +290,7 @@ H5S__mpio_create_point_datatype(size_t elmt_size, hsize_t num_points,
         if(remaining_points) {
 #if MPI_VERSION >= 3
             if(MPI_SUCCESS != (mpi_code = MPI_Type_create_hindexed_block(remaining_points,
-                    1, &disp[num_big_types*bigio_count], elmt_type, &inner_types[num_big_types])))
+                    1, &disp[(hsize_t)num_big_types*bigio_count], elmt_type, &inner_types[num_big_types])))
                 HMPI_GOTO_ERROR(FAIL, "MPI_Type_create_hindexed_block failed", mpi_code);
 #else
             if(MPI_SUCCESS != (mpi_code = MPI_Type_create_hindexed((int)remaining_points,
@@ -312,10 +308,6 @@ H5S__mpio_create_point_datatype(size_t elmt_size, hsize_t num_points,
         for(i = 0; i < total_types; i++)
             MPI_Type_free(&inner_types[i]);
 
-        H5MM_free(inner_types);
-        H5MM_free(inner_blocks);
-        H5MM_free(inner_disps);
-
         /* Commit MPI datatype for later use */
         if(MPI_SUCCESS != (mpi_code = MPI_Type_commit(new_type)))
             HMPI_GOTO_ERROR(FAIL, "MPI_Type_commit failed", mpi_code)
@@ -324,8 +316,16 @@ H5S__mpio_create_point_datatype(size_t elmt_size, hsize_t num_points,
 done:
     if(elmt_type_created)
         MPI_Type_free(&elmt_type);
+#if MPI_VERSION < 3
     if(blocks)
         H5MM_free(blocks);
+#endif
+    if(inner_types)
+        H5MM_free(inner_types);
+    if(inner_blocks)
+        H5MM_free(inner_blocks);
+    if(inner_disps)
+        H5MM_free(inner_disps);
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5S__mpio_create_point_datatype() */
@@ -1033,6 +1033,7 @@ static herr_t
 H5S__obtain_datatype(const hsize_t *down, H5S_hyper_span_t *spans,
     const MPI_Datatype *elmt_type, MPI_Datatype *span_type, size_t elmt_size)
 {
+    H5S_hyper_span_t      *span;                /* Hyperslab span to iterate with */
     hsize_t               bigio_count;          /* Transition point to create derived type */
     size_t                alloc_count = 0;      /* Number of span tree nodes allocated at this level */
     size_t                outercount = 0;       /* Number of span tree nodes at this level */
@@ -1042,7 +1043,7 @@ H5S__obtain_datatype(const hsize_t *down, H5S_hyper_span_t *spans,
     hbool_t large_block = FALSE;                /* Wether the block length is larger than 32 bit integer */
     int                   *blocklen = NULL;
     MPI_Aint              *disp = NULL;
-    H5S_hyper_span_t      *tspan = NULL;        /* Temporary pointer to span tree node */
+    size_t                u;                    /* Local index variable */
     int                   mpi_code;             /* MPI return status code */
     herr_t                ret_value = SUCCEED;  /* Return value */
 
@@ -1061,9 +1062,9 @@ H5S__obtain_datatype(const hsize_t *down, H5S_hyper_span_t *spans,
 
     /* if this is the fastest changing dimension, it is the base case for derived datatype. */
     if(NULL == spans->down) {
-        tspan = spans;
+        span = spans;
         outercount = 0;
-        while(tspan) {
+        while(span) {
             /* Check if we need to increase the size of the buffers */
             if(outercount >= alloc_count) {
                 MPI_Aint     *tmp_disp;         /* Temporary pointer to new displacement buffer */
@@ -1082,10 +1083,10 @@ H5S__obtain_datatype(const hsize_t *down, H5S_hyper_span_t *spans,
             } /* end if */
 
             /* Store displacement & block length */
-            disp[outercount]      = (MPI_Aint)elmt_size * tspan->low;
-            H5_CHECK_OVERFLOW(tspan->nelem, hsize_t, int)
-            blocklen[outercount]  = (int)tspan->nelem;
-            tspan                 = tspan->next;
+            disp[outercount]      = (MPI_Aint)elmt_size * span->low;
+            H5_CHECK_OVERFLOW(span->nelem, hsize_t, int)
+            blocklen[outercount]  = (int)span->nelem;
+            span                 = span->next;
 
             if (bigio_count < blocklen[outercount]) {
                 large_block = TRUE; /* at least one block type is large, so set this flag to true */
@@ -1146,14 +1147,13 @@ H5S__obtain_datatype(const hsize_t *down, H5S_hyper_span_t *spans,
 
     } /* end if */
     else {
-        size_t u;               /* Local index variable */
 
         if(NULL == (inner_type = (MPI_Datatype *)H5MM_malloc(alloc_count * sizeof(MPI_Datatype))))
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, FAIL, "can't allocate array of inner MPI datatypes")
 
-        tspan = spans;
+        span = spans;
         outercount = 0;
-        while(tspan) {
+        while(span) {
             MPI_Datatype down_type;     /* Temporary MPI datatype for a span tree node's children */
             MPI_Aint stride;            /* Distance between inner MPI datatypes */
 
@@ -1182,17 +1182,17 @@ H5S__obtain_datatype(const hsize_t *down, H5S_hyper_span_t *spans,
             /* First using MPI Type vector to build derived data type for this span only */
             /* Need to calculate the disp in byte for this dimension. */
             /* Calculate the total bytes of the lower dimension */
-            disp[outercount]      = tspan->low * (*down) * elmt_size;
+            disp[outercount]      = span->low * (*down) * elmt_size;
             blocklen[outercount]  = 1;
 
             /* Generate MPI datatype for next dimension down */
-            if(H5S__obtain_datatype(down + 1, tspan->down->head, elmt_type, &down_type, elmt_size) < 0)
+            if(H5S__obtain_datatype(down + 1, span->down->head, elmt_type, &down_type, elmt_size) < 0)
                 HGOTO_ERROR(H5E_DATASPACE, H5E_BADTYPE, FAIL, "couldn't obtain  MPI derived data type")
 
             /* Build the MPI datatype for this node */
             stride = (*down) * elmt_size;
-            H5_CHECK_OVERFLOW(tspan->nelem, hsize_t, int)
-            if(MPI_SUCCESS != (mpi_code = MPI_Type_create_hvector((int)tspan->nelem, 1, stride, down_type, &inner_type[outercount]))) {
+            H5_CHECK_OVERFLOW(span->nelem, hsize_t, int)
+            if(MPI_SUCCESS != (mpi_code = MPI_Type_create_hvector((int)span->nelem, 1, stride, down_type, &inner_type[outercount]))) {
                 MPI_Type_free(&down_type);
                 HMPI_GOTO_ERROR(FAIL, "MPI_Type_create_hvector failed", mpi_code)
             } /* end if */
@@ -1201,7 +1201,7 @@ H5S__obtain_datatype(const hsize_t *down, H5S_hyper_span_t *spans,
             if(MPI_SUCCESS != (mpi_code = MPI_Type_free(&down_type)))
                 HMPI_GOTO_ERROR(FAIL, "MPI_Type_free failed", mpi_code)
 
-            tspan = tspan->next;
+            span = span->next;
             outercount++;
          } /* end while */
 
@@ -1221,14 +1221,10 @@ H5S__obtain_datatype(const hsize_t *down, H5S_hyper_span_t *spans,
 done:
     /* General cleanup */
     if(inner_type != NULL) {
-        if(!inner_types_freed) {
-            size_t u;          /* Local index variable */
-
+        if(!inner_types_freed)
             for(u = 0; u < outercount; u++)
                 if(MPI_SUCCESS != (mpi_code = MPI_Type_free(&inner_type[u])))
                     HMPI_DONE_ERROR(FAIL, "MPI_Type_free failed", mpi_code)
-        } /* end if */
-
         H5MM_free(inner_type);
     } /* end if */
     if(blocklen != NULL)
diff --git a/src/H5Snone.c b/src/H5Snone.c
index c17ba40..1546d0b 100644
--- a/src/H5Snone.c
+++ b/src/H5Snone.c
@@ -66,10 +66,10 @@ static int H5S__none_unlim_dim(const H5S_t *space);
 static htri_t H5S__none_is_contiguous(const H5S_t *space);
 static htri_t H5S__none_is_single(const H5S_t *space);
 static htri_t H5S__none_is_regular(const H5S_t *space);
-static void H5S__none_adjust_u(H5S_t *space, const hsize_t *offset);
+static herr_t H5S__none_adjust_u(H5S_t *space, const hsize_t *offset);
 static herr_t H5S__none_project_scalar(const H5S_t *space, hsize_t *offset);
 static herr_t H5S__none_project_simple(const H5S_t *space, H5S_t *new_space, hsize_t *offset);
-static herr_t H5S__none_iter_init(H5S_sel_iter_t *iter, const H5S_t *space);
+static herr_t H5S__none_iter_init(const H5S_t *space, H5S_sel_iter_t *iter);
 
 /* Selection iteration callbacks */
 static herr_t H5S__none_iter_coords(const H5S_sel_iter_t *iter, hsize_t *coords);
@@ -149,7 +149,7 @@ static const H5S_sel_iter_class_t H5S_sel_iter_none[1] = {{
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5S__none_iter_init(H5S_sel_iter_t *iter, const H5S_t H5_ATTR_UNUSED *space)
+H5S__none_iter_init(const H5S_t H5_ATTR_UNUSED *space, H5S_sel_iter_t *iter)
 {
     FUNC_ENTER_STATIC_NOERR
 
@@ -801,11 +801,11 @@ H5S__none_is_regular(const H5S_t H5_ATTR_UNUSED *space)
  PURPOSE
     Adjust an "none" selection by subtracting an offset
  USAGE
-    void H5S__none_adjust_u(space, offset)
+    herr_t H5S__none_adjust_u(space, offset)
         H5S_t *space;           IN/OUT: Pointer to dataspace to adjust
         const hsize_t *offset; IN: Offset to subtract
  RETURNS
-    None
+    Non-negative on success, negative on failure
  DESCRIPTION
     Moves selection by subtracting an offset from it.
  GLOBAL VARIABLES
@@ -813,7 +813,7 @@ H5S__none_is_regular(const H5S_t H5_ATTR_UNUSED *space)
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
-static void
+static herr_t
 H5S__none_adjust_u(H5S_t H5_ATTR_UNUSED *space, const hsize_t H5_ATTR_UNUSED *offset)
 {
     FUNC_ENTER_STATIC_NOERR
@@ -822,7 +822,7 @@ H5S__none_adjust_u(H5S_t H5_ATTR_UNUSED *space, const hsize_t H5_ATTR_UNUSED *of
     HDassert(space);
     HDassert(offset);
 
-    FUNC_LEAVE_NOAPI_VOID
+    FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5S__none_adjust_u() */
 
 
diff --git a/src/H5Spkg.h b/src/H5Spkg.h
index 6ba671b..d95c4ff 100644
--- a/src/H5Spkg.h
+++ b/src/H5Spkg.h
@@ -29,6 +29,9 @@
 /* Get package's private header */
 #include "H5Sprivate.h"
 
+/* Other private headers needed by this file */
+#include "H5Oprivate.h"		/* Object headers		  	*/
+
 /* Flags to indicate special dataspace features are active */
 #define H5S_VALID_MAX	0x01
 #define H5S_VALID_PERM	0x02
@@ -106,29 +109,29 @@ struct H5S_extent_t {
 
 /* Node in point selection list (typedef'd in H5Sprivate.h) */
 struct H5S_pnt_node_t {
+    struct H5S_pnt_node_t *next; /* Pointer to next point in list */
     hsize_t *pnt;          /* Pointer to a selected point */
-    struct H5S_pnt_node_t *next;  /* pointer to next point in list */
 };
 
-/* Information about point selection list */
-typedef struct {
+/* Information about point selection list (typedef'd in H5Sprivate.h) */
+struct H5S_pnt_list_t {
     H5S_pnt_node_t *head;   /* Pointer to head of point list */
-} H5S_pnt_list_t;
+};
 
 /* Information about hyperslab spans */
 
-/* Information a particular hyperslab span */
+/* Information a particular hyperslab span (typedef'd in H5Sprivate.h) */
 struct H5S_hyper_span_t {
-    hsize_t low, high;          /* Low & high bounds of span */
+    hsize_t low, high;  /* Low & high bounds of elements selected for span, inclusive */
     hsize_t nelem;              /* Number of elements in span (only needed during I/O) */
     hsize_t pstride;            /* Pseudo-stride from start of previous span (only used during I/O) */
-    struct H5S_hyper_span_info_t *down;     /* Pointer to list of spans in next dimension down */
-    struct H5S_hyper_span_t *next;     /* Pointer to next span in list */
+    struct H5S_hyper_span_info_t *down; /* Pointer to list of spans in next dimension down */
+    struct H5S_hyper_span_t *next;      /* Pointer to next span in list */
 };
 
-/* Information about a list of hyperslab spans in one dimension */
+/* Information about a list of hyperslab spans in one dimension (typedef'd in H5Sprivate.h) */
 struct H5S_hyper_span_info_t {
-    unsigned count;                    /* Ref. count of number of spans which share this span */
+    unsigned count;     /* Ref. count of number of spans which share this span */
     struct H5S_hyper_span_info_t *scratch;  /* Scratch pointer
                                              * (used during copies, as mark
                                              * during precomputes for I/O &
@@ -140,7 +143,7 @@ struct H5S_hyper_span_info_t {
 
 /* Information about hyperslab selection */
 typedef struct {
-    hbool_t diminfo_valid;                      /* Whether the dataset has valid diminfo */
+    hbool_t diminfo_valid;  /* Whether the dataset has valid diminfo */
     H5S_hyper_dim_t opt_diminfo[H5S_MAX_RANK];  /* per-dim selection info */
     H5S_hyper_dim_t app_diminfo[H5S_MAX_RANK];  /* per-dim selection info */
 	/* 'opt_diminfo' points to a [potentially] optimized version of the user's
@@ -187,13 +190,13 @@ typedef htri_t (*H5S_sel_is_single_func_t)(const H5S_t *space);
 /* Method to determine if current selection is "regular" */
 typedef htri_t (*H5S_sel_is_regular_func_t)(const H5S_t *space);
 /* Method to adjust a selection by an offset */
-typedef void (*H5S_sel_adjust_u_func_t)(H5S_t *space, const hsize_t *offset);
+typedef herr_t (*H5S_sel_adjust_u_func_t)(H5S_t *space, const hsize_t *offset);
 /* Method to construct single element projection onto scalar dataspace */
 typedef herr_t (*H5S_sel_project_scalar)(const H5S_t *space, hsize_t *offset);
 /* Method to construct selection projection onto/into simple dataspace */
 typedef herr_t (*H5S_sel_project_simple)(const H5S_t *space, H5S_t *new_space, hsize_t *offset);
 /* Method to initialize iterator for current selection */
-typedef herr_t (*H5S_sel_iter_init_func_t)(H5S_sel_iter_t *sel_iter, const H5S_t *space);
+typedef herr_t (*H5S_sel_iter_init_func_t)(const H5S_t *space, H5S_sel_iter_t *sel_iter);
 
 /* Selection class information */
 typedef struct {
diff --git a/src/H5Spoint.c b/src/H5Spoint.c
index 2d73dfd..89ce86a 100644
--- a/src/H5Spoint.c
+++ b/src/H5Spoint.c
@@ -65,10 +65,10 @@ static int H5S__point_unlim_dim(const H5S_t *space);
 static htri_t H5S__point_is_contiguous(const H5S_t *space);
 static htri_t H5S__point_is_single(const H5S_t *space);
 static htri_t H5S__point_is_regular(const H5S_t *space);
-static void H5S__point_adjust_u(H5S_t *space, const hsize_t *offset);
+static herr_t H5S__point_adjust_u(H5S_t *space, const hsize_t *offset);
 static herr_t H5S__point_project_scalar(const H5S_t *space, hsize_t *offset);
 static herr_t H5S__point_project_simple(const H5S_t *space, H5S_t *new_space, hsize_t *offset);
-static herr_t H5S__point_iter_init(H5S_sel_iter_t *iter, const H5S_t *space);
+static herr_t H5S__point_iter_init(const H5S_t *space, H5S_sel_iter_t *iter);
 static herr_t H5S__point_get_version_enc_size(const H5S_t *space, uint32_t *version, uint8_t *enc_size);
 
 /* Selection iteration callbacks */
@@ -139,7 +139,7 @@ H5FL_DEFINE_STATIC(H5S_pnt_list_t);
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5S__point_iter_init(H5S_sel_iter_t *iter, const H5S_t *space)
+H5S__point_iter_init(const H5S_t *space, H5S_sel_iter_t *iter)
 {
     FUNC_ENTER_STATIC_NOERR
 
@@ -538,7 +538,7 @@ H5S__point_release(H5S_t *space)
     herr_t H5S_select_elements(dsid, op, num_elem, coord)
         hid_t dsid;             IN: Dataspace ID of selection to modify
         H5S_seloper_t op;       IN: Operation to perform on current selection
-        hsize_t num_elem;       IN: Number of elements in COORD array.
+        size_t num_elem;        IN: Number of elements in COORD array.
         const hsize_t *coord;   IN: The location of each element selected
  RETURNS
     Non-negative on success/Negative on failure
@@ -560,7 +560,7 @@ H5S__point_release(H5S_t *space)
  REVISION LOG
 --------------------------------------------------------------------------*/
 herr_t
-H5S_select_elements(H5S_t *space, H5S_seloper_t op, hsize_t num_elem,
+H5S_select_elements(H5S_t *space, H5S_seloper_t op, size_t num_elem,
     const hsize_t *coord)
 {
     herr_t ret_value = SUCCEED;         /* Return value */
@@ -579,9 +579,10 @@ H5S_select_elements(H5S_t *space, H5S_seloper_t op, hsize_t num_elem,
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't release point selection")
 
     /* Allocate space for the point selection information if necessary */
-    if(H5S_GET_SELECT_TYPE(space) != H5S_SEL_POINTS || space->select.sel_info.pnt_lst == NULL)
+    if(H5S_GET_SELECT_TYPE(space) != H5S_SEL_POINTS || space->select.sel_info.pnt_lst == NULL) {
         if(NULL == (space->select.sel_info.pnt_lst = H5FL_CALLOC(H5S_pnt_list_t)))
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate element information")
+    }
 
     /* Add points to selection */
     if(H5S__point_add(space, op, num_elem, coord) < 0)
@@ -1492,11 +1493,11 @@ H5S__point_is_regular(const H5S_t *space)
  PURPOSE
     Adjust a "point" selection by subtracting an offset
  USAGE
-    void H5S_point_adjust_u(space, offset)
+    herr_t H5S__point_adjust_u(space, offset)
         H5S_t *space;           IN/OUT: Pointer to dataspace to adjust
         const hsize_t *offset; IN: Offset to subtract
  RETURNS
-    None
+    Non-negative on success, negative on failure
  DESCRIPTION
     Moves a point selection by subtracting an offset from it.
  GLOBAL VARIABLES
@@ -1504,37 +1505,47 @@ H5S__point_is_regular(const H5S_t *space)
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
-static void
+static herr_t
 H5S__point_adjust_u(H5S_t *space, const hsize_t *offset)
 {
+    hbool_t non_zero_offset = FALSE;    /* Whether any offset is non-zero */
     H5S_pnt_node_t *node;               /* Point node */
     unsigned rank;                      /* Dataspace rank */
+    unsigned u;                         /* Local index variable */
 
     FUNC_ENTER_STATIC_NOERR
 
     HDassert(space);
     HDassert(offset);
 
-    /* Iterate through the nodes, checking the bounds on each element */
-    node = space->select.sel_info.pnt_lst->head;
-    rank = space->extent.rank;
-    while(node) {
-        unsigned u;                         /* Local index variable */
-
-        /* Adjust each coordinate for point node */
-        for(u = 0; u < rank; u++) {
-            /* Check for offset moving selection negative */
-            HDassert(node->pnt[u] >= offset[u]);
-
-            /* Adjust node's coordinate location */
-            node->pnt[u] -= offset[u];
-        } /* end for */
+    /* Check for an all-zero offset vector */
+    for(u = 0; u < space->extent.rank; u++)
+        if(0 != offset[u]) {
+            non_zero_offset = TRUE;
+            break;
+        }
 
-        /* Advance to next point node in selection */
-        node = node->next;
-    } /* end while */
+    /* Only perform operation if the offset is non-zero */
+    if(non_zero_offset) {
+        /* Iterate through the nodes, checking the bounds on each element */
+        node = space->select.sel_info.pnt_lst->head;
+        rank = space->extent.rank;
+        while(node) {
+            /* Adjust each coordinate for point node */
+            for(u = 0; u < rank; u++) {
+                /* Check for offset moving selection negative */
+                HDassert(node->pnt[u] >= offset[u]);
+
+                /* Adjust node's coordinate location */
+                node->pnt[u] -= offset[u];
+            } /* end for */
+
+            /* Advance to next point node in selection */
+            node = node->next;
+        } /* end while */
+    } /* end if */
 
-    FUNC_LEAVE_NOAPI_VOID
+    FUNC_LEAVE_NOAPI(SUCCEED)
 } /* end H5S__point_adjust_u() */
 
 
@@ -1758,7 +1769,7 @@ H5Sselect_elements(hid_t spaceid, H5S_seloper_t op, size_t num_elem,
         HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "unsupported operation attempted")
 
     /* Call the real element selection routine */
-    if((ret_value = H5S_select_elements(space, op, (hsize_t)num_elem, coord)) < 0)
+    if((ret_value = H5S_select_elements(space, op, num_elem, coord)) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't select elements")
 
 done:
@@ -1805,7 +1816,7 @@ H5S__point_get_seq_list(const H5S_t *space, unsigned flags, H5S_sel_iter_t *iter
     size_t io_left;             /* The number of bytes left in the selection */
     size_t start_io_left;       /* The initial number of bytes left in the selection */
     H5S_pnt_node_t *node;       /* Point node */
-    hsize_t dims[H5O_LAYOUT_NDIMS];     /* Total size of memory buf */
+    hsize_t dims[H5S_MAX_RANK];     /* Total size of memory buf */
     int	ndims;                  /* Dimensionality of space*/
     hsize_t	acc;            /* Coordinate accumulator */
     hsize_t	loc;            /* Coordinate offset */
diff --git a/src/H5Sprivate.h b/src/H5Sprivate.h
index 588b395..c361612 100644
--- a/src/H5Sprivate.h
+++ b/src/H5Sprivate.h
@@ -17,9 +17,6 @@
 #ifndef _H5Sprivate_H
 #define _H5Sprivate_H
 
-/* Early typedefs to avoid circular dependencies */
-typedef struct H5S_t H5S_t;
-
 /* Include package's public header */
 #include "H5Spublic.h"
 
@@ -33,21 +30,13 @@ typedef struct H5S_t H5S_t;
 #include "H5Pprivate.h"		/* Property lists			*/
 #include "H5Tprivate.h"		/* Datatypes				*/
 
-/* Flags for H5S_find */
-#define H5S_CONV_PAR_IO_POSSIBLE        0x0001
-/* The storage options are mutually exclusive */
-/* (2-bits reserved for storage type currently) */
-#define H5S_CONV_STORAGE_COMPACT        0x0000  /* i.e. '0' */
-#define H5S_CONV_STORAGE_CONTIGUOUS     0x0002  /* i.e. '1' */
-#define H5S_CONV_STORAGE_CHUNKED        0x0004  /* i.e. '2' */
-#define H5S_CONV_STORAGE_MASK           0x0006
-
 /* Flags for "get_seq_list" methods */
 #define H5S_GET_SEQ_LIST_SORTED         0x0001
 
 /* Forward references of package typedefs */
 typedef struct H5S_extent_t H5S_extent_t;
 typedef struct H5S_pnt_node_t H5S_pnt_node_t;
+typedef struct H5S_pnt_list_t H5S_pnt_list_t;
 typedef struct H5S_hyper_span_t H5S_hyper_span_t;
 typedef struct H5S_hyper_span_info_t H5S_hyper_span_info_t;
 
@@ -147,7 +136,6 @@ typedef struct H5S_sel_iter_op_t {
 #define H5S_GET_SELECT_TYPE(S)          ((S)->select.type->type)
 #define H5S_SELECT_GET_SEQ_LIST(S,FLAGS,ITER,MAXSEQ,MAXBYTES,NSEQ,NBYTES,OFF,LEN)             ((*(S)->select.type->get_seq_list)(S,FLAGS,ITER,MAXSEQ,MAXBYTES,NSEQ,NBYTES,OFF,LEN))
 #define H5S_SELECT_VALID(S)             ((*(S)->select.type->is_valid)(S))
-#define H5S_SELECT_RELEASE(S)           ((*(S)->select.type->release)(S))
 #define H5S_SELECT_SERIAL_SIZE(S)       ((*(S)->select.type->serial_size)(S))
 #define H5S_SELECT_SERIALIZE(S,BUF)     ((*(S)->select.type->serialize)(S,BUF))
 #define H5S_SELECT_BOUNDS(S,START,END)  ((*(S)->select.type->bounds)(S,START,END))
@@ -173,7 +161,6 @@ typedef struct H5S_sel_iter_op_t {
 #define H5S_GET_SELECT_TYPE(S)          (H5S_get_select_type(S))
 #define H5S_SELECT_GET_SEQ_LIST(S,FLAGS,ITER,MAXSEQ,MAXBYTES,NSEQ,NBYTES,OFF,LEN)       (H5S_select_get_seq_list(S,FLAGS,ITER,MAXSEQ,MAXBYTES,NSEQ,NBYTES,OFF,LEN))
 #define H5S_SELECT_VALID(S)             (H5S_select_valid(S))
-#define H5S_SELECT_RELEASE(S)           (H5S_select_release(S))
 #define H5S_SELECT_SERIAL_SIZE(S)       (H5S_select_serial_size(S))
 #define H5S_SELECT_SERIALIZE(S,BUF)     (H5S_select_serialize(S,BUF))
 #define H5S_SELECT_BOUNDS(S,START,END)  (H5S_get_select_bounds(S,START,END))
@@ -192,11 +179,17 @@ typedef struct H5S_sel_iter_op_t {
 #define H5S_SELECT_ITER_NEXT_BLOCK(ITER)        (H5S_select_iter_next_block(ITER))
 #define H5S_SELECT_ITER_RELEASE(ITER)   (H5S_select_iter_release(ITER))
 #endif /* H5S_MODULE */
+
 /* Handle these callbacks in a special way, since they have prologs that need to be executed */
 #define H5S_SELECT_COPY(DST,SRC,SHARE)  (H5S_select_copy(DST,SRC,SHARE))
+#define H5S_SELECT_SHAPE_SAME(S1,S2)    (H5S_select_shape_same(S1,S2))
+#define H5S_SELECT_RELEASE(S)           (H5S_select_release(S))
 #define H5S_SELECT_DESERIALIZE(S,BUF)   (H5S_select_deserialize(S,BUF))
 
 
+/* Early typedef to avoid circular dependencies */
+typedef struct H5S_t H5S_t;
+
 /* Operations on dataspaces */
 H5_DLL H5S_t *H5S_copy(const H5S_t *src, hbool_t share_selection, hbool_t copy_max);
 H5_DLL herr_t H5S_close(H5S_t *ds);
@@ -259,7 +252,7 @@ H5_DLL herr_t H5S_select_serialize(const H5S_t *space, uint8_t **p);
 H5_DLL htri_t H5S_select_is_contiguous(const H5S_t *space);
 H5_DLL htri_t H5S_select_is_single(const H5S_t *space);
 H5_DLL htri_t H5S_select_is_regular(const H5S_t *space);
-H5_DLL void H5S_select_adjust_u(H5S_t *space, const hsize_t *offset);
+H5_DLL herr_t H5S_select_adjust_u(H5S_t *space, const hsize_t *offset);
 H5_DLL herr_t H5S_select_project_scalar(const H5S_t *space, hsize_t *offset);
 H5_DLL herr_t H5S_select_project_simple(const H5S_t *space, H5S_t *new_space, hsize_t *offset);
 H5_DLL herr_t H5S_select_project_intersection(const H5S_t *src_space,
@@ -275,7 +268,7 @@ H5_DLL herr_t H5S_select_none(H5S_t *space);
 
 /* Operations on point selections */
 H5_DLL herr_t H5S_select_elements(H5S_t *space, H5S_seloper_t op,
-    hsize_t num_elem, const hsize_t *coord);
+    size_t num_elem, const hsize_t *coord);
 
 /* Operations on hyperslab selections */
 H5_DLL herr_t H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
@@ -284,9 +277,6 @@ H5_DLL herr_t H5S_hyper_add_span_element(H5S_t *space, unsigned rank,
     const hsize_t *coords);
 H5_DLL herr_t H5S_hyper_reset_scratch(H5S_t *space);
 H5_DLL herr_t H5S_hyper_convert(H5S_t *space);
-#ifdef LATER
-H5_DLL htri_t H5S_hyper_intersect (H5S_t *space1, H5S_t *space2);
-#endif /* LATER */
 H5_DLL htri_t H5S_hyper_intersect_block(H5S_t *space, const hsize_t *start, const hsize_t *end);
 H5_DLL herr_t H5S_hyper_adjust_s(H5S_t *space, const hssize_t *offset);
 H5_DLL htri_t H5S_hyper_normalize_offset(H5S_t *space, hssize_t *old_offset);
diff --git a/src/H5Sselect.c b/src/H5Sselect.c
index 8657008..815c0b8 100644
--- a/src/H5Sselect.c
+++ b/src/H5Sselect.c
@@ -124,6 +124,49 @@ H5S_select_offset(H5S_t *space, const hssize_t *offset)
 
 /*--------------------------------------------------------------------------
  NAME
+    H5Soffset_simple
+ PURPOSE
+    Changes the offset of a selection within a simple dataspace extent
+ USAGE
+    herr_t H5Soffset_simple(space_id, offset)
+        hid_t space_id;	        IN: Dataspace object to reset
+        const hssize_t *offset; IN: Offset to position the selection at
+ RETURNS
+    Non-negative on success/Negative on failure
+ DESCRIPTION
+	This function creates an offset for the selection within an extent, allowing
+    the same shaped selection to be moved to different locations within a
+    dataspace without requiring it to be re-defined.
+--------------------------------------------------------------------------*/
+herr_t
+H5Soffset_simple(hid_t space_id, const hssize_t *offset)
+{
+    H5S_t *space;                   /* Dataspace to modify */
+    herr_t ret_value = SUCCEED;     /* Return value */
+
+    FUNC_ENTER_API(FAIL)
+    H5TRACE2("e", "i*Hs", space_id, offset);
+
+    /* Check args */
+    if(NULL == (space = (H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE)))
+        HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "not a dataspace")
+    if(space->extent.rank == 0 || (H5S_GET_EXTENT_TYPE(space) == H5S_SCALAR
+            || H5S_GET_EXTENT_TYPE(space) == H5S_NULL))
+        HGOTO_ERROR(H5E_ATOM, H5E_UNSUPPORTED, FAIL, "can't set offset on scalar or null dataspace")
+    if(offset == NULL)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no offset specified")
+
+    /* Set the selection offset */
+    if(H5S_select_offset(space, offset) < 0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "can't set offset")
+
+done:
+    FUNC_LEAVE_API(ret_value)
+} /* end H5Soffset_simple() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
     H5S_select_copy
  PURPOSE
     Copy a selection from one dataspace to another
@@ -189,7 +232,7 @@ done:
 herr_t
 H5S_select_release(H5S_t *ds)
 {
-    herr_t ret_value = FAIL;    /* Return value */
+    herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -870,11 +913,11 @@ H5S_select_is_regular(const H5S_t *space)
  PURPOSE
     Adjust a selection by subtracting an offset
  USAGE
-    void H5S_select_adjust_u(space, offset)
+    herr_t H5S_select_adjust_u(space, offset)
         H5S_t *space;           IN/OUT: Pointer to dataspace to adjust
         const hsize_t *offset; IN: Offset to subtract
  RETURNS
-    None
+    Non-negative on success, negative on failure
  DESCRIPTION
     Moves a selection by subtracting an offset from it.
  GLOBAL VARIABLES
@@ -885,18 +928,21 @@ H5S_select_is_regular(const H5S_t *space)
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
-void
+herr_t
 H5S_select_adjust_u(H5S_t *space, const hsize_t *offset)
 {
+    herr_t ret_value = SUCCEED;         /* Return value */
+
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     /* Check args */
     HDassert(space);
     HDassert(offset);
 
-    (*space->select.type->adjust_u)(space, offset);
+    /* Perform operation */
+    ret_value = (*space->select.type->adjust_u)(space, offset);
 
-    FUNC_LEAVE_NOAPI_VOID
+    FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S_select_adjust_u() */
 
 
@@ -1024,7 +1070,7 @@ H5S_select_iter_init(H5S_sel_iter_t *sel_iter, const H5S_t *space,
     sel_iter->elmt_size = elmt_size;
 
     /* Call initialization routine for selection type */
-    ret_value = (*space->select.type->iter_init)(sel_iter, space);
+    ret_value = (*space->select.type->iter_init)(space, sel_iter);
     HDassert(sel_iter->type);
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -1351,7 +1397,7 @@ H5S_select_iterate(void *buf, const H5T_t *type, const H5S_t *space,
     hsize_t *off = NULL;        /* Array to store sequence offsets */
     size_t *len = NULL;         /* Array to store sequence lengths */
     hssize_t nelmts;            /* Number of elements in selection */
-    hsize_t space_size[H5O_LAYOUT_NDIMS]; /* Dataspace size */
+    hsize_t space_size[H5S_MAX_RANK]; /* Dataspace size */
     size_t max_elem;            /* Maximum number of elements allowed in sequences */
     size_t elmt_size;           /* Datatype size */
     unsigned ndims;             /* Number of dimensions in dataspace */
@@ -1425,7 +1471,7 @@ H5S_select_iterate(void *buf, const H5T_t *type, const H5S_t *space,
 
             /* Loop, while bytes left in sequence */
             while(curr_len > 0 && user_ret == 0) {
-                hsize_t coords[H5O_LAYOUT_NDIMS];  /* Coordinates of element in dataspace */
+                hsize_t coords[H5S_MAX_RANK];  /* Coordinates of element in dataspace */
                 hsize_t tmp_off;        /* Temporary offset within sequence */
                 uint8_t *loc;           /* Current element location in buffer */
                 int i;			/* Local Index variable */
@@ -1648,8 +1694,8 @@ H5S_select_shape_same(const H5S_t *space1, const H5S_t *space2)
 
         /* Check for "easy" cases before getting into generalized block iteration code */
         if((H5S_GET_SELECT_TYPE(space_a) == H5S_SEL_ALL) && (H5S_GET_SELECT_TYPE(space_b) == H5S_SEL_ALL)) {
-            hsize_t dims1[H5O_LAYOUT_NDIMS];    /* End point of selection block in dataspace #1 */
-            hsize_t dims2[H5O_LAYOUT_NDIMS];    /* End point of selection block in dataspace #2 */
+            hsize_t dims1[H5S_MAX_RANK];    /* End point of selection block in dataspace #1 */
+            hsize_t dims2[H5S_MAX_RANK];    /* End point of selection block in dataspace #2 */
             int space_a_dim;                /* Current dimension in dataspace A */
             int space_b_dim;                /* Current dimension in dataspace B */
 
@@ -2277,7 +2323,7 @@ herr_t
 H5S_select_project_intersection(const H5S_t *src_space, const H5S_t *dst_space,
     const H5S_t *src_intersect_space, H5S_t **new_space_ptr)
 {
-    H5S_t *new_space = NULL;           /* New dataspace constructed */
+    H5S_t *new_space = NULL;            /* New dataspace constructed */
     herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
@@ -2287,6 +2333,8 @@ H5S_select_project_intersection(const H5S_t *src_space, const H5S_t *dst_space,
     HDassert(dst_space);
     HDassert(src_intersect_space);
     HDassert(new_space_ptr);
+    HDassert(H5S_GET_SELECT_NPOINTS(src_space) == H5S_GET_SELECT_NPOINTS(dst_space));
+    HDassert(H5S_GET_EXTENT_NDIMS(src_space) == H5S_GET_EXTENT_NDIMS(src_intersect_space));
 
     /* Create new space, using dst extent.  Start with "all" selection. */
     if(NULL == (new_space = H5S_create(H5S_SIMPLE)))
@@ -2296,15 +2344,16 @@ H5S_select_project_intersection(const H5S_t *src_space, const H5S_t *dst_space,
 
     /* If the intersecting space is "all", the intersection must be equal to the
      * source space and the projection must be equal to the destination space */
-    if(src_intersect_space->select.type->type == H5S_SEL_ALL) {
+    if(H5S_GET_SELECT_TYPE(src_intersect_space) == H5S_SEL_ALL) {
         /* Copy the destination selection. */
         if(H5S_select_copy(new_space, dst_space, FALSE) < 0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, FAIL, "can't copy destination space selection")
     } /* end if */
-    /* If any of the spaces are "none", the projection must also be "none" */
-    else if((src_intersect_space->select.type->type == H5S_SEL_NONE)
-            || (src_space->select.type->type == H5S_SEL_NONE)
-            || (dst_space->select.type->type == H5S_SEL_NONE)) {
+    /* If any of the selections contain no elements, the projection must be
+     * "none" */
+    else if((H5S_GET_SELECT_NPOINTS(src_intersect_space) == 0)
+            || (H5S_GET_SELECT_NPOINTS(src_space) == 0)
+            || (H5S_GET_SELECT_NPOINTS(dst_space) == 0)) {
         /* Change to "none" selection */
         if(H5S_select_none(new_space) < 0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't change selection")
diff --git a/src/H5private.h b/src/H5private.h
index c628fcf..5b1c4db 100644
--- a/src/H5private.h
+++ b/src/H5private.h
@@ -1951,12 +1951,11 @@ H5_DLL double H5_trace(const double *calltime, const char *func, const char *typ
 /* global library version information string */
 extern char  H5_lib_vers_info_g[];
 
+#include "H5TSprivate.h"
+
 /* Lock headers */
 #ifdef H5_HAVE_THREADSAFE
 
-/* Include required thread-safety header */
-#include "H5TSprivate.h"
-
 /* replacement structure for original global variable */
 typedef struct H5_api_struct {
     H5TS_mutex_t init_lock;  /* API entrance mutex */
diff --git a/src/H5public.h b/src/H5public.h
index fe4e33c..871c360 100644
--- a/src/H5public.h
+++ b/src/H5public.h
@@ -328,6 +328,19 @@ typedef struct H5_ih_info_t {
     hsize_t     heap_size;
 } H5_ih_info_t;
 
+/*
+ * Allocation statistics info struct
+ */
+typedef struct H5_alloc_stats_t {
+    unsigned long long total_alloc_bytes; /* Running count of total # of bytes allocated */
+    size_t curr_alloc_bytes;           /* Current # of bytes allocated */
+    size_t peak_alloc_bytes;           /* Peak # of bytes allocated */
+    size_t max_block_size;             /* Largest block allocated */
+    size_t total_alloc_blocks_count;   /* Running count of total # of blocks allocated */
+    size_t curr_alloc_blocks_count;    /* Current # of blocks allocated */
+    size_t peak_alloc_blocks_count;    /* Peak # of blocks allocated */
+} H5_alloc_stats_t;
+
 /* Functions in H5.c */
 H5_DLL herr_t H5open(void);
 H5_DLL herr_t H5close(void);
@@ -336,6 +349,9 @@ H5_DLL herr_t H5garbage_collect(void);
 H5_DLL herr_t H5set_free_list_limits (int reg_global_lim, int reg_list_lim,
                 int arr_global_lim, int arr_list_lim, int blk_global_lim,
                 int blk_list_lim);
+H5_DLL herr_t H5get_free_list_sizes(size_t *reg_size, size_t *arr_size,
+    size_t *blk_size, size_t *fac_size);
+H5_DLL herr_t H5get_alloc_stats(H5_alloc_stats_t *stats);
 H5_DLL herr_t H5get_libversion(unsigned *majnum, unsigned *minnum,
 				unsigned *relnum);
 H5_DLL herr_t H5check_version(unsigned majnum, unsigned minnum,