Merge branch 'develop' into noF77

16 files changed, 610 insertions, 538 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 91b8e0c..b163b8a 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -883,7 +883,7 @@ set (gen_SRCS ${HDF5_BINARY_DIR}/H5Tinit.c ${HDF5_BINARY_DIR}/H5lib_settings.c)
 
 add_library (${HDF5_LIB_TARGET} STATIC ${common_SRCS} ${gen_SRCS} ${H5_PUBLIC_HEADERS} ${H5_PRIVATE_HEADERS} ${H5_GENERATED_HEADERS})
 TARGET_C_PROPERTIES (${HDF5_LIB_TARGET} STATIC " " " ")
-target_link_libraries (${HDF5_LIB_TARGET} PRIVATE ${LINK_LIBS})
+target_link_libraries (${HDF5_LIB_TARGET} PRIVATE ${LINK_LIBS} ${LINK_COMP_LIBS})
 if (NOT WIN32)
   target_link_libraries (${HDF5_LIB_TARGET} PUBLIC dl)
 endif ()
@@ -927,7 +927,7 @@ if (BUILD_SHARED_LIBS)
   set (shared_gen_SRCS ${HDF5_BINARY_DIR}/shared/H5Tinit.c ${HDF5_BINARY_DIR}/shared/H5lib_settings.c)
   add_library (${HDF5_LIBSH_TARGET} SHARED ${common_SRCS} ${shared_gen_SRCS} ${H5_PUBLIC_HEADERS} ${H5_PRIVATE_HEADERS} ${H5_GENERATED_HEADERS})
   TARGET_C_PROPERTIES (${HDF5_LIBSH_TARGET} SHARED " " " ")
-  target_link_libraries (${HDF5_LIBSH_TARGET} PRIVATE ${LINK_LIBS})
+  target_link_libraries (${HDF5_LIBSH_TARGET} PRIVATE ${LINK_LIBS} ${LINK_COMP_LIBS})
   if (NOT WIN32)
     target_link_libraries (${HDF5_LIBSH_TARGET} PUBLIC dl)
   endif ()
diff --git a/src/H5Dchunk.c b/src/H5Dchunk.c
index 0d7fcc9..be3b678 100644
--- a/src/H5Dchunk.c
+++ b/src/H5Dchunk.c
@@ -5661,7 +5661,7 @@ H5D__chunk_copy_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
     /* needed for commpressed variable length data */
     hbool_t                 must_filter = FALSE;        /* Whether chunk must be filtered during copy */
     size_t                  nbytes;                     /* Size of chunk in file (in bytes) */
-    H5Z_cb_t                cb_struct;                  /* Filter failure callback struct */
+    H5Z_cb_t                filter_cb;                  /* Filter failure callback struct */
     int                     ret_value = H5_ITER_CONT;   /* Return value */
 
 
@@ -5670,6 +5670,10 @@ H5D__chunk_copy_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
     /* Get 'size_t' local value for number of bytes in chunk */
     H5_CHECKED_ASSIGN(nbytes, size_t, chunk_rec->nbytes, uint32_t);
 
+    /* Initialize the filter callback struct */
+    filter_cb.op_data = NULL;
+    filter_cb.func = NULL;      /* no callback function when failed */
+
     /* Check for filtered chunks */
     /* Check for an edge chunk that is not filtered */
     if(pline && pline->nused) {
@@ -5716,7 +5720,8 @@ H5D__chunk_copy_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
         HDassert(!H5F_addr_defined(chunk_rec->chunk_addr));
         HDmemcpy(buf, udata->chunk, nbytes);
         udata->chunk = NULL;
-    } else {
+    }
+    else {
         H5D_rdcc_ent_t *ent = NULL;    /* Cache entry */
         unsigned idx;                   /* Index of chunk in cache, if present */
         unsigned u;                     /* Counter */
@@ -5748,7 +5753,8 @@ H5D__chunk_copy_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
 
             H5_CHECKED_ASSIGN(nbytes, size_t, shared_fo->layout.u.chunk.size, uint32_t);
             HDmemcpy(buf, ent->chunk, nbytes);
-        } else {
+        }
+        else {
             /* read chunk data from the source file */
             if(H5F_block_read(udata->file_src, H5FD_MEM_DRAW, chunk_rec->chunk_addr, nbytes, H5AC_rawdata_dxpl_id, buf) < 0)
                 HGOTO_ERROR(H5E_IO, H5E_READERROR, H5_ITER_ERROR, "unable to read raw data chunk")
@@ -5759,8 +5765,7 @@ H5D__chunk_copy_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
     if(must_filter && (is_vlen || fix_ref) && !udata->chunk_in_cache) {
         unsigned filter_mask = chunk_rec->filter_mask;
 
-        cb_struct.func = NULL; /* no callback function when failed */
-        if(H5Z_pipeline(pline, H5Z_FLAG_REVERSE, &filter_mask, H5Z_NO_EDC, cb_struct, &nbytes, &buf_size, &buf) < 0)
+        if(H5Z_pipeline(pline, H5Z_FLAG_REVERSE, &filter_mask, H5Z_NO_EDC, filter_cb, &nbytes, &buf_size, &buf) < 0)
             HGOTO_ERROR(H5E_PLINE, H5E_CANTFILTER, H5_ITER_ERROR, "data pipeline read failed")
     } /* end if */
 
@@ -5822,7 +5827,7 @@ H5D__chunk_copy_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
 
     /* Need to compress variable-length or reference data elements or a chunk found in cache before writing to file */
     if(must_filter && (is_vlen || fix_ref || udata->chunk_in_cache) ) {
-        if(H5Z_pipeline(pline, 0, &(udata_dst.filter_mask), H5Z_NO_EDC, cb_struct, &nbytes, &buf_size, &buf) < 0)
+        if(H5Z_pipeline(pline, 0, &(udata_dst.filter_mask), H5Z_NO_EDC, filter_cb, &nbytes, &buf_size, &buf) < 0)
             HGOTO_ERROR(H5E_PLINE, H5E_CANTFILTER, H5_ITER_ERROR, "output pipeline failed")
 #if H5_SIZEOF_SIZE_T > 4
         /* Check for the chunk expanding too much to encode in a 32-bit value */
@@ -6707,46 +6712,49 @@ H5D__chunk_format_convert_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
     H5_CHECKED_ASSIGN(nbytes, size_t, chunk_rec->nbytes, uint32_t);
     chunk_addr = chunk_rec->chunk_addr;
 
-    if(new_idx_info->pline->nused &&
+    if (new_idx_info->pline->nused &&
           (new_idx_info->layout->flags & H5O_LAYOUT_CHUNK_DONT_FILTER_PARTIAL_BOUND_CHUNKS) &&
           (H5D__chunk_is_partial_edge_chunk(udata->dset_ndims, new_idx_info->layout->dim, chunk_rec->scaled, udata->dset_dims))) {
-	/* This is a partial non-filtered edge chunk */
-	/* Convert the chunk to a filtered edge chunk for v1 B-tree chunk index */
 
-	unsigned filter_mask = chunk_rec->filter_mask;
-	H5Z_cb_t  cb_struct;        	/* Filter failure callback struct */
-	size_t read_size = nbytes;	/* Bytes to read */
+        /* This is a partial non-filtered edge chunk */
+        /* Convert the chunk to a filtered edge chunk for v1 B-tree chunk index */
 
-	HDassert(read_size == new_idx_info->layout->size);
+        unsigned filter_mask = chunk_rec->filter_mask;
+        H5Z_cb_t  filter_cb;        /* Filter failure callback struct */
+        size_t read_size = nbytes;	/* Bytes to read */
+
+        HDassert(read_size == new_idx_info->layout->size);
 
-	cb_struct.func = NULL; /* no callback function when failed */
+        /* Initialize the filter callback struct */
+        filter_cb.op_data = NULL;
+        filter_cb.func = NULL;      /* no callback function when failed */
 
-	/* Allocate buffer for chunk data */
-	if(NULL == (buf = H5MM_malloc(read_size)))
-	    HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, H5_ITER_ERROR, "memory allocation failed for raw data chunk")
+        /* Allocate buffer for chunk data */
+        if (NULL == (buf = H5MM_malloc(read_size)))
+            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, H5_ITER_ERROR, "memory allocation failed for raw data chunk")
 
-	/* Read the non-filtered edge chunk */
-        if(H5F_block_read(new_idx_info->f, H5FD_MEM_DRAW, chunk_addr, read_size, H5AC_rawdata_dxpl_id, buf) < 0)
-	    HGOTO_ERROR(H5E_IO, H5E_READERROR, H5_ITER_ERROR, "unable to read raw data chunk")
+        /* Read the non-filtered edge chunk */
+        if (H5F_block_read(new_idx_info->f, H5FD_MEM_DRAW, chunk_addr, read_size, H5AC_rawdata_dxpl_id, buf) < 0)
+            HGOTO_ERROR(H5E_IO, H5E_READERROR, H5_ITER_ERROR, "unable to read raw data chunk")
 
-	/* Pass the chunk through the pipeline */
-	if(H5Z_pipeline(new_idx_info->pline, 0, &filter_mask, H5Z_NO_EDC, cb_struct, &nbytes, &read_size, &buf) < 0)
-	    HGOTO_ERROR(H5E_PLINE, H5E_CANTFILTER, H5_ITER_ERROR, "output pipeline failed")
+        /* Pass the chunk through the pipeline */
+        if (H5Z_pipeline(new_idx_info->pline, 0, &filter_mask, H5Z_NO_EDC, filter_cb, &nbytes, &read_size, &buf) < 0)
+            HGOTO_ERROR(H5E_PLINE, H5E_CANTFILTER, H5_ITER_ERROR, "output pipeline failed")
 
 #if H5_SIZEOF_SIZE_T > 4
         /* Check for the chunk expanding too much to encode in a 32-bit value */
-	if(nbytes > ((size_t)0xffffffff))
-	    HGOTO_ERROR(H5E_DATASET, H5E_BADRANGE, H5_ITER_ERROR, "chunk too large for 32-bit length")
+        if (nbytes > ((size_t)0xffffffff))
+            HGOTO_ERROR(H5E_DATASET, H5E_BADRANGE, H5_ITER_ERROR, "chunk too large for 32-bit length")
 #endif /* H5_SIZEOF_SIZE_T > 4 */
 
-	/* Allocate space for the filtered chunk */
-	if((chunk_addr = H5MF_alloc(new_idx_info->f, H5FD_MEM_DRAW, new_idx_info->dxpl_id, (hsize_t)nbytes)) == HADDR_UNDEF)
-	    HGOTO_ERROR(H5E_DATASET, H5E_NOSPACE, H5_ITER_ERROR, "file allocation failed for filtered chunk")
-	HDassert(H5F_addr_defined(chunk_addr));
+        /* Allocate space for the filtered chunk */
+        if ((chunk_addr = H5MF_alloc(new_idx_info->f, H5FD_MEM_DRAW, new_idx_info->dxpl_id, (hsize_t)nbytes)) == HADDR_UNDEF)
+            HGOTO_ERROR(H5E_DATASET, H5E_NOSPACE, H5_ITER_ERROR, "file allocation failed for filtered chunk")
+        HDassert(H5F_addr_defined(chunk_addr));
 
-	/* Write the filtered chunk to disk */
-	if(H5F_block_write(new_idx_info->f, H5FD_MEM_DRAW, chunk_addr, nbytes, H5AC_rawdata_dxpl_id, buf) < 0)
-	    HGOTO_ERROR(H5E_DATASET, H5E_WRITEERROR, H5_ITER_ERROR, "unable to write raw data to file")
+        /* Write the filtered chunk to disk */
+        if (H5F_block_write(new_idx_info->f, H5FD_MEM_DRAW, chunk_addr, nbytes, H5AC_rawdata_dxpl_id, buf) < 0)
+            HGOTO_ERROR(H5E_DATASET, H5E_WRITEERROR, H5_ITER_ERROR, "unable to write raw data to file")
     } /* end if */
 
     /* Set up chunk information for insertion to chunk index */
@@ -6758,11 +6766,11 @@ H5D__chunk_format_convert_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
     insert_udata.common.storage = new_idx_info->storage;
 
     /* Insert chunk into the v1 B-tree chunk index */
-    if((new_idx_info->storage->ops->insert)(new_idx_info, &insert_udata, NULL) < 0)
+    if ((new_idx_info->storage->ops->insert)(new_idx_info, &insert_udata, NULL) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTINSERT, H5_ITER_ERROR, "unable to insert chunk addr into index")
 
 done:
-    if(buf)
+    if (buf)
         H5MM_xfree(buf);
 
     FUNC_LEAVE_NOAPI(ret_value)
diff --git a/src/H5Dio.c b/src/H5Dio.c
index 104a632..280d602 100644
--- a/src/H5Dio.c
+++ b/src/H5Dio.c
@@ -962,7 +962,9 @@ const
     io_info->using_mpi_vfd = H5F_HAS_FEATURE(dset->oloc.file, H5FD_FEAT_HAS_MPI);
 #endif /* H5_HAVE_PARALLEL */
 
-done:
+#ifdef H5_DEBUG_BUILD
+	done:
+#endif /* H5_DEBUG_BUILD */
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5D__ioinfo_init() */
 
diff --git a/src/H5HFcache.c b/src/H5HFcache.c
index f957e2e..069bf17 100644
--- a/src/H5HFcache.c
+++ b/src/H5HFcache.c
@@ -1671,9 +1671,13 @@ H5HF__cache_dblock_verify_chksum(const void *_image, size_t len, void *_udata)
 	HGOTO_DONE(TRUE);
 
     if(hdr->filter_len > 0) {
-	size_t nbytes;          /* Number of bytes used in buffer, after applying reverse filters */
-	unsigned filter_mask;	/* Excluded filters for direct block */
-	H5Z_cb_t filter_cb = {NULL, NULL};  /* Filter callback structure */
+        size_t nbytes;          /* Number of bytes used in buffer, after applying reverse filters */
+        unsigned filter_mask;	/* Excluded filters for direct block */
+        H5Z_cb_t filter_cb;     /* Filter callback structure */
+
+        /* Initialize the filter callback struct */
+        filter_cb.op_data = NULL;
+        filter_cb.func = NULL;      /* no callback function when failed */
 
         /* Allocate buffer to perform I/O filtering on and copy image into
          * it.  Must do this as H5Z_pipeline() may re-size the buffer 
@@ -1682,17 +1686,17 @@ H5HF__cache_dblock_verify_chksum(const void *_image, size_t len, void *_udata)
         if(NULL == (read_buf = H5MM_malloc(len)))
             HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL, "memory allocation failed for pipeline buffer")
 
-	/* Set up parameters for filter pipeline */
-	nbytes = len;
-	filter_mask = udata->filter_mask;
+        /* Set up parameters for filter pipeline */
+        nbytes = len;
+        filter_mask = udata->filter_mask;
         HDmemcpy(read_buf, image, len);
 
-	/* Push direct block data through I/O filter pipeline */
-	if(H5Z_pipeline(&(hdr->pline), H5Z_FLAG_REVERSE, &filter_mask, H5Z_ENABLE_EDC, filter_cb, &nbytes, &len, &read_buf) < 0)
-	    HGOTO_ERROR(H5E_HEAP, H5E_CANTFILTER, FAIL, "output pipeline failed")
+        /* Push direct block data through I/O filter pipeline */
+        if(H5Z_pipeline(&(hdr->pline), H5Z_FLAG_REVERSE, &filter_mask, H5Z_ENABLE_EDC, filter_cb, &nbytes, &len, &read_buf) < 0)
+            HGOTO_ERROR(H5E_HEAP, H5E_CANTFILTER, FAIL, "output pipeline failed")
 
         /* Update info about direct block */
-	udata->decompressed = TRUE;
+        udata->decompressed = TRUE;
         len = nbytes;
     } /* end if */
     else
@@ -1818,45 +1822,49 @@ H5HF__cache_dblock_deserialize(const void *_image, size_t len, void *_udata,
             udata->dblk = NULL;
         } /* end if */
         else {
-            H5Z_cb_t filter_cb = {NULL, NULL};  /* Filter callback structure */
+            H5Z_cb_t filter_cb;     /* Filter callback structure */
             size_t nbytes;          /* Number of bytes used in buffer, after applying reverse filters */
             unsigned filter_mask;   /* Excluded filters for direct block */
 
             /* Sanity check */
-	    HDassert(udata->dblk == NULL);
+            HDassert(udata->dblk == NULL);
 
-	    /* Allocate buffer to perform I/O filtering on and copy image into
-	     * it.  Must do this as H5Z_pipeline() may resize the buffer 
-	     * provided to it.
-	     */
-	    if(NULL == (read_buf = H5MM_malloc(len)))
-		HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, NULL, "memory allocation failed for pipeline buffer")
+            /* Initialize the filter callback struct */
+            filter_cb.op_data = NULL;
+            filter_cb.func = NULL;      /* no callback function when failed */
+
+            /* Allocate buffer to perform I/O filtering on and copy image into
+             * it.  Must do this as H5Z_pipeline() may resize the buffer 
+             * provided to it.
+             */
+            if (NULL == (read_buf = H5MM_malloc(len)))
+                HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, NULL, "memory allocation failed for pipeline buffer")
 
             /* Copy compressed image into buffer */
-	    HDmemcpy(read_buf, image, len);
+            HDmemcpy(read_buf, image, len);
 
-	    /* Push direct block data through I/O filter pipeline */
-	    nbytes = len;
-	    filter_mask = udata->filter_mask;
-	    if(H5Z_pipeline(&(hdr->pline), H5Z_FLAG_REVERSE, &filter_mask, H5Z_ENABLE_EDC, filter_cb, &nbytes, &len, &read_buf) < 0)
-		HGOTO_ERROR(H5E_HEAP, H5E_CANTFILTER, NULL, "output pipeline failed")
+            /* Push direct block data through I/O filter pipeline */
+            nbytes = len;
+            filter_mask = udata->filter_mask;
+            if (H5Z_pipeline(&(hdr->pline), H5Z_FLAG_REVERSE, &filter_mask, H5Z_ENABLE_EDC, filter_cb, &nbytes, &len, &read_buf) < 0)
+                HGOTO_ERROR(H5E_HEAP, H5E_CANTFILTER, NULL, "output pipeline failed")
 
-	    /* Sanity check */
-	    HDassert(nbytes == dblock->size);
+            /* Sanity check */
+            HDassert(nbytes == dblock->size);
 
-	    /* Copy un-filtered data into block's buffer */
-	    HDmemcpy(dblock->blk, read_buf, dblock->size);
-	} /* end if */
+            /* Copy un-filtered data into block's buffer */
+            HDmemcpy(dblock->blk, read_buf, dblock->size);
+        } /* end if */
     } /* end if */
     else {
         /* Sanity checks */
-	HDassert(udata->dblk == NULL);
-	HDassert(!udata->decompressed);
+        HDassert(udata->dblk == NULL);
+        HDassert(!udata->decompressed);
 
-	/* Allocate block buffer */
-/* XXX: Change to using free-list factories */
-	if(NULL == (dblock->blk = H5FL_BLK_MALLOC(direct_block, (size_t)dblock->size)))
-	    HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
+        /* Allocate block buffer */
+        /* XXX: Change to using free-list factories */
+        if  (NULL == (dblock->blk = H5FL_BLK_MALLOC(direct_block, (size_t)dblock->size)))
+            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
 
         /* Copy image to dblock->blk */
         HDassert(dblock->size == len);
@@ -1895,9 +1903,9 @@ H5HF__cache_dblock_deserialize(const void *_image, size_t len, void *_udata,
 
     /* Decode checksum on direct block, if requested */
     if(hdr->checksum_dblocks) {
-	uint32_t stored_chksum;         /* Metadata checksum value */
+        uint32_t stored_chksum;         /* Metadata checksum value */
 
-	/* checksum verification already done in verify_chksum cb */
+        /* checksum verification already done in verify_chksum cb */
 
         /* Metadata checksum */
         UINT32DECODE(image, stored_chksum);
@@ -2188,10 +2196,14 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, hid_t dxpl_id, void *_thing,
 
     /* Check for I/O filters on this heap */
     if(hdr->filter_len > 0) {
-        H5Z_cb_t filter_cb = {NULL, NULL};  /* Filter callback structure */
+        H5Z_cb_t filter_cb;                 /* Filter callback structure */
         size_t nbytes;                      /* Number of bytes used */
         unsigned filter_mask = 0;           /* Filter mask for block */
 
+        /* Initialize the filter callback struct */
+        filter_cb.op_data = NULL;
+        filter_cb.func = NULL;      /* no callback function when failed */
+
         /* Allocate buffer to perform I/O filtering on */
         write_size = dblock->size;
         if(NULL == (write_buf = H5MM_malloc(write_size)))
diff --git a/src/H5HFhuge.c b/src/H5HFhuge.c
index b2a1e68..350100e 100644
--- a/src/H5HFhuge.c
+++ b/src/H5HFhuge.c
@@ -345,9 +345,13 @@ HDfprintf(stderr, "%s: obj_size = %Zu\n", FUNC, obj_size);
 
     /* Check for I/O pipeline filter on heap */
     if(hdr->filter_len > 0) {
-        H5Z_cb_t filter_cb = {NULL, NULL};  /* Filter callback structure */
+        H5Z_cb_t filter_cb;                 /* Filter callback structure */
         size_t nbytes;                      /* Number of bytes used */
 
+        /* Initialize the filter callback struct */
+        filter_cb.op_data = NULL;
+        filter_cb.func = NULL;          /* no callback function when failed */
+
         /* Allocate buffer to perform I/O filtering on */
         write_size = obj_size;
         if(NULL == (write_buf = H5MM_malloc(write_size)))
@@ -773,10 +777,14 @@ H5HF_huge_op_real(H5HF_hdr_t *hdr, hid_t dxpl_id, const uint8_t *id,
 
     /* Check for I/O pipeline filter on heap */
     if(hdr->filter_len > 0) {
-        H5Z_cb_t filter_cb = {NULL, NULL};  /* Filter callback structure */
+        H5Z_cb_t filter_cb;                 /* Filter callback structure */
         size_t read_size;                   /* Object's size in the file */
         size_t nbytes;                      /* Number of bytes used */
 
+        /* Initialize the filter callback struct */
+        filter_cb.op_data = NULL;
+        filter_cb.func = NULL;          /* no callback function when failed */
+
         /* De-filter the object */
         read_size = nbytes = obj_size;
         if(H5Z_pipeline(&(hdr->pline), H5Z_FLAG_REVERSE, &filter_mask, H5Z_NO_EDC, filter_cb, &nbytes, &read_size, &read_buf) < 0)
diff --git a/src/H5MF.c b/src/H5MF.c
index 49c7b77..7e06654 100644
--- a/src/H5MF.c
+++ b/src/H5MF.c
@@ -3247,7 +3247,6 @@ H5MF_settle_meta_data_fsm(H5F_t *f, hid_t dxpl_id, hbool_t *fsm_settled)
                                         /* for self referential FSMs */
     haddr_t eoa_post_fsm_fsalloc;       /* eoa post file space allocation */
                                         /* for self referential FSMs */
-    H5FS_stat_t fs_stat;                /* Information for hdr FSM */
     H5P_genplist_t *dxpl = NULL;        /* DXPL for setting ring */
     H5AC_ring_t orig_ring = H5AC_RING_INV; /* Original ring value */
     hbool_t	reset_ring = FALSE;     /* Whether we set the ring */
@@ -3310,6 +3309,9 @@ H5MF_settle_meta_data_fsm(H5F_t *f, hid_t dxpl_id, hbool_t *fsm_settled)
         reset_ring = TRUE;
 
 #ifndef NDEBUG
+{
+        H5FS_stat_t fs_stat;                /* Information for hdr FSM */
+
         /* Verify that sm_hdr_fspace is floating if it exists */
         if(sm_hdr_fspace) {
             /* Query free space manager info for this type */
@@ -3357,6 +3359,7 @@ H5MF_settle_meta_data_fsm(H5F_t *f, hid_t dxpl_id, hbool_t *fsm_settled)
                 HDassert(fs_stat.alloc_sect_size == 0);
             } /* end if */
         } /* end if */
+}
 #endif /* NDEBUG */
 
         /* Free the space in the metadata aggregator.  Do this via the
diff --git a/src/H5PLint.c b/src/H5PLint.c
index c887f86..b190746 100644
--- a/src/H5PLint.c
+++ b/src/H5PLint.c
@@ -235,11 +235,11 @@ done:
  *-------------------------------------------------------------------------
  */
 const void *
-H5PL_load(H5PL_type_t type, int id)
+H5PL_load(H5PL_type_t type, H5PL_key_t key)
 {
-    H5PL_search_params_t    search_params;
+    H5PL_search_params_t    search_params;          /* Plugin search parameters     */
     hbool_t                 found = FALSE;          /* Whether the plugin was found */
-    const void             *plugin_info = NULL;
+    const void             *plugin_info = NULL;     /* Information from the plugin  */
     const void             *ret_value = NULL;
 
     FUNC_ENTER_NOAPI(NULL)
@@ -248,18 +248,17 @@ H5PL_load(H5PL_type_t type, int id)
     switch (type) {
         case H5PL_TYPE_FILTER:
             if ((H5PL_plugin_control_mask_g & H5PL_FILTER_PLUGIN) == 0)
-                HGOTO_ERROR(H5E_PLUGIN, H5E_CANTLOAD, NULL, "required dynamically loaded plugin filter '%d' is not available", id)
+                HGOTO_ERROR(H5E_PLUGIN, H5E_CANTLOAD, NULL, "filter plugins disabled")
             break;
-
         case H5PL_TYPE_ERROR:
         case H5PL_TYPE_NONE:
         default:
-            HGOTO_ERROR(H5E_PLUGIN, H5E_CANTLOAD, NULL, "required dynamically loaded plugin '%d' is not valid", id)
+            HGOTO_ERROR(H5E_PLUGIN, H5E_CANTLOAD, NULL, "Invalid plugin type specified")
     }
 
     /* Set up the search parameters */
     search_params.type = type;
-    search_params.id = id;
+    search_params.key.id = key.id;
 
     /* Search in the table of already loaded plugin libraries */
     if(H5PL__find_plugin_in_cache(&search_params, &found, &plugin_info) < 0)
@@ -304,11 +303,11 @@ done:
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wpedantic"
 herr_t
-H5PL__open(const char *path, H5PL_type_t type, int id, hbool_t *success, const void **plugin_info)
+H5PL__open(const char *path, H5PL_type_t type, H5PL_key_t key, hbool_t *success, const void **plugin_info)
 {
     H5PL_HANDLE             handle = NULL;
     H5PL_get_plugin_info_t  get_plugin_info = NULL;
-    htri_t                  ret_value = SUCCEED;
+    herr_t                  ret_value = SUCCEED;
 
     FUNC_ENTER_PACKAGE
 
@@ -326,35 +325,46 @@ H5PL__open(const char *path, H5PL_type_t type, int id, hbool_t *success, const v
      */
     if (NULL == (handle = H5PL_OPEN_DLIB(path))) {
         H5PL_CLR_ERROR; /* clear error */
-        HGOTO_DONE(SUCCEED);
+        HGOTO_DONE(SUCCEED)
     }
 
     /* Return a handle for the function H5PLget_plugin_info in the dynamic library.
      * The plugin library is suppose to define this function.
      */
-    if (NULL != (get_plugin_info = (H5PL_get_plugin_info_t)H5PL_GET_LIB_FUNC(handle, "H5PLget_plugin_info"))) {
-
-        const H5Z_class2_t *info;
+    if (NULL == (get_plugin_info = (H5PL_get_plugin_info_t)H5PL_GET_LIB_FUNC(handle, "H5PLget_plugin_info")))
+        HGOTO_DONE(SUCCEED)
 
-        /* Get the plugin info */
-        if (NULL == (info = (const H5Z_class2_t *)(*get_plugin_info)()))
-            HGOTO_ERROR(H5E_PLUGIN, H5E_CANTGET, FAIL, "can't get plugin info")
+    /* Get the plugin information */
+    switch (type) {
+        case H5PL_TYPE_FILTER:
+        {
+            const H5Z_class2_t *filter_info;
 
-        /* Check if the filter IDs match */
-        if (info->id == id) {
+            /* Get the plugin info */
+            if (NULL == (filter_info = (const H5Z_class2_t *)(*get_plugin_info)()))
+                HGOTO_ERROR(H5E_PLUGIN, H5E_CANTGET, FAIL, "can't get filter info from plugin")
 
-            /* Store the plugin in the cache */
-            if (H5PL__add_plugin(type, id, handle))
-                HGOTO_ERROR(H5E_PLUGIN, H5E_CANTINSERT, FAIL, "unable to add new plugin to plugin cache")
+            /* If the filter IDs match, we're done. Set the output parameters. */
+            if (filter_info->id == key.id) {
+                *plugin_info = (const void *)filter_info;
+                *success = TRUE;
+            }
 
-            /* Set output parameters */
-            *success = TRUE;
-            *plugin_info = (const void *)info;
+            break;
         }
-    }
+        case H5PL_TYPE_ERROR:
+        case H5PL_TYPE_NONE:
+        default:
+            HGOTO_ERROR(H5E_PLUGIN, H5E_CANTGET, FAIL, "Invalid plugin type specified")
+    } /* end switch */
+
+    /* If we found the correct plugin, store it in the cache */
+    if (*success)
+        if (H5PL__add_plugin(type, key, handle))
+            HGOTO_ERROR(H5E_PLUGIN, H5E_CANTINSERT, FAIL, "unable to add new plugin to plugin cache")
 
 done:
-    if (!success && handle)
+    if (!(*success) && handle)
         if (H5PL__close(handle) < 0)
             HDONE_ERROR(H5E_PLUGIN, H5E_CLOSEERROR, FAIL, "can't close dynamic library")
 
diff --git a/src/H5PLpath.c b/src/H5PLpath.c
index 435802a..972f1d0 100644
--- a/src/H5PLpath.c
+++ b/src/H5PLpath.c
@@ -689,7 +689,7 @@ H5PL__find_plugin_in_path(const H5PL_search_params_t *search_params, hbool_t *fo
                 continue;
 
             /* attempt to open the dynamic library as a filter library */
-            if (H5PL__open(path, search_params->type, search_params->id, found, plugin_info) < 0)
+            if (H5PL__open(path, search_params->type, search_params->key, found, plugin_info) < 0)
                 HGOTO_ERROR(H5E_PLUGIN, H5E_CANTGET, FAIL, "search in directory failed")
             if (*found)
                 HGOTO_DONE(SUCCEED)
@@ -755,7 +755,7 @@ H5PL__find_plugin_in_path(const H5PL_search_params_t *search_params, hbool_t *fo
                 continue;
 
             /* attempt to open the dynamic library as a filter library */
-            if (H5PL__open(path, search_params->type, search_params->id, found, plugin_info) < 0)
+            if (H5PL__open(path, search_params->type, search_params->key, found, plugin_info) < 0)
                 HGOTO_ERROR(H5E_PLUGIN, H5E_CANTGET, FAIL, "search in directory failed")
             if (*found)
                 HGOTO_DONE(SUCCEED)
diff --git a/src/H5PLpkg.h b/src/H5PLpkg.h
index 0d1c271..dfaa4af 100644
--- a/src/H5PLpkg.h
+++ b/src/H5PLpkg.h
@@ -115,8 +115,8 @@
 
 /* Data used to search for plugins */
 typedef struct H5PL_search_params_t {
-    H5PL_type_t     type;
-    int             id;
+    H5PL_type_t         type;
+    H5PL_key_t          key;
 } H5PL_search_params_t;
 
 
@@ -134,13 +134,13 @@ H5_DLL herr_t H5PL__get_plugin_control_mask(unsigned int *mask /*out*/);
 H5_DLL herr_t H5PL__set_plugin_control_mask(unsigned int mask);
 
 /* Plugin search and manipulation */
-H5_DLL herr_t H5PL__open(const char *libname, H5PL_type_t type, int id, hbool_t *success /*out*/, const void **plugin_info /*out*/);
+H5_DLL herr_t H5PL__open(const char *libname, H5PL_type_t type, H5PL_key_t key, hbool_t *success /*out*/, const void **plugin_info /*out*/);
 H5_DLL herr_t H5PL__close(H5PL_HANDLE handle);
 
 /* Plugin cache calls */
 H5_DLL herr_t H5PL__create_plugin_cache(void);
 H5_DLL herr_t H5PL__close_plugin_cache(hbool_t *already_closed /*out*/);
-H5_DLL herr_t H5PL__add_plugin(H5PL_type_t type, int id, H5PL_HANDLE handle);
+H5_DLL herr_t H5PL__add_plugin(H5PL_type_t type, H5PL_key_t key, H5PL_HANDLE handle);
 H5_DLL herr_t H5PL__find_plugin_in_cache(const H5PL_search_params_t *search_params, hbool_t *found /*out*/, const void **plugin_info /*out*/);
 
 /* Plugin search path calls */
diff --git a/src/H5PLplugin_cache.c b/src/H5PLplugin_cache.c
index d826ba0..e905ac2 100644
--- a/src/H5PLplugin_cache.c
+++ b/src/H5PLplugin_cache.c
@@ -56,9 +56,9 @@
 
 /* Type for the list of info for opened plugin libraries */
 typedef struct H5PL_plugin_t {
-    H5PL_type_t     type;           /* Plugin type          */
-    int             id;             /* ID for the plugin    */
-    H5PL_HANDLE     handle;         /* Plugin handle        */
+    H5PL_type_t     type;           /* Plugin type                          */
+    H5PL_key_t      key;            /* Unique key to identify the plugin    */
+    H5PL_HANDLE     handle;         /* Plugin handle                        */
 } H5PL_plugin_t;
 
 
@@ -209,14 +209,14 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5PL__add_plugin
  *
- * Purpose:     Add a plugin to the plugin cached.
+ * Purpose:     Add a plugin to the plugin cache.
  *
  * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
 herr_t
-H5PL__add_plugin(H5PL_type_t type, int id, H5PL_HANDLE handle)
+H5PL__add_plugin(H5PL_type_t type, H5PL_key_t key, H5PL_HANDLE handle)
 {
     herr_t      ret_value = SUCCEED;
 
@@ -229,7 +229,7 @@ H5PL__add_plugin(H5PL_type_t type, int id, H5PL_HANDLE handle)
 
     /* Store the plugin info and bump the # of plugins */
     H5PL_cache_g[H5PL_num_plugins_g].type       = type;
-    H5PL_cache_g[H5PL_num_plugins_g].id         = id;
+    H5PL_cache_g[H5PL_num_plugins_g].key        = key;
     H5PL_cache_g[H5PL_num_plugins_g].handle     = handle;
 
     H5PL_num_plugins_g++;
@@ -276,18 +276,18 @@ H5PL__find_plugin_in_cache(const H5PL_search_params_t *search_params, hbool_t *f
     for (u = 0; u < H5PL_num_plugins_g; u++) {
 
         /* If the plugin type (filter, etc.) and ID match, query the plugin for its info */
-        if ((search_params->type == (H5PL_cache_g[u]).type) && (search_params->id == (H5PL_cache_g[u]).id)) {
+        if ((search_params->type == (H5PL_cache_g[u]).type) && (search_params->key.id == (H5PL_cache_g[u]).key.id)) {
 
             H5PL_get_plugin_info_t      get_plugin_info_function;
             const H5Z_class2_t          *filter_info;
 
             /* Get the "get plugin info" function from the plugin. */
             if (NULL == (get_plugin_info_function = (H5PL_get_plugin_info_t)H5PL_GET_LIB_FUNC((H5PL_cache_g[u]).handle, "H5PLget_plugin_info")))
-                HGOTO_ERROR(H5E_DATATYPE, H5E_CANTGET, FAIL, "can't get function for H5PLget_plugin_info")
+                HGOTO_ERROR(H5E_PLUGIN, H5E_CANTGET, FAIL, "can't get function for H5PLget_plugin_info")
 
             /* Call the "get plugin info" function */
             if (NULL == (filter_info = (const H5Z_class2_t *)(*get_plugin_info_function)()))
-                HGOTO_ERROR(H5E_DATATYPE, H5E_CANTGET, FAIL, "can't get plugin info")
+                HGOTO_ERROR(H5E_PLUGIN, H5E_CANTGET, FAIL, "can't get plugin info")
 
             /* Set output parameters */
             *found = TRUE;
diff --git a/src/H5PLprivate.h b/src/H5PLprivate.h
index bc12e64..cc2e258 100644
--- a/src/H5PLprivate.h
+++ b/src/H5PLprivate.h
@@ -33,6 +33,11 @@
 /* Library Private Typedefs */
 /****************************/
 
+/* The key that will be used to find the plugin */
+typedef union H5PL_key_t {
+    int         id;         /* filters      */
+} H5PL_key_t;
+
 
 /*****************************/
 /* Library-private Variables */
@@ -44,7 +49,7 @@
 /***************************************/
 
 /* Internal API routines */
-H5_DLL const void *H5PL_load(H5PL_type_t plugin_type, int type_id);
+H5_DLL const void *H5PL_load(H5PL_type_t plugin_type, H5PL_key_t key);
 
 #endif /* _H5PLprivate_H */
 
diff --git a/src/H5PLpublic.h b/src/H5PLpublic.h
index 3b36ccd..fe5bdfb 100644
--- a/src/H5PLpublic.h
+++ b/src/H5PLpublic.h
@@ -30,9 +30,9 @@
 
 /* Plugin type used by the plugin library */
 typedef enum H5PL_type_t {
-    H5PL_TYPE_ERROR         = -1,   /* Error                    */
-    H5PL_TYPE_FILTER        = 0,    /* Filter                   */
-    H5PL_TYPE_NONE          = 1     /* This must be last!       */
+    H5PL_TYPE_ERROR         = -1,   /* Error                */
+    H5PL_TYPE_FILTER        =  0,   /* Filter               */
+    H5PL_TYPE_NONE          =  1    /* This must be last!   */
 } H5PL_type_t;
 
 /* Common dynamic plugin type flags used by the set/get_loading_state functions */
diff --git a/src/H5Tdbg.c b/src/H5Tdbg.c
index f434543..eb648f3 100644
--- a/src/H5Tdbg.c
+++ b/src/H5Tdbg.c
@@ -32,9 +32,9 @@
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"		/* Generic Functions			*/
-#include "H5Eprivate.h"		/* Error handling		  	*/
-#include "H5Tpkg.h"		/* Datatypes         			*/
+#include "H5private.h"          /* Generic Functions                        */
+#include "H5Eprivate.h"         /* Error handling                           */
+#include "H5Tpkg.h"             /* Datatypes                                */
 
 
 /****************/
@@ -74,28 +74,21 @@
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5T__print_stats
+ * Function:    H5T__print_stats
  *
- * Purpose:	Print statistics about a conversion path.  Statistics are
- *		printed only if all the following conditions are true:
+ * Purpose:     Print statistics about a conversion path.  Statistics are
+ *              printed only if all the following conditions are true:
  *
- * 		1. The library was compiled with H5T_DEBUG defined.
- *		2. Data type debugging is turned on at run time.
- *		3. The path was called at least one time.
+ *              1. The library was compiled with H5T_DEBUG defined.
+ *              2. Data type debugging is turned on at run time.
+ *              3. The path was called at least one time.
  *
- *		The optional NPRINT argument keeps track of the number of
- *		conversions paths for which statistics have been shown. If
- *		its value is zero then table headers are printed before the
- *		first line of output.
+ *              The optional NPRINT argument keeps track of the number of
+ *              conversions paths for which statistics have been shown. If
+ *              its value is zero then table headers are printed before the
+ *              first line of output.
  *
- * Return:	Success:	non-negative
- *
- *		Failure:	negative
- *
- * Programmer:	Robb Matzke
- *              Monday, December 14, 1998
- *
- * Modifications:
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
@@ -110,34 +103,34 @@ H5T__print_stats(H5T_path_t H5_ATTR_UNUSED * path, int H5_ATTR_UNUSED * nprint/*
     FUNC_ENTER_PACKAGE_NOERR
 
 #ifdef H5T_DEBUG
-    if(H5DEBUG(T) && path->stats.ncalls > 0) {
-	if(nprint && 0 == (*nprint)++) {
-	    HDfprintf(H5DEBUG(T), "H5T: type conversion statistics:\n");
-	    HDfprintf(H5DEBUG(T), "   %-16s %10s %10s %8s %8s %8s %10s\n",
-		       "Conversion", "Elmts", "Calls", "User",
-		       "System", "Elapsed", "Bandwidth");
-	    HDfprintf(H5DEBUG(T), "   %-16s %10s %10s %8s %8s %8s %10s\n",
-		       "----------", "-----", "-----", "----",
-		       "------", "-------", "---------");
-	}
-        if(path->src && path->dst)
+    if (H5DEBUG(T) && path->stats.ncalls > 0) {
+        if (nprint && 0 == (*nprint)++) {
+            HDfprintf(H5DEBUG(T), "H5T: type conversion statistics:\n");
+            HDfprintf(H5DEBUG(T), "   %-16s %10s %10s %8s %8s %8s %10s\n",
+                "Conversion", "Elmts", "Calls", "User",
+                "System", "Elapsed", "Bandwidth");
+            HDfprintf(H5DEBUG(T), "   %-16s %10s %10s %8s %8s %8s %10s\n",
+                "----------", "-----", "-----", "----",
+                "------", "-------", "---------");
+        }
+        if (path->src && path->dst)
             nbytes = MAX(H5T_get_size(path->src), H5T_get_size(path->dst));
-        else if(path->src)
+        else if (path->src)
             nbytes = H5T_get_size(path->src);
-        else if(path->dst)
+        else if (path->dst)
             nbytes = H5T_get_size(path->dst);
         else
             nbytes = 0;
-	nbytes *= path->stats.nelmts;
-	H5_bandwidth(bandwidth, (double)nbytes, path->stats.timer.etime);
-	HDfprintf(H5DEBUG(T), "   %-16s %10Hd %10d %8.2f %8.2f %8.2f %10s\n",
-		   path->name,
-		   path->stats.nelmts,
-		   path->stats.ncalls,
-		   path->stats.timer.utime,
-		   path->stats.timer.stime,
-		   path->stats.timer.etime,
-		   bandwidth);
+        nbytes *= path->stats.nelmts;
+        H5_bandwidth(bandwidth, (double)nbytes, path->stats.timer.etime);
+        HDfprintf(H5DEBUG(T), "   %-16s %10Hd %10d %8.2f %8.2f %8.2f %10s\n",
+            path->name,
+            path->stats.nelmts,
+            path->stats.ncalls,
+            path->stats.timer.utime,
+            path->stats.timer.stime,
+            path->stats.timer.etime,
+            bandwidth);
     }
 #endif
     FUNC_LEAVE_NOAPI(SUCCEED)
@@ -145,24 +138,20 @@ H5T__print_stats(H5T_path_t H5_ATTR_UNUSED * path, int H5_ATTR_UNUSED * nprint/*
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5T_debug
- *
- * Purpose:	Prints information about a data type.
+ * Function:    H5T_debug
  *
- * Return:	Non-negative on success/Negative on failure
+ * Purpose:     Prints information about a data type.
  *
- * Programmer:	Robb Matzke
- *		Wednesday, January  7, 1998
- *
- * Modifications:
+ * Return:      SUCCEED/FAIL
  *
  *-------------------------------------------------------------------------
  */
 herr_t
 H5T_debug(const H5T_t *dt, FILE *stream)
 {
-    const char	*s1 = "", *s2 = "";
-    unsigned	i;
+    const char  *s1 = "";
+    const char  *s2 = "";
+    unsigned    i;
     herr_t      ret_value = SUCCEED;       /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
@@ -171,7 +160,7 @@ H5T_debug(const H5T_t *dt, FILE *stream)
     HDassert(dt);
     HDassert(stream);
 
-    switch(dt->shared->type) {
+    switch (dt->shared->type) {
         case H5T_NO_CLASS:
             HGOTO_ERROR(H5E_DATATYPE, H5E_BADTYPE, FAIL, "no class");
             break;
@@ -221,9 +210,9 @@ H5T_debug(const H5T_t *dt, FILE *stream)
         default:
             s1 = "";
             break;
-    } /* end switch */
+    }  /* end switch */
 
-    switch(dt->shared->state) {
+    switch (dt->shared->state) {
         case H5T_STATE_TRANSIENT:
             s2 = "[transient]";
             break;
@@ -245,14 +234,14 @@ H5T_debug(const H5T_t *dt, FILE *stream)
             break;
         default:
             HDassert(0 && "This Should never be executed!");
-    } /* end switch */
+    }  /* end switch */
 
-    fprintf(stream, "%s%s {nbytes=%lu", s1, s2, (unsigned long)(dt->shared->size));
+    HDfprintf(stream, "%s%s {nbytes=%lu", s1, s2, (unsigned long)(dt->shared->size));
 
-    if(H5T_IS_ATOMIC(dt->shared)) {
-        uint64_t	tmp;
+    if (H5T_IS_ATOMIC(dt->shared)) {
+        uint64_t    tmp;
 
-	switch(dt->shared->u.atomic.order) {
+        switch (dt->shared->u.atomic.order) {
             case H5T_ORDER_ERROR:
                 HGOTO_ERROR(H5E_DATATYPE, H5E_BADTYPE, FAIL, "order error");
                 break;
@@ -277,17 +266,16 @@ H5T_debug(const H5T_t *dt, FILE *stream)
             default:
                 s1 = "order?";
                 break;
-	} /* end switch */
+        } /* end switch */
+
+        HDfprintf(stream, ", %s", s1);
 
-	fprintf(stream, ", %s", s1);
+        if (dt->shared->u.atomic.offset)
+            HDfprintf(stream, ", offset=%lu", (unsigned long) (dt->shared->u.atomic.offset));
+        if (dt->shared->u.atomic.prec != 8 * dt->shared->size)
+            HDfprintf(stream, ", prec=%lu", (unsigned long) (dt->shared->u.atomic.prec));
 
-	if(dt->shared->u.atomic.offset)
-	    fprintf(stream, ", offset=%lu",
-		    (unsigned long) (dt->shared->u.atomic.offset));
-	if(dt->shared->u.atomic.prec != 8 * dt->shared->size)
-	    fprintf(stream, ", prec=%lu",
-		    (unsigned long) (dt->shared->u.atomic.prec));
-	switch(dt->shared->type) {
+        switch (dt->shared->type) {
             case H5T_NO_CLASS:
                 HGOTO_ERROR(H5E_DATATYPE, H5E_BADTYPE, FAIL, "no class");
                 break;
@@ -313,7 +301,7 @@ H5T_debug(const H5T_t *dt, FILE *stream)
 
                 } /* end switch */
                 if(s1)
-                    fprintf(stream, ", %s", s1);
+                    HDfprintf(stream, ", %s", s1);
                 break;
 
             case H5T_FLOAT:
@@ -339,23 +327,24 @@ H5T_debug(const H5T_t *dt, FILE *stream)
                         break;
                 } /* end switch */
 
-                fprintf(stream, ", sign=%lu+1",
+                HDfprintf(stream, ", sign=%lu+1",
                         (unsigned long)(dt->shared->u.atomic.u.f.sign));
-                fprintf(stream, ", mant=%lu+%lu (%s)",
+                HDfprintf(stream, ", mant=%lu+%lu (%s)",
                         (unsigned long)(dt->shared->u.atomic.u.f.mpos),
                         (unsigned long)(dt->shared->u.atomic.u.f.msize), s1);
-                fprintf(stream, ", exp=%lu+%lu",
+                HDfprintf(stream, ", exp=%lu+%lu",
                         (unsigned long)(dt->shared->u.atomic.u.f.epos),
                         (unsigned long)(dt->shared->u.atomic.u.f.esize));
                 tmp = dt->shared->u.atomic.u.f.ebias >> 32;
-                if(tmp) {
+                if (tmp) {
                     size_t hi = (size_t)tmp;
                     size_t lo = (size_t)(dt->shared->u.atomic.u.f.ebias & 0xffffffff);
-                    fprintf(stream, " bias=0x%08lx%08lx",
+                    HDfprintf(stream, " bias=0x%08lx%08lx",
                             (unsigned long)hi, (unsigned long)lo);
-                } else {
+                }
+                else {
                     size_t lo = (size_t)(dt->shared->u.atomic.u.f.ebias & 0xffffffff);
-                    fprintf(stream, " bias=0x%08lx", (unsigned long)lo);
+                    HDfprintf(stream, " bias=0x%08lx", (unsigned long)lo);
                 }
                 break;
 
@@ -372,69 +361,73 @@ H5T_debug(const H5T_t *dt, FILE *stream)
             default:
                 /* No additional info */
                 break;
-	} /* end switch */
-    } else if(H5T_COMPOUND == dt->shared->type) {
-	/* Compound data type */
-	for(i = 0; i < dt->shared->u.compnd.nmembs; i++) {
-	    fprintf(stream, "\n\"%s\" @%lu",
-		    dt->shared->u.compnd.memb[i].name,
-		    (unsigned long)(dt->shared->u.compnd.memb[i].offset));
-	    fprintf(stream, " ");
-	    H5T_debug(dt->shared->u.compnd.memb[i].type, stream);
-	} /* end for */
-	fprintf(stream, "\n");
-    } else if(H5T_VLEN == dt->shared->type) {
-        switch(dt->shared->u.vlen.loc) {
+        } /* end switch */
+    }
+    else if (H5T_COMPOUND == dt->shared->type) {
+        /* Compound data type */
+        for (i = 0; i < dt->shared->u.compnd.nmembs; i++) {
+            HDfprintf(stream, "\n\"%s\" @%lu",
+                    dt->shared->u.compnd.memb[i].name,
+                    (unsigned long)(dt->shared->u.compnd.memb[i].offset));
+            HDfprintf(stream, " ");
+            H5T_debug(dt->shared->u.compnd.memb[i].type, stream);
+        } /* end for */
+        HDfprintf(stream, "\n");
+    }
+    else if (H5T_VLEN == dt->shared->type) {
+        switch (dt->shared->u.vlen.loc) {
             case H5T_LOC_BADLOC:
                 HGOTO_ERROR(H5E_DATATYPE, H5E_BADTYPE, FAIL, "invalid datatype location");
                 break;
 
             case H5T_LOC_MEMORY:
-                fprintf(stream, ", loc=memory");
+                HDfprintf(stream, ", loc=memory");
                 break;
 
             case H5T_LOC_DISK:
-                fprintf(stream, ", loc=disk");
+                HDfprintf(stream, ", loc=disk");
                 break;
 
             case H5T_LOC_MAXLOC:
             default:
-                fprintf(stream, ", loc=UNKNOWN");
+                HDfprintf(stream, ", loc=UNKNOWN");
                 break;
         } /* end switch */
 
-        if(H5T_IS_VL_STRING(dt->shared))
+        if (H5T_IS_VL_STRING(dt->shared))
             /* Variable length string datatype */
-            fprintf(stream, ", variable-length");
+            HDfprintf(stream, ", variable-length");
         else {
             /* Variable length sequence datatype */
-            fprintf(stream, " VLEN ");
+            HDfprintf(stream, " VLEN ");
             H5T_debug(dt->shared->parent, stream);
-            fprintf(stream, "\n");
+            HDfprintf(stream, "\n");
         } /* end else */
-    } else if(H5T_ENUM == dt->shared->type) {
+    }
+    else if (H5T_ENUM == dt->shared->type) {
         size_t	base_size;
 
-	/* Enumeration data type */
-	fprintf(stream, " ");
-	H5T_debug(dt->shared->parent, stream);
-	base_size = dt->shared->parent->shared->size;
-	for(i = 0; i < dt->shared->u.enumer.nmembs; i++) {
+        /* Enumeration data type */
+        HDfprintf(stream, " ");
+        H5T_debug(dt->shared->parent, stream);
+        base_size = dt->shared->parent->shared->size;
+        for (i = 0; i < dt->shared->u.enumer.nmembs; i++) {
             size_t	k;
 
-	    fprintf(stream, "\n\"%s\" = 0x", dt->shared->u.enumer.name[i]);
-	    for(k = 0; k < base_size; k++)
-		fprintf(stream, "%02lx",
-			(unsigned long)(dt->shared->u.enumer.value + (i * base_size) + k));
-	} /* end for */
-	fprintf(stream, "\n");
-    } else if(H5T_OPAQUE == dt->shared->type) {
-	fprintf(stream, ", tag=\"%s\"", dt->shared->u.opaque.tag);
-    } else {
-	/* Unknown */
-	fprintf(stream, "unknown class %d\n", (int)(dt->shared->type));
+            HDfprintf(stream, "\n\"%s\" = 0x", dt->shared->u.enumer.name[i]);
+            for (k = 0; k < base_size; k++)
+                HDfprintf(stream, "%02lx", (unsigned long)(dt->shared->u.enumer.value + (i * base_size) + k));
+        } /* end for */
+        HDfprintf(stream, "\n");
+    }
+    else if (H5T_OPAQUE == dt->shared->type) {
+        HDfprintf(stream, ", tag=\"%s\"", dt->shared->u.opaque.tag);
+    }
+    else {
+        /* Unknown */
+        HDfprintf(stream, "unknown class %d\n", (int)(dt->shared->type));
     }
-    fprintf(stream, "}");
+    HDfprintf(stream, "}");
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
diff --git a/src/H5Z.c b/src/H5Z.c
index 1d023b5..6f173b2 100644
--- a/src/H5Z.c
+++ b/src/H5Z.c
@@ -34,15 +34,15 @@
 #ifdef H5Z_DEBUG
 typedef struct H5Z_stats_t {
     struct {
-        hsize_t        total;    /*total number of bytes processed        */
-        hsize_t        errors;   /*bytes of total attributable to errors  */
-        H5_timer_t timer;        /*execution time including errors        */
-    } stats[2];                  /*0=output, 1=input                      */
+        hsize_t    total;    /* total number of bytes processed */
+        hsize_t    errors;   /* bytes of total attributable to errors */
+        H5_timer_t timer;    /* execution time including errors */
+    } stats[2];              /* 0=output, 1=input */
 } H5Z_stats_t;
 #endif /* H5Z_DEBUG */
 
 typedef struct H5Z_object_t {
-    H5Z_filter_t filter_id;     /* ID of the filter we're looking for         */
+    H5Z_filter_t filter_id;     /* ID of the filter we're looking for */
     htri_t       found;         /* Whether we find an object using the filter */
 } H5Z_object_t;
 
@@ -86,24 +86,24 @@ H5Z__init_package(void)
     FUNC_ENTER_PACKAGE
 
     /* Internal filters */
-    if(H5Z_register(H5Z_SHUFFLE) < 0)
+    if (H5Z_register(H5Z_SHUFFLE) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register shuffle filter")
-    if(H5Z_register(H5Z_FLETCHER32) < 0)
+    if (H5Z_register(H5Z_FLETCHER32) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register fletcher32 filter")
-    if(H5Z_register(H5Z_NBIT) < 0)
+    if (H5Z_register(H5Z_NBIT) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register nbit filter")
-    if(H5Z_register(H5Z_SCALEOFFSET) < 0)
+    if (H5Z_register(H5Z_SCALEOFFSET) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register scaleoffset filter")
 
     /* External filters */
 #ifdef H5_HAVE_FILTER_DEFLATE
-    if(H5Z_register(H5Z_DEFLATE) < 0)
-        HGOTO_ERROR (H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register deflate filter")
+    if (H5Z_register(H5Z_DEFLATE) < 0)
+        HGOTO_ERROR(H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register deflate filter")
 #endif /* H5_HAVE_FILTER_DEFLATE */
 #ifdef H5_HAVE_FILTER_SZIP
     H5Z_SZIP->encoder_present = SZ_encoder_enabled();
-    if(H5Z_register(H5Z_SZIP) < 0)
-        HGOTO_ERROR (H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register szip filter")
+    if (H5Z_register(H5Z_SZIP) < 0)
+        HGOTO_ERROR(H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register szip filter")
 #endif /* H5_HAVE_FILTER_SZIP */
 
 done:
@@ -180,7 +180,7 @@ H5Z_term_package(void)
         } /* end if */
 #endif /* H5Z_DEBUG */
         /* Free the table of filters */
-        if(H5Z_table_g) {
+        if (H5Z_table_g) {
             H5Z_table_g = (H5Z_class2_t *)H5MM_xfree(H5Z_table_g);
 #ifdef H5Z_DEBUG
             H5Z_stat_table_g = (H5Z_stats_t *)H5MM_xfree(H5Z_stat_table_g);
@@ -191,7 +191,7 @@ H5Z_term_package(void)
         } /* end if */
 
         /* Mark interface as closed */
-        if(0 == n)
+        if (0 == n)
             H5_PKG_INIT_VAR = FALSE;
     } /* end if */
 
@@ -211,15 +211,15 @@ herr_t
 H5Zregister(const void *cls)
 {
     const H5Z_class2_t  *cls_real = (const H5Z_class2_t *) cls; /* "Real" class pointer */
-    H5Z_class2_t        cls_new;                /* Translated class struct */
-    herr_t              ret_value=SUCCEED;      /* Return value */
+    H5Z_class2_t        cls_new;                  /* Translated class struct */
+    herr_t              ret_value = SUCCEED;      /* Return value */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE1("e", "*x", cls);
 
     /* Check args */
     if (cls_real==NULL)
-        HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "invalid filter class")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid filter class")
 
     /* Check H5Z_class_t version number; this is where a function to convert
      * from an outdated version should be called.
@@ -231,7 +231,7 @@ H5Zregister(const void *cls)
      * at least 256, there should be no overlap and the version of the struct
      * can be determined by the value of the first field.
      */
-    if(cls_real->version != H5Z_CLASS_T_VERS) {
+    if (cls_real->version != H5Z_CLASS_T_VERS) {
 #ifndef H5_NO_DEPRECATED_SYMBOLS
         /* Assume it is an old "H5Z_class1_t" instead */
         const H5Z_class1_t *cls_old = (const H5Z_class1_t *) cls;
@@ -255,16 +255,16 @@ H5Zregister(const void *cls)
 #endif /* H5_NO_DEPRECATED_SYMBOLS */
     } /* end if */
 
-    if (cls_real->id<0 || cls_real->id>H5Z_FILTER_MAX)
-        HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "invalid filter identification number")
-    if (cls_real->id<H5Z_FILTER_RESERVED)
-        HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "unable to modify predefined filters")
-    if (cls_real->filter==NULL)
+    if (cls_real->id < 0 || cls_real->id > H5Z_FILTER_MAX)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid filter identification number")
+    if (cls_real->id < H5Z_FILTER_RESERVED)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "unable to modify predefined filters")
+    if (cls_real->filter == NULL)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no filter function specified")
 
     /* Do it */
-    if (H5Z_register (cls_real)<0)
-        HGOTO_ERROR (H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register filter")
+    if (H5Z_register(cls_real) < 0)
+        HGOTO_ERROR(H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register filter")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -275,16 +275,17 @@ done:
  * Function: H5Z_register
  *
  * Purpose:  Same as the public version except this one allows filters
- *           to be set for predefined method numbers <H5Z_FILTER_RESERVED
+ *           to be set for predefined method numbers < H5Z_FILTER_RESERVED
  *
- * Return:   Non-negative on success/Negative on failure
+ * Return:   Non-negative on success
+ *           Negative on failure
  *-------------------------------------------------------------------------
  */
 herr_t
 H5Z_register (const H5Z_class2_t *cls)
 {
-    size_t      i;
-    herr_t      ret_value = SUCCEED;       /* Return value */
+    size_t    i;
+    herr_t    ret_value = SUCCEED;       /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
@@ -292,23 +293,23 @@ H5Z_register (const H5Z_class2_t *cls)
     HDassert(cls->id >= 0 && cls->id <= H5Z_FILTER_MAX);
 
     /* Is the filter already registered? */
-    for(i = 0; i < H5Z_table_used_g; i++)
-        if(H5Z_table_g[i].id == cls->id)
+    for (i = 0; i < H5Z_table_used_g; i++)
+        if (H5Z_table_g[i].id == cls->id)
             break;
 
     /* Filter not already registered */
-    if(i >= H5Z_table_used_g) {
-        if(H5Z_table_used_g >= H5Z_table_alloc_g) {
-            size_t n = MAX(H5Z_MAX_NFILTERS, 2*H5Z_table_alloc_g);
+    if (i >= H5Z_table_used_g) {
+        if (H5Z_table_used_g >= H5Z_table_alloc_g) {
+            size_t n = MAX(H5Z_MAX_NFILTERS, 2 * H5Z_table_alloc_g);
             H5Z_class2_t *table = (H5Z_class2_t *)H5MM_realloc(H5Z_table_g, n * sizeof(H5Z_class2_t));
 #ifdef H5Z_DEBUG
             H5Z_stats_t *stat_table = (H5Z_stats_t *)H5MM_realloc(H5Z_stat_table_g, n * sizeof(H5Z_stats_t));
 #endif /* H5Z_DEBUG */
-            if(!table)
+            if (!table)
                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to extend filter table")
             H5Z_table_g = table;
 #ifdef H5Z_DEBUG
-            if(!stat_table)
+            if (!stat_table)
                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to extend filter statistics table")
             H5Z_stat_table_g = stat_table;
 #endif /* H5Z_DEBUG */
@@ -338,25 +339,26 @@ done:
  *
  * Purpose:  This function unregisters a filter.
  *
- * Return:   Non-negative on success/Negative on failure
+ * Return:   Non-negative on success
+ *           Negative on failure
  *-------------------------------------------------------------------------
  */
 herr_t
 H5Zunregister(H5Z_filter_t id)
 {
-    herr_t      ret_value=SUCCEED;       /* Return value */
+    herr_t      ret_value = SUCCEED;       /* Return value */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE1("e", "Zf", id);
 
     /* Check args */
-    if(id < 0 || id > H5Z_FILTER_MAX)
+    if (id < 0 || id > H5Z_FILTER_MAX)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid filter identification number")
-    if(id < H5Z_FILTER_RESERVED)
+    if (id < H5Z_FILTER_RESERVED)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "unable to modify predefined filters")
 
     /* Do it */
-    if(H5Z_unregister(id) < 0)
+    if (H5Z_unregister(id) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_CANTINIT, FAIL, "unable to unregister filter")
 
 done:
@@ -370,27 +372,28 @@ done:
  * Purpose:  Same as the public version except this one allows filters
  *           to be unset for predefined method numbers <H5Z_FILTER_RESERVED
  *
- * Return:   Non-negative on success/Negative on failure
+ * Return:   Non-negative on success
+ *           Negative on failure
  *-------------------------------------------------------------------------
  */
 herr_t
 H5Z_unregister(H5Z_filter_t filter_id)
 {
-    size_t       filter_index;        /* Local index variable for filter */
+    size_t       filter_index;          /* Local index variable for filter */
     H5Z_object_t object;
-    herr_t       ret_value=SUCCEED;   /* Return value */
+    herr_t       ret_value = SUCCEED;   /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
     HDassert(filter_id>=0 && filter_id<=H5Z_FILTER_MAX);
 
     /* Is the filter already registered? */
-    for (filter_index=0; filter_index<H5Z_table_used_g; filter_index++)
-        if (H5Z_table_g[filter_index].id==filter_id)
+    for (filter_index = 0; filter_index < H5Z_table_used_g; filter_index++)
+        if (H5Z_table_g[filter_index].id == filter_id)
             break;
 
     /* Fail if filter not found */
-    if (filter_index>=H5Z_table_used_g)
+    if (filter_index >= H5Z_table_used_g)
         HGOTO_ERROR(H5E_PLINE, H5E_NOTFOUND, FAIL, "filter is not registered")
 
     /* Initialize the structure object for iteration */
@@ -398,28 +401,28 @@ H5Z_unregister(H5Z_filter_t filter_id)
     object.found = FALSE;
 
     /* Iterate through all opened datasets, returns a failure if any of them uses the filter */
-    if(H5I_iterate(H5I_DATASET, H5Z__check_unregister_dset_cb, &object, FALSE) < 0)
+    if (H5I_iterate(H5I_DATASET, H5Z__check_unregister_dset_cb, &object, FALSE) < 0)
         HGOTO_ERROR(H5E_FILE, H5E_BADITER, FAIL, "iteration failed")
 
-    if(object.found)
+    if (object.found)
         HGOTO_ERROR(H5E_PLINE, H5E_CANTRELEASE, FAIL, "can't unregister filter because a dataset is still using it")
 
     /* Iterate through all opened groups, returns a failure if any of them uses the filter */
-    if(H5I_iterate(H5I_GROUP, H5Z__check_unregister_group_cb, &object, FALSE) < 0)
+    if (H5I_iterate(H5I_GROUP, H5Z__check_unregister_group_cb, &object, FALSE) < 0)
         HGOTO_ERROR(H5E_FILE, H5E_BADITER, FAIL, "iteration failed")
 
-    if(object.found)
+    if (object.found)
         HGOTO_ERROR(H5E_PLINE, H5E_CANTRELEASE, FAIL, "can't unregister filter because a group is still using it")
 
     /* Iterate through all opened files and flush them */
-    if(H5I_iterate(H5I_FILE, H5Z__flush_file_cb, NULL, FALSE) < 0)
+    if (H5I_iterate(H5I_FILE, H5Z__flush_file_cb, NULL, FALSE) < 0)
         HGOTO_ERROR(H5E_FILE, H5E_BADITER, FAIL, "iteration failed")
 
     /* Remove filter from table */
     /* Don't worry about shrinking table size (for now) */
-    HDmemmove(&H5Z_table_g[filter_index],&H5Z_table_g[filter_index+1],sizeof(H5Z_class2_t)*((H5Z_table_used_g-1)-filter_index));
+    HDmemmove(&H5Z_table_g[filter_index], &H5Z_table_g[filter_index+1], sizeof(H5Z_class2_t)*((H5Z_table_used_g-1)-filter_index));
 #ifdef H5Z_DEBUG
-    HDmemmove(&H5Z_stat_table_g[filter_index],&H5Z_stat_table_g[filter_index+1],sizeof(H5Z_stats_t)*((H5Z_table_used_g-1)-filter_index));
+    HDmemmove(&H5Z_stat_table_g[filter_index], &H5Z_stat_table_g[filter_index+1], sizeof(H5Z_stats_t)*((H5Z_table_used_g-1)-filter_index));
 #endif /* H5Z_DEBUG */
     H5Z_table_used_g--;
 
@@ -431,10 +434,10 @@ done:
 /*-------------------------------------------------------------------------
  * Function: H5Z__check_unregister
  *
- * Purpose:  Check if an object uses the filter to be unregistered.
+ * Purpose: Check if an object uses the filter to be unregistered.
  *
- * Return:   TRUE if the object uses the filter.
- *           FALSE if not, NEGATIVE on error.
+ * Return:  TRUE if the object uses the filter.
+ *          FALSE if not, NEGATIVE on error.
  *-------------------------------------------------------------------------
  */
 static htri_t
@@ -446,11 +449,11 @@ H5Z__check_unregister(hid_t ocpl_id, H5Z_filter_t filter_id)
     FUNC_ENTER_STATIC
 
     /* Get the plist structure of object creation */
-    if(NULL == (plist = H5P_object_verify(ocpl_id, H5P_OBJECT_CREATE)))
+    if (NULL == (plist = H5P_object_verify(ocpl_id, H5P_OBJECT_CREATE)))
         HGOTO_ERROR(H5E_PLINE, H5E_BADATOM, FAIL, "can't find object for ID")
 
     /* Check if the object creation property list uses the filter */
-    if((ret_value = H5P_filter_in_pline(plist, filter_id)) < 0)
+    if ((ret_value = H5P_filter_in_pline(plist, filter_id)) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_CANTGET, FAIL, "can't check filter in pipeline")
 
 done:
@@ -483,24 +486,24 @@ H5Z__check_unregister_group_cb(void *obj_ptr, hid_t H5_ATTR_UNUSED obj_id, void
     HDassert(obj_ptr);
 
     /* Get the group creation property */
-    if((ocpl_id = H5G_get_create_plist((H5G_t *)obj_ptr)) < 0)
+    if ((ocpl_id = H5G_get_create_plist((H5G_t *)obj_ptr)) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_CANTGET, FAIL, "can't get group creation property list")
 
     /* Check if the filter is in the group creation property list */
-    if((filter_in_pline = H5Z__check_unregister(ocpl_id, object->filter_id)) < 0)
+    if ((filter_in_pline = H5Z__check_unregister(ocpl_id, object->filter_id)) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_CANTGET, FAIL, "can't check filter in pipeline")
 
     /* H5I_iterate expects TRUE to stop the loop over objects. Stop the loop and
      * let H5Z_unregister return failure.
      */
-    if(filter_in_pline) {
+    if (filter_in_pline) {
         object->found = TRUE;
         ret_value = TRUE;
     } /* end if */
 
 done:
-    if(ocpl_id > 0)
-        if(H5I_dec_app_ref(ocpl_id) < 0)
+    if (ocpl_id > 0)
+        if (H5I_dec_app_ref(ocpl_id) < 0)
             HDONE_ERROR(H5E_PLINE, H5E_CANTDEC, FAIL, "can't release plist")
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -510,13 +513,13 @@ done:
 /*-------------------------------------------------------------------------
  * Function: H5Z__check_unregister_dset_cb
  *
- * Purpose:  The callback function for H5Z_unregister. It iterates
- *           through all opened objects.  If the object is a dataset
- *           or a group and it uses the filter to be unregistered, the
- *           function returns TRUE.
+ * Purpose: The callback function for H5Z_unregister. It iterates
+ *          through all opened objects.  If the object is a dataset
+ *          or a group and it uses the filter to be unregistered, the
+ *          function returns TRUE.
  *
- * Return:   TRUE if the object uses the filter.
- *           FALSE otherwise.
+ * Return:  TRUE if the object uses the filter.
+ *          FALSE otherwise.
  *-------------------------------------------------------------------------
  */
 static int
@@ -532,24 +535,24 @@ H5Z__check_unregister_dset_cb(void *obj_ptr, hid_t H5_ATTR_UNUSED obj_id, void *
     HDassert(obj_ptr);
 
     /* Get the dataset creation property */
-    if((ocpl_id = H5D_get_create_plist((H5D_t *)obj_ptr)) < 0)
+    if ((ocpl_id = H5D_get_create_plist((H5D_t *)obj_ptr)) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_CANTGET, FAIL, "can't get dataset creation property list")
 
     /* Check if the filter is in the dataset creation property list */
-    if((filter_in_pline = H5Z__check_unregister(ocpl_id, object->filter_id)) < 0)
+    if ((filter_in_pline = H5Z__check_unregister(ocpl_id, object->filter_id)) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_CANTGET, FAIL, "can't check filter in pipeline")
 
     /* H5I_iterate expects TRUE to stop the loop over objects. Stop the loop and
      * let H5Z_unregister return failure.
      */
-    if(filter_in_pline) {
+    if (filter_in_pline) {
         object->found = TRUE;
         ret_value = TRUE;
     } /* end if */
 
 done:
-    if(ocpl_id > 0)
-        if(H5I_dec_app_ref(ocpl_id) < 0)
+    if (ocpl_id > 0)
+        if (H5I_dec_app_ref(ocpl_id) < 0)
             HDONE_ERROR(H5E_PLINE, H5E_CANTDEC, FAIL, "can't release plist")
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -569,7 +572,7 @@ done:
 static int
 H5Z__flush_file_cb(void *obj_ptr, hid_t H5_ATTR_UNUSED obj_id, void H5_ATTR_UNUSED *key)
 {
-    int             ret_value = FALSE;    /* Return value */
+    int    ret_value = FALSE;    /* Return value */
 
     FUNC_ENTER_STATIC
 
@@ -577,8 +580,8 @@ H5Z__flush_file_cb(void *obj_ptr, hid_t H5_ATTR_UNUSED obj_id, void H5_ATTR_UNUS
 
     /* Call the flush routine for mounted file hierarchies. Do a global flush
      * if the file is opened for write */
-    if(H5F_ACC_RDWR & H5F_INTENT((H5F_t *)obj_ptr)) {
-        if(H5F_flush_mounts((H5F_t *)obj_ptr, H5AC_ind_read_dxpl_id, H5AC_rawdata_dxpl_id) < 0)
+    if (H5F_ACC_RDWR & H5F_INTENT((H5F_t *)obj_ptr)) {
+        if (H5F_flush_mounts((H5F_t *)obj_ptr, H5AC_ind_read_dxpl_id, H5AC_rawdata_dxpl_id) < 0)
             HGOTO_ERROR(H5E_PLINE, H5E_CANTFLUSH, FAIL, "unable to flush file hierarchy")
     } /* end if */
 
@@ -598,16 +601,16 @@ done:
 htri_t
 H5Zfilter_avail(H5Z_filter_t id)
 {
-    htri_t ret_value=FALSE;     /* Return value */
+    htri_t    ret_value = FALSE;     /* Return value */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE1("t", "Zf", id);
 
     /* Check args */
-    if(id<0 || id>H5Z_FILTER_MAX)
-        HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "invalid filter identification number")
+    if (id < 0 || id > H5Z_FILTER_MAX)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid filter identification number")
 
-    if((ret_value = H5Z_filter_avail(id)) < 0)
+    if ((ret_value = H5Z_filter_avail(id)) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_NOTFOUND, FAIL, "unable to check the availability of the filter")
 
 done:
@@ -626,22 +629,25 @@ done:
 htri_t
 H5Z_filter_avail(H5Z_filter_t id)
 {
-    size_t i;                   /* Local index variable */
-    const H5Z_class2_t *filter_info;
-    htri_t ret_value = FALSE;   /* Return value */
+    H5PL_key_t          key;                /* Key for finding a plugin     */
+    const H5Z_class2_t *filter_info;        /* Filter information           */
+    size_t              i;                  /* Local index variable         */
+    htri_t              ret_value = FALSE;  /* Return value                 */
 
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Is the filter already registered? */
-    for(i = 0; i < H5Z_table_used_g; i++)
-        if(H5Z_table_g[i].id == id)
+    for (i = 0; i < H5Z_table_used_g; i++)
+        if (H5Z_table_g[i].id == id)
             HGOTO_DONE(TRUE)
 
-    if(NULL != (filter_info = (const H5Z_class2_t *)H5PL_load(H5PL_TYPE_FILTER, (int)id))) {
-        if(H5Z_register(filter_info) < 0)
+    key.id = (int)id;
+    if (NULL != (filter_info = (const H5Z_class2_t *)H5PL_load(H5PL_TYPE_FILTER, key))) {
+        if (H5Z_register(filter_info) < 0)
             HGOTO_ERROR(H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register loaded filter")
         HGOTO_DONE(TRUE)
     }
+
 done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5Z_filter_avail() */
@@ -666,52 +672,52 @@ H5Z_prelude_callback(const H5O_pline_t *pline, hid_t dcpl_id, hid_t type_id,
 {
     H5Z_class2_t    *fclass;                /* Individual filter information */
     size_t          u;                      /* Local index variable */
-    htri_t          ret_value = TRUE;    /* Return value */
+    htri_t          ret_value = TRUE;       /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
     HDassert(pline->nused > 0);
 
     /* Iterate over filters */
-    for(u = 0; u < pline->nused; u++) {
+    for (u = 0; u < pline->nused; u++) {
         /* Get filter information */
-        if(NULL == (fclass = H5Z_find(pline->filter[u].id))) {
+        if (NULL == (fclass = H5Z_find(pline->filter[u].id))) {
             /* Ignore errors from optional filters */
-            if(pline->filter[u].flags & H5Z_FLAG_OPTIONAL)
-                H5E_clear_stack(NULL);
+            if (pline->filter[u].flags & H5Z_FLAG_OPTIONAL)
+                H5E_clear_stack (NULL);
             else
                 HGOTO_ERROR(H5E_PLINE, H5E_NOTFOUND, FAIL, "required filter was not located")
         } /* end if */
         else {
             /* Make correct callback */
-            switch(prelude_type) {
+            switch (prelude_type) {
                 case H5Z_PRELUDE_CAN_APPLY:
                     /* Check if filter is configured to be able to encode */
-                    if(!fclass->encoder_present)
+                    if (!fclass->encoder_present)
                         HGOTO_ERROR(H5E_PLINE, H5E_NOENCODER, FAIL, "Filter present but encoding is disabled.");
 
 
                     /* Check if there is a "can apply" callback */
-                    if(fclass->can_apply) {
+                    if (fclass->can_apply) {
                         /* Make callback to filter's "can apply" function */
                         htri_t status = (fclass->can_apply)(dcpl_id, type_id, space_id);
 
                         /* Indicate error during filter callback */
-                        if(status < 0)
+                        if (status < 0)
                             HGOTO_ERROR(H5E_PLINE, H5E_CANAPPLY, FAIL, "error during user callback")
 
                         /* Indicate filter can't apply to this combination of parameters.
                          * If the filter is NOT optional, returns failure. */
-                        if(status == FALSE && !(pline->filter[u].flags & H5Z_FLAG_OPTIONAL))
+                        if (status == FALSE && !(pline->filter[u].flags & H5Z_FLAG_OPTIONAL))
                             HGOTO_ERROR(H5E_PLINE, H5E_CANAPPLY, FAIL, "filter parameters not appropriate")
                     } /* end if */
                     break;
 
                 case H5Z_PRELUDE_SET_LOCAL:
                     /* Check if there is a "set local" callback */
-                    if(fclass->set_local) {
+                    if (fclass->set_local) {
                         /* Make callback to filter's "set local" function */
-                        if((fclass->set_local)(dcpl_id, type_id, space_id) < 0)
+                        if ((fclass->set_local)(dcpl_id, type_id, space_id) < 0)
                             /* Indicate error during filter callback */
                             HGOTO_ERROR(H5E_PLINE, H5E_SETLOCAL, FAIL, "error during user callback")
                     } /* end if */
@@ -745,8 +751,9 @@ done:
 static herr_t
 H5Z_prepare_prelude_callback_dcpl(hid_t dcpl_id, hid_t type_id, H5Z_prelude_type_t prelude_type)
 {
-    hid_t space_id = -1;            /* ID for dataspace describing chunk */
-    herr_t ret_value = SUCCEED;     /* Return value */
+    hid_t   space_id = -1;            /* ID for dataspace describing chunk */
+    H5O_layout_t *dcpl_layout = NULL; /* Dataset's layout information */
+    herr_t  ret_value = SUCCEED;      /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -754,55 +761,61 @@ H5Z_prepare_prelude_callback_dcpl(hid_t dcpl_id, hid_t type_id, H5Z_prelude_type
     HDassert(H5I_DATATYPE == H5I_get_type(type_id));
 
     /* Check if the property list is non-default */
-    if(dcpl_id != H5P_DATASET_CREATE_DEFAULT) {
-        H5P_genplist_t         *dc_plist;      /* Dataset creation property list object */
-        H5O_layout_t    dcpl_layout;    /* Dataset's layout information */
+    if (dcpl_id != H5P_DATASET_CREATE_DEFAULT) {
+        H5P_genplist_t     *dc_plist;           /* Dataset creation property list object */
+
+        /* Get memory for the layout */
+        if (NULL == (dcpl_layout = (H5O_layout_t *)H5MM_calloc(sizeof(H5O_layout_t))))
+            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to allocate dcpl layout buffer")
 
         /* Get dataset creation property list object */
-        if(NULL == (dc_plist = (H5P_genplist_t *)H5I_object(dcpl_id)))
-            HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "can't get dataset creation property list")
+        if (NULL == (dc_plist = (H5P_genplist_t *)H5I_object(dcpl_id)))
+            HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "can't get dataset creation property list")
 
         /* Peek at the layout information */
-        if(H5P_peek(dc_plist, H5D_CRT_LAYOUT_NAME, &dcpl_layout) < 0)
-            HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, FAIL, "can't retrieve layout")
+        if (H5P_peek(dc_plist, H5D_CRT_LAYOUT_NAME, dcpl_layout) < 0)
+            HGOTO_ERROR (H5E_PLIST, H5E_CANTGET, FAIL, "can't retrieve layout")
 
         /* Check if the dataset is chunked */
-        if(H5D_CHUNKED == dcpl_layout.type) {
+        if (H5D_CHUNKED == dcpl_layout->type) {
             H5O_pline_t     dcpl_pline;     /* Object's I/O pipeline information */
 
             /* Get I/O pipeline information */
-            if(H5P_peek(dc_plist, H5O_CRT_PIPELINE_NAME, &dcpl_pline) < 0)
-                HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, FAIL, "can't retrieve pipeline filter")
+            if (H5P_peek(dc_plist, H5O_CRT_PIPELINE_NAME, &dcpl_pline) < 0)
+                HGOTO_ERROR (H5E_PLIST, H5E_CANTGET, FAIL, "can't retrieve pipeline filter")
 
             /* Check if the chunks have filters */
-            if(dcpl_pline.nused > 0) {
+            if (dcpl_pline.nused > 0) {
                 hsize_t chunk_dims[H5O_LAYOUT_NDIMS];      /* Size of chunk dimensions */
-                H5S_t *space;           /* Dataspace describing chunk */
-                size_t u;               /* Local index variable */
+                H5S_t  *space;           /* Dataspace describing chunk */
+                size_t  u;               /* Local index variable */
 
-                /* Create a data space for a chunk & set the extent */
-                for(u = 0; u < dcpl_layout.u.chunk.ndims; u++)
-                    chunk_dims[u] = dcpl_layout.u.chunk.dim[u];
-                if(NULL == (space = H5S_create_simple(dcpl_layout.u.chunk.ndims, chunk_dims, NULL)))
-                    HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCREATE, FAIL, "can't create simple dataspace")
+                /* Create a dataspace for a chunk & set the extent */
+                for (u = 0; u < dcpl_layout->u.chunk.ndims; u++)
+                    chunk_dims[u] = dcpl_layout->u.chunk.dim[u];
+                if (NULL == (space = H5S_create_simple(dcpl_layout->u.chunk.ndims, chunk_dims, NULL)))
+                    HGOTO_ERROR (H5E_DATASPACE, H5E_CANTCREATE, FAIL, "can't create simple dataspace")
 
                 /* Get ID for dataspace to pass to filter routines */
-                if((space_id = H5I_register(H5I_DATASPACE, space, FALSE)) < 0) {
+                if ((space_id = H5I_register(H5I_DATASPACE, space, FALSE)) < 0) {
                     (void)H5S_close(space);
-                    HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register dataspace ID")
-                } /* end if */
+                    HGOTO_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register dataspace ID")
+                }
 
                 /* Make the callbacks */
-                if(H5Z_prelude_callback(&dcpl_pline, dcpl_id, type_id, space_id, prelude_type) < 0)
-                    HGOTO_ERROR(H5E_PLINE, H5E_CANAPPLY, FAIL, "unable to apply filter")
-            } /* end if */
-        } /* end if */
-    } /* end if */
+                if (H5Z_prelude_callback(&dcpl_pline, dcpl_id, type_id, space_id, prelude_type) < 0)
+                    HGOTO_ERROR (H5E_PLINE, H5E_CANAPPLY, FAIL, "unable to apply filter")
+            }
+        }
+    }
 
 done:
-    if(space_id > 0 && H5I_dec_ref(space_id) < 0)
+    if (space_id > 0 && H5I_dec_ref(space_id) < 0)
         HDONE_ERROR(H5E_PLINE, H5E_CANTRELEASE, FAIL, "unable to close dataspace")
 
+    if (dcpl_layout)
+        dcpl_layout = (H5O_layout_t *)H5MM_xfree(dcpl_layout);
+
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5Z_prepare_prelude_callback_dcpl() */
 
@@ -814,7 +827,8 @@ done:
  *           property list can be applied to a particular combination of
  *           datatype and dataspace for a dataset.
  *
- * Return:   Non-negative on success/Negative on failure
+ * Return:   Non-negative on success
+ *           Negative on failure
  *
  * Notes:    The chunk dimensions are used to create a dataspace, instead
  *           of passing in the dataset's dataspace, since the chunk
@@ -829,7 +843,7 @@ H5Z_can_apply(hid_t dcpl_id, hid_t type_id)
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Make "can apply" callbacks for filters in pipeline */
-    if(H5Z_prepare_prelude_callback_dcpl(dcpl_id, type_id, H5Z_PRELUDE_CAN_APPLY) < 0)
+    if (H5Z_prepare_prelude_callback_dcpl(dcpl_id, type_id, H5Z_PRELUDE_CAN_APPLY) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_CANAPPLY, FAIL, "unable to apply filter")
 
 done:
@@ -844,7 +858,8 @@ done:
  *           settings for filters on a new dataset, based on the datatype
  *           and dataspace of that dataset (chunk).
  *
- * Return:   Non-negative on success/Negative on failure
+ * Return:   Non-negative on success
+ *           Negative on failure
  *
  * Notes:    The chunk dimensions are used to create a dataspace, instead
  *           of passing in the dataset's dataspace, since the chunk
@@ -859,7 +874,7 @@ H5Z_set_local(hid_t dcpl_id, hid_t type_id)
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Make "set local" callbacks for filters in pipeline */
-    if(H5Z_prepare_prelude_callback_dcpl(dcpl_id, type_id, H5Z_PRELUDE_SET_LOCAL) < 0)
+    if (H5Z_prepare_prelude_callback_dcpl(dcpl_id, type_id, H5Z_PRELUDE_SET_LOCAL) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_SETLOCAL, FAIL, "local filter parameters not set")
 
 done:
@@ -874,7 +889,8 @@ done:
  *           applied to an opaque byte stream (currently only a group).
  *           The pipeline is assumed to have at least one filter.
  *
- * Return:   Non-negative on success/Negative on failure
+ * Return:   Non-negative on success
+ *           Negative on failure
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -887,7 +903,7 @@ H5Z_can_apply_direct(const H5O_pline_t *pline)
     HDassert(pline->nused > 0);
 
     /* Make "can apply" callbacks for filters in pipeline */
-    if(H5Z_prelude_callback(pline, (hid_t)-1, (hid_t)-1, (hid_t)-1, H5Z_PRELUDE_CAN_APPLY) < 0)
+    if (H5Z_prelude_callback(pline, (hid_t)-1, (hid_t)-1, (hid_t)-1, H5Z_PRELUDE_CAN_APPLY) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_CANAPPLY, FAIL, "unable to apply filter")
 
 done:
@@ -902,7 +918,8 @@ done:
  *           new opaque object.  The pipeline is assumed to have at
  *           least one filter.
  *
- * Return:   Non-negative on success/Negative on failure
+ * Return:   Non-negative on success
+ *           Negative on failure
  *
  * Notes:    This callback will almost certainly not do anything
  *           useful, other than to make certain that the filter will
@@ -919,7 +936,7 @@ H5Z_set_local_direct(const H5O_pline_t *pline)
     HDassert(pline->nused > 0);
 
     /* Make "set local" callbacks for filters in pipeline */
-    if(H5Z_prelude_callback(pline, (hid_t)-1, (hid_t)-1, (hid_t)-1, H5Z_PRELUDE_SET_LOCAL) < 0)
+    if (H5Z_prelude_callback(pline, (hid_t)-1, (hid_t)-1, (hid_t)-1, H5Z_PRELUDE_SET_LOCAL) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_SETLOCAL, FAIL, "local filter parameters not set")
 
 done:
@@ -930,17 +947,18 @@ done:
 /*-------------------------------------------------------------------------
  * Function: H5Z_modify
  *
- * Purpose: Modify filter parameters for specified pipeline.
+ * Purpose:  Modify filter parameters for specified pipeline.
  *
- * Return:  Non-negative on success/Negative on failure
+ * Return:   Non-negative on success
+ *           Negative on failure
  *-------------------------------------------------------------------------
  */
 herr_t
 H5Z_modify(const H5O_pline_t *pline, H5Z_filter_t filter, unsigned flags,
         size_t cd_nelmts, const unsigned int cd_values[/*cd_nelmts*/])
 {
-    size_t      idx;                      /* Index of filter in pipeline */
-    herr_t      ret_value = SUCCEED;      /* Return value */
+    size_t      idx;                    /* Index of filter in pipeline */
+    herr_t      ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
@@ -950,12 +968,12 @@ H5Z_modify(const H5O_pline_t *pline, H5Z_filter_t filter, unsigned flags,
     HDassert(0 == cd_nelmts || cd_values);
 
     /* Locate the filter in the pipeline */
-    for(idx = 0; idx < pline->nused; idx++)
-        if(pline->filter[idx].id == filter)
+    for (idx = 0; idx < pline->nused; idx++)
+        if (pline->filter[idx].id == filter)
             break;
 
     /* Check if the filter was not already in the pipeline */
-    if(idx > pline->nused)
+    if (idx > pline->nused)
         HGOTO_ERROR(H5E_PLINE, H5E_NOTFOUND, FAIL, "filter not in pipeline")
 
     /* Change parameters for filter */
@@ -963,25 +981,25 @@ H5Z_modify(const H5O_pline_t *pline, H5Z_filter_t filter, unsigned flags,
     pline->filter[idx].cd_nelmts = cd_nelmts;
 
     /* Free any existing parameters */
-    if(pline->filter[idx].cd_values != NULL && pline->filter[idx].cd_values != pline->filter[idx]._cd_values)
+    if (pline->filter[idx].cd_values != NULL && pline->filter[idx].cd_values != pline->filter[idx]._cd_values)
         H5MM_xfree(pline->filter[idx].cd_values);
 
     /* Set parameters */
-    if(cd_nelmts > 0) {
-        size_t        i;                      /* Local index variable */
+    if (cd_nelmts > 0) {
+        size_t    i;                      /* Local index variable */
 
         /* Allocate memory or point at internal buffer */
-        if(cd_nelmts > H5Z_COMMON_CD_VALUES) {
+        if (cd_nelmts > H5Z_COMMON_CD_VALUES) {
             pline->filter[idx].cd_values = (unsigned *)H5MM_malloc(cd_nelmts * sizeof(unsigned));
-            if(NULL == pline->filter[idx].cd_values)
+            if (NULL == pline->filter[idx].cd_values)
                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for filter parameters")
         } /* end if */
         else
             pline->filter[idx].cd_values = pline->filter[idx]._cd_values;
 
         /* Copy client data values */
-        for(i = 0; i < cd_nelmts; i++)
-        pline->filter[idx].cd_values[i] = cd_values[i];
+        for (i = 0; i < cd_nelmts; i++)
+            pline->filter[idx].cd_values[i] = cd_values[i];
     } /* end if */
     else
        pline->filter[idx].cd_values = NULL;
@@ -996,15 +1014,16 @@ done:
  *
  * Purpose:  Append another filter to the specified pipeline.
  *
- * Return:   Non-negative on success/Negative on failure
+ * Return:   Non-negative on success
+ *           Negative on failure
  *-------------------------------------------------------------------------
  */
 herr_t
 H5Z_append(H5O_pline_t *pline, H5Z_filter_t filter, unsigned flags,
         size_t cd_nelmts, const unsigned int cd_values[/*cd_nelmts*/])
 {
-    size_t      idx;
-    herr_t      ret_value = SUCCEED;       /* Return value */
+    size_t    idx;
+    herr_t    ret_value = SUCCEED;       /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
@@ -1017,15 +1036,15 @@ H5Z_append(H5O_pline_t *pline, H5Z_filter_t filter, unsigned flags,
      * Check filter limit.  We do it here for early warnings although we may
      * decide to relax this restriction in the future.
      */
-    if(pline->nused >= H5Z_MAX_NFILTERS)
-        HGOTO_ERROR(H5E_PLINE, H5E_CANTINIT, FAIL, "too many filters in pipeline")
+    if (pline->nused >= H5Z_MAX_NFILTERS)
+        HGOTO_ERROR (H5E_PLINE, H5E_CANTINIT, FAIL, "too many filters in pipeline")
 
     /* Check for freshly allocated filter pipeline */
-    if(pline->version == 0)
+    if (pline->version == 0)
         pline->version = H5O_PLINE_VERSION_1;
 
     /* Allocate additional space in the pipeline if it's full */
-    if(pline->nused >= pline->nalloc) {
+    if (pline->nused >= pline->nalloc) {
         H5O_pline_t x;
         size_t n;
 
@@ -1036,20 +1055,20 @@ H5Z_append(H5O_pline_t *pline, H5Z_filter_t filter, unsigned flags,
          * filter struct is reallocated.  Set these pointers to ~NULL
          * so that we can reset them after reallocating the filters array.
          */
-        for(n = 0; n < pline->nalloc; ++n)
-            if(pline->filter[n].cd_values == pline->filter[n]._cd_values)
+        for (n = 0; n < pline->nalloc; ++n)
+            if (pline->filter[n].cd_values == pline->filter[n]._cd_values)
                 pline->filter[n].cd_values = (unsigned *)((void *) ~((size_t)NULL));
 
         x.nalloc = MAX(H5Z_MAX_NFILTERS, 2 * pline->nalloc);
         x.filter = (H5Z_filter_info_t *)H5MM_realloc(pline->filter, x.nalloc * sizeof(x.filter[0]));
-        if(NULL == x.filter)
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for filter pipeline")
+        if (NULL == x.filter)
+            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for filter pipeline")
 
         /* Fix pointers in previous filters that need to point to their own
          *      internal data.
          */
-        for(n = 0; n < pline->nalloc; ++n)
-            if(x.filter[n].cd_values == (void *) ~((size_t) NULL))
+        for (n = 0; n < pline->nalloc; ++n)
+            if (x.filter[n].cd_values == (void *) ~((size_t) NULL))
                 x.filter[n].cd_values = x.filter[n]._cd_values;
 
         /* Point to newly allocated buffer */
@@ -1061,22 +1080,22 @@ H5Z_append(H5O_pline_t *pline, H5Z_filter_t filter, unsigned flags,
     idx = pline->nused;
     pline->filter[idx].id = filter;
     pline->filter[idx].flags = flags;
-    pline->filter[idx].name = NULL; /* we'll pick it up later*/
+    pline->filter[idx].name = NULL; /*we'll pick it up later*/
     pline->filter[idx].cd_nelmts = cd_nelmts;
-    if(cd_nelmts > 0) {
-        size_t        i;                      /* Local index variable */
+    if (cd_nelmts > 0) {
+        size_t    i;                      /* Local index variable */
 
         /* Allocate memory or point at internal buffer */
-        if(cd_nelmts > H5Z_COMMON_CD_VALUES) {
+        if (cd_nelmts > H5Z_COMMON_CD_VALUES) {
             pline->filter[idx].cd_values = (unsigned *)H5MM_malloc(cd_nelmts * sizeof(unsigned));
-            if(NULL == pline->filter[idx].cd_values)
+            if (NULL == pline->filter[idx].cd_values)
                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for filter")
         } /* end if */
         else
             pline->filter[idx].cd_values = pline->filter[idx]._cd_values;
 
         /* Copy client data values */
-        for(i = 0; i < cd_nelmts; i++)
+        for (i = 0; i < cd_nelmts; i++)
             pline->filter[idx].cd_values[i] = cd_values[i];
     } /* end if */
     else
@@ -1095,8 +1114,8 @@ done:
  * Purpose:  Given a filter ID return the offset in the global array
  *           that holds all the registered filters.
  *
- * Return:   Success:        Non-negative index of entry in global filter table.
- *           Failure:        Negative
+ * Return:   Success:    Non-negative index of entry in global filter table.
+ *           Failure:    Negative
  *-------------------------------------------------------------------------
  */
 static int
@@ -1107,9 +1126,9 @@ H5Z_find_idx(H5Z_filter_t id)
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
-    for (i=0; i<H5Z_table_used_g; i++)
+    for (i = 0; i < H5Z_table_used_g; i++)
         if (H5Z_table_g[i].id == id)
-        HGOTO_DONE((int)i)
+            HGOTO_DONE((int)i)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -1122,24 +1141,24 @@ done:
  * Purpose:  Given a filter ID return a pointer to a global struct that
  *           defines the filter.
  *
- * Return:   Success:        Ptr to entry in global filter table.
- *           Failure:        NULL
+ * Return:   Success:    Ptr to entry in global filter table.
+ *           Failure:    NULL
  *-------------------------------------------------------------------------
  */
 H5Z_class2_t *
 H5Z_find(H5Z_filter_t id)
 {
-    int           idx;                   /* Filter index in global table */
-    H5Z_class2_t *ret_value=NULL;        /* Return value */
+    int           idx;                     /* Filter index in global table */
+    H5Z_class2_t *ret_value = NULL;        /* Return value */
 
     FUNC_ENTER_NOAPI(NULL)
 
     /* Get the index in the global table */
-    if((idx=H5Z_find_idx(id))<0)
+    if ((idx = H5Z_find_idx(id)) < 0)
         HGOTO_ERROR(H5E_PLINE, H5E_NOTFOUND, NULL, "required filter %d is not registered", id)
 
     /* Set return value */
-    ret_value=H5Z_table_g+idx;
+    ret_value = H5Z_table_g + idx;
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -1149,23 +1168,24 @@ done:
 /*-------------------------------------------------------------------------
  * Function: H5Z_pipeline
  *
- * Purpose: Process data through the filter pipeline.  The FLAGS argument
- *          is the filter invocation flags (definition flags come from
- *          the PLINE->filter[].flags).  The filters are processed in
- *          definition order unless the H5Z_FLAG_REVERSE is set.  The
- *          FILTER_MASK is a bit-mask to indicate which filters to skip
- *          and on exit will indicate which filters failed.  Each
- *          filter has an index number in the pipeline and that index
- *          number is the filter's bit in the FILTER_MASK.  NBYTES is the
- *          number of bytes of data to filter and on exit should be the
- *          number of resulting bytes while BUF_SIZE holds the total
- *          allocated size of the buffer, which is pointed to BUF.
- *
- *          If the buffer must grow during processing of the pipeline
- *          then the pipeline function should free the original buffer
- *          and return a fresh buffer, adjusting BUF_SIZE accordingly.
- *
- * Return:  Non-negative on success/Negative on failure
+ * Purpose:  Process data through the filter pipeline.  The FLAGS argument
+ *           is the filter invocation flags (definition flags come from
+ *           the PLINE->filter[].flags).  The filters are processed in
+ *           definition order unless the H5Z_FLAG_REVERSE is set.  The
+ *           FILTER_MASK is a bit-mask to indicate which filters to skip
+ *           and on exit will indicate which filters failed.  Each
+ *           filter has an index number in the pipeline and that index
+ *           number is the filter's bit in the FILTER_MASK.  NBYTES is the
+ *           number of bytes of data to filter and on exit should be the
+ *           number of resulting bytes while BUF_SIZE holds the total
+ *           allocated size of the buffer, which is pointed to BUF.
+ *
+ *           If the buffer must grow during processing of the pipeline
+ *           then the pipeline function should free the original buffer
+ *           and return a fresh buffer, adjusting BUF_SIZE accordingly.
+ *
+ * Return:   Non-negative on success
+ *           Negative on failure
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -1174,94 +1194,96 @@ H5Z_pipeline(const H5O_pline_t *pline, unsigned flags,
         H5Z_cb_t cb_struct, size_t *nbytes/*in,out*/,
         size_t *buf_size/*in,out*/, void **buf/*in,out*/)
 {
-    size_t        i, idx, new_nbytes;
-    int           fclass_idx;          /* Index of filter class in global table */
-    H5Z_class2_t  *fclass = NULL;      /* Filter class pointer */
+    size_t    i, idx, new_nbytes;
+    int       fclass_idx;        /* Index of filter class in global table */
+    H5Z_class2_t *fclass=NULL;   /* Filter class pointer */
 #ifdef H5Z_DEBUG
-    H5Z_stats_t   *fstats = NULL;      /* Filter stats pointer */
+    H5Z_stats_t  *fstats=NULL;   /* Filter stats pointer */
     H5_timer_t    timer;
 #endif
-    unsigned      failed = 0;
-    unsigned      tmp_flags;
-    herr_t        ret_value = SUCCEED; /* Return value */
+    unsigned    failed = 0;
+    unsigned    tmp_flags;
+    herr_t      ret_value = SUCCEED;       /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
     HDassert(0 == (flags & ~((unsigned)H5Z_FLAG_INVMASK)));
     HDassert(filter_mask);
-    HDassert(nbytes && *nbytes > 0);
-    HDassert(buf_size && *buf_size > 0);
+    HDassert(nbytes && *nbytes>0);
+    HDassert(buf_size && *buf_size>0);
     HDassert(buf && *buf);
     HDassert(!pline || pline->nused < H5Z_MAX_NFILTERS);
 
     if (pline && (flags & H5Z_FLAG_REVERSE)) { /* Read */
         for (i = pline->nused; i > 0; --i) {
-            idx = i - 1;
+            idx = i-1;
 
             if (*filter_mask & ((unsigned)1 << idx)) {
                 failed |= (unsigned)1 << idx;
-                continue;/*filter excluded*/
+                continue;   /* filter excluded */
             }
 
             /* If the filter isn't registered and the application doesn't
-            * indicate no plugin through HDF5_PRELOAD_PLUG (using the symbol "::"),
-            * try to load it dynamically and register it.  Otherwise, return failure
-            */
-            if((fclass_idx = H5Z_find_idx(pline->filter[idx].id)) < 0) {
+             * indicate no plugin through HDF5_PRELOAD_PLUG (using the symbol "::"),
+             * try to load it dynamically and register it.  Otherwise, return failure
+             */
+            if ((fclass_idx = H5Z_find_idx(pline->filter[idx].id)) < 0) {
                 hbool_t issue_error = FALSE;
+                H5PL_key_t key;
                 const H5Z_class2_t    *filter_info;
 
                 /* Try loading the filter */
-                if(NULL != (filter_info = (const H5Z_class2_t *)H5PL_load(H5PL_TYPE_FILTER, (int)(pline->filter[idx].id)))) {
+                key.id = (int)(pline->filter[idx].id);
+                if(NULL != (filter_info = (const H5Z_class2_t *)H5PL_load(H5PL_TYPE_FILTER, key))) {
                     /* Register the filter we loaded */
                     if(H5Z_register(filter_info) < 0)
                         HGOTO_ERROR(H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register filter")
 
                     /* Search in the table of registered filters again to find the dynamic filter just loaded and registered */
-                    if((fclass_idx = H5Z_find_idx(pline->filter[idx].id)) < 0)
+                    if ((fclass_idx = H5Z_find_idx(pline->filter[idx].id)) < 0)
                         issue_error = TRUE;
-                } /* end if */
+                }
                 else
                     issue_error = TRUE;
 
                 /* Check for error */
-                if(issue_error) {
+                if (issue_error) {
                     /* Print out the filter name to give more info.  But the name is optional for
-                    * the filter */
-                    if(pline->filter[idx].name)
+                     * the filter */
+                    if (pline->filter[idx].name)
                         HGOTO_ERROR(H5E_PLINE, H5E_READERROR, FAIL, "required filter '%s' is not registered", pline->filter[idx].name)
                     else
                         HGOTO_ERROR(H5E_PLINE, H5E_READERROR, FAIL, "required filter (name unavailable) is not registered")
-                } /* end if */
+                }
             } /* end if */
 
             fclass = &H5Z_table_g[fclass_idx];
 #ifdef H5Z_DEBUG
             fstats = &H5Z_stat_table_g[fclass_idx];
-            H5_timer_begin(&timer);
+            H5_timer_begin (&timer);
 #endif
-            tmp_flags = flags|(pline->filter[idx].flags);
+            tmp_flags = flags | (pline->filter[idx].flags);
             tmp_flags |= (edc_read== H5Z_DISABLE_EDC) ? H5Z_FLAG_SKIP_EDC : 0;
             new_nbytes = (fclass->filter)(tmp_flags, pline->filter[idx].cd_nelmts,
-                          pline->filter[idx].cd_values, *nbytes, buf_size, buf);
+                                        pline->filter[idx].cd_values, *nbytes, buf_size, buf);
 
 #ifdef H5Z_DEBUG
-            H5_timer_end(&(fstats->stats[1].timer), &timer);
+            H5_timer_end (&(fstats->stats[1].timer), &timer);
             fstats->stats[1].total += MAX(*nbytes, new_nbytes);
-            if (0 == new_nbytes) fstats->stats[1].errors += *nbytes;
+            if (0 == new_nbytes)
+                fstats->stats[1].errors += *nbytes;
 #endif
 
-            if(0==new_nbytes) {
-                if((cb_struct.func && (H5Z_CB_FAIL == cb_struct.func(pline->filter[idx].id, *buf, *buf_size, cb_struct.op_data))) || !cb_struct.func)
+            if (0 == new_nbytes) {
+                if ((cb_struct.func && (H5Z_CB_FAIL == cb_struct.func(pline->filter[idx].id, *buf, *buf_size, cb_struct.op_data))) || !cb_struct.func)
                     HGOTO_ERROR(H5E_PLINE, H5E_READERROR, FAIL, "filter returned failure during read")
 
                 *nbytes = *buf_size;
                 failed |= (unsigned)1 << idx;
-                H5E_clear_stack(NULL);
+                H5E_clear_stack (NULL);
             }
-            else {
+            else
                 *nbytes = new_nbytes;
-            }
         }
     }
     else if (pline) { /* Write */
@@ -1276,35 +1298,35 @@ H5Z_pipeline(const H5O_pline_t *pline, unsigned flags,
                     HGOTO_ERROR(H5E_PLINE, H5E_WRITEERROR, FAIL, "required filter is not registered")
 
                 failed |= (unsigned)1 << idx;
-                H5E_clear_stack(NULL);
+                H5E_clear_stack (NULL);
                 continue; /*filter excluded*/
             }
             fclass = &H5Z_table_g[fclass_idx];
 #ifdef H5Z_DEBUG
             fstats = &H5Z_stat_table_g[fclass_idx];
-            H5_timer_begin(&timer);
+            H5_timer_begin (&timer);
 #endif
-            new_nbytes = (fclass->filter)(flags|(pline->filter[idx].flags), pline->filter[idx].cd_nelmts,
-                         pline->filter[idx].cd_values, *nbytes, buf_size, buf);
+            new_nbytes = (fclass->filter)(flags | (pline->filter[idx].flags), pline->filter[idx].cd_nelmts,
+                    pline->filter[idx].cd_values, *nbytes, buf_size, buf);
 #ifdef H5Z_DEBUG
-            H5_timer_end(&(fstats->stats[0].timer), &timer);
+            H5_timer_end (&(fstats->stats[0].timer), &timer);
             fstats->stats[0].total += MAX(*nbytes, new_nbytes);
-            if (0 == new_nbytes) fstats->stats[0].errors += *nbytes;
+            if (0 == new_nbytes)
+                fstats->stats[0].errors += *nbytes;
 #endif
-            if(0 == new_nbytes) {
+            if (0 == new_nbytes) {
                 if (0 == (pline->filter[idx].flags & H5Z_FLAG_OPTIONAL)) {
-                    if((cb_struct.func && (H5Z_CB_FAIL == cb_struct.func(pline->filter[idx].id, *buf, *nbytes, cb_struct.op_data))) || !cb_struct.func)
+                    if ((cb_struct.func && (H5Z_CB_FAIL == cb_struct.func (pline->filter[idx].id, *buf, *nbytes, cb_struct.op_data))) || !cb_struct.func)
                         HGOTO_ERROR(H5E_PLINE, H5E_WRITEERROR, FAIL, "filter returned failure")
 
                     *nbytes = *buf_size;
                 }
 
                 failed |= (unsigned)1 << idx;
-                H5E_clear_stack(NULL);
+                H5E_clear_stack (NULL);
             }
-            else {
+            else
                 *nbytes = new_nbytes;
-            }
         }
     }
 
@@ -1320,7 +1342,8 @@ done:
  *
  * Purpose:  Get pointer to filter info for pipeline
  *
- * Return:   Non-negative on success/Negative on failure
+ * Return:   Non-negative on success
+ *           Negative on failure
  *-------------------------------------------------------------------------
  */
 H5Z_filter_info_t *
@@ -1335,12 +1358,12 @@ H5Z_filter_info(const H5O_pline_t *pline, H5Z_filter_t filter)
     HDassert(filter >= 0 && filter <= H5Z_FILTER_MAX);
 
     /* Locate the filter in the pipeline */
-    for(idx = 0; idx < pline->nused; idx++)
-        if(pline->filter[idx].id == filter)
+    for (idx = 0; idx < pline->nused; idx++)
+        if (pline->filter[idx].id == filter)
             break;
 
     /* Check if the filter was not already in the pipeline */
-    if(idx >= pline->nused)
+    if (idx >= pline->nused)
         HGOTO_ERROR(H5E_PLINE, H5E_NOTFOUND, NULL, "filter not in pipeline")
 
     /* Set return value */
@@ -1365,8 +1388,8 @@ done:
 htri_t
 H5Z_filter_in_pline(const H5O_pline_t *pline, H5Z_filter_t filter)
 {
-    size_t      idx;                    /* Index of filter in pipeline */
-    htri_t      ret_value = TRUE;       /* Return value */
+    size_t    idx;                    /* Index of filter in pipeline */
+    htri_t    ret_value = TRUE;       /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
@@ -1374,12 +1397,12 @@ H5Z_filter_in_pline(const H5O_pline_t *pline, H5Z_filter_t filter)
     HDassert(filter >= 0 && filter <= H5Z_FILTER_MAX);
 
     /* Locate the filter in the pipeline */
-    for(idx = 0; idx < pline->nused; idx++)
-        if(pline->filter[idx].id == filter)
+    for (idx = 0; idx < pline->nused; idx++)
+        if (pline->filter[idx].id == filter)
             break;
 
     /* Check if the filter was not already in the pipeline */
-    if(idx >= pline->nused)
+    if (idx >= pline->nused)
         ret_value = FALSE;
 
 done:
@@ -1394,14 +1417,15 @@ done:
  * Purpose:  Verify that all the filters in a pipeline are currently
  *           available (i.e. registered)
  *
- * Return:   Non-negative (TRUE/FALSE) on success/Negative on failure
+ * Return:   Non-negative (TRUE/FALSE) on success
+ *           Negative on failure
  *-------------------------------------------------------------------------
  */
 htri_t
 H5Z_all_filters_avail(const H5O_pline_t *pline)
 {
-    size_t i,j;                 /* Local index variable */
-    htri_t ret_value=TRUE;      /* Return value */
+    size_t i, j;                  /* Local index variable */
+    htri_t ret_value = TRUE;      /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
@@ -1409,14 +1433,14 @@ H5Z_all_filters_avail(const H5O_pline_t *pline)
     HDassert(pline);
 
     /* Iterate through all the filters in pipeline */
-    for(i = 0; i < pline->nused; i++) {
+    for (i = 0; i < pline->nused; i++) {
         /* Look for each filter in the list of registered filters */
-        for(j = 0; j < H5Z_table_used_g; j++)
-            if(H5Z_table_g[j].id == pline->filter[i].id)
+        for (j = 0; j < H5Z_table_used_g; j++)
+            if (H5Z_table_g[j].id == pline->filter[i].id)
                 break;
 
         /* Check if we didn't find the filter */
-        if(j == H5Z_table_used_g)
+        if (j == H5Z_table_used_g)
             HGOTO_DONE(FALSE)
     } /* end for */
 
@@ -1432,7 +1456,8 @@ done:
  * Purpose:  Delete filter FILTER from pipeline PLINE;
  *           deletes all filters if FILTER is H5Z_FILTER_NONE
  *
- * Return:   Non-negative on success/Negative on failure
+ * Return:   Non-negative on success
+ *           Negative on failure
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -1447,57 +1472,57 @@ H5Z_delete(H5O_pline_t *pline, H5Z_filter_t filter)
     HDassert(filter >= 0 && filter <= H5Z_FILTER_MAX);
 
     /* if the pipeline has no filters, just return */
-    if(pline->nused == 0)
-        HGOTO_DONE(SUCCEED)
+    if (pline->nused == 0)
+        HGOTO_DONE (SUCCEED)
 
     /* Delete all filters */
-    if(H5Z_FILTER_ALL == filter) {
-        if(H5O_msg_reset(H5O_PLINE_ID, pline) < 0)
+    if (H5Z_FILTER_ALL == filter) {
+        if (H5O_msg_reset(H5O_PLINE_ID, pline) < 0)
             HGOTO_ERROR(H5E_PLINE, H5E_CANTFREE, FAIL, "can't release pipeline info")
-    } /* end if */
+    }
     /* Delete filter */
     else {
-        size_t idx;             /* Index of filter in pipeline */
-        hbool_t found = FALSE;  /* Indicate filter was found in pipeline */
+        size_t  idx;             /* Index of filter in pipeline */
+        hbool_t found = FALSE;   /* Indicate filter was found in pipeline */
 
         /* Locate the filter in the pipeline */
-        for(idx = 0; idx < pline->nused; idx++)
-            if(pline->filter[idx].id == filter) {
+        for (idx = 0; idx < pline->nused; idx++)
+            if (pline->filter[idx].id == filter) {
                 found = TRUE;
                 break;
-            } /* end if */
+            }
 
         /* filter was not found in the pipeline */
-        if(!found)
+        if (!found)
             HGOTO_ERROR(H5E_PLINE, H5E_NOTFOUND, FAIL, "filter not in pipeline")
 
         /* Free information for deleted filter */
-        if(pline->filter[idx].name && pline->filter[idx].name != pline->filter[idx]._name)
+        if (pline->filter[idx].name && pline->filter[idx].name != pline->filter[idx]._name)
             HDassert((HDstrlen(pline->filter[idx].name) + 1) > H5Z_COMMON_NAME_LEN);
-        if(pline->filter[idx].name != pline->filter[idx]._name)
+        if (pline->filter[idx].name != pline->filter[idx]._name)
             pline->filter[idx].name = (char *)H5MM_xfree(pline->filter[idx].name);
-        if(pline->filter[idx].cd_values && pline->filter[idx].cd_values != pline->filter[idx]._cd_values)
+        if (pline->filter[idx].cd_values && pline->filter[idx].cd_values != pline->filter[idx]._cd_values)
             HDassert(pline->filter[idx].cd_nelmts > H5Z_COMMON_CD_VALUES);
-        if(pline->filter[idx].cd_values != pline->filter[idx]._cd_values)
+        if (pline->filter[idx].cd_values != pline->filter[idx]._cd_values)
             pline->filter[idx].cd_values = (unsigned *)H5MM_xfree(pline->filter[idx].cd_values);
 
         /* Remove filter from pipeline array */
-        if((idx + 1) < pline->nused) {
+        if ((idx + 1) < pline->nused) {
             /* Copy filters down & fix up any client data value arrays using internal storage */
-            for(; (idx + 1) < pline->nused; idx++) {
+            for (; (idx + 1) < pline->nused; idx++) {
                 pline->filter[idx] = pline->filter[idx + 1];
-                if(pline->filter[idx].name && (HDstrlen(pline->filter[idx].name) + 1) <= H5Z_COMMON_NAME_LEN)
+                if (pline->filter[idx].name && (HDstrlen(pline->filter[idx].name) + 1) <= H5Z_COMMON_NAME_LEN)
                     pline->filter[idx].name = pline->filter[idx]._name;
-                if(pline->filter[idx].cd_nelmts <= H5Z_COMMON_CD_VALUES)
+                if (pline->filter[idx].cd_nelmts <= H5Z_COMMON_CD_VALUES)
                     pline->filter[idx].cd_values = pline->filter[idx]._cd_values;
-            } /* end for */
-        } /* end if */
+            }
+        }
 
         /* Decrement number of used filters */
         pline->nused--;
 
         /* Reset information for previous last filter in pipeline */
-        HDmemset(&pline->filter[pline->nused], 0, sizeof(H5Z_filter_info_t));
+        HDmemset (&pline->filter[pline->nused], 0, sizeof(H5Z_filter_info_t));
     } /* end else */
 
 done:
@@ -1510,6 +1535,9 @@ done:
  *
  * Purpose:  Gets information about a pipeline data filter and stores it
  *           in filter_config_flags.
+ *
+ * Return:   zero on success
+ *           negative on failure
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -1521,8 +1549,8 @@ H5Zget_filter_info(H5Z_filter_t filter, unsigned int *filter_config_flags)
     H5TRACE2("e", "Zf*Iu", filter, filter_config_flags);
 
     /* Get the filter info */
-    if(H5Z_get_filter_info(filter, filter_config_flags) < 0)
-        HGOTO_ERROR(H5E_PLINE, H5E_CANTGET, FAIL, "Filter info not retrieved")
+    if (H5Z_get_filter_info(filter, filter_config_flags) < 0)
+        HGOTO_ERROR (H5E_PLINE, H5E_CANTGET, FAIL, "Filter info not retrieved")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -1534,6 +1562,9 @@ done:
  *
  * Purpose:  Gets information about a pipeline data filter and stores it
  *           in filter_config_flags.
+ *
+ * Return:   zero on success
+ *           negative on failure
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -1545,16 +1576,16 @@ H5Z_get_filter_info(H5Z_filter_t filter, unsigned int *filter_config_flags)
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Look up the filter class info */
-    if(NULL == (fclass = H5Z_find(filter)))
+    if (NULL == (fclass = H5Z_find(filter)))
         HGOTO_ERROR(H5E_PLINE, H5E_BADVALUE, FAIL, "Filter not defined")
 
     /* Set the filter config flags for the application */
-    if(filter_config_flags != NULL) {
+    if (filter_config_flags != NULL) {
         *filter_config_flags = 0;
 
-        if(fclass->encoder_present)
+        if (fclass->encoder_present)
             *filter_config_flags |= H5Z_FILTER_CONFIG_ENCODE_ENABLED;
-        if(fclass->decoder_present)
+        if (fclass->decoder_present)
             *filter_config_flags |= H5Z_FILTER_CONFIG_DECODE_ENABLED;
     } /* end if */
 
diff --git a/src/H5Zpublic.h b/src/H5Zpublic.h
index f6b313e..fcb2d37 100644
--- a/src/H5Zpublic.h
+++ b/src/H5Zpublic.h
@@ -129,8 +129,8 @@ typedef H5Z_cb_return_t (*H5Z_filter_func_t)(H5Z_filter_t filter, void* buf,
 
 /* Structure for filter callback property */
 typedef struct H5Z_cb_t {
-    H5Z_filter_func_t func;
-    void*              op_data;
+    H5Z_filter_func_t   func;
+    void                *op_data;
 } H5Z_cb_t;
 
 #ifdef __cplusplus
@@ -206,14 +206,14 @@ typedef size_t (*H5Z_func_t)(unsigned int flags, size_t cd_nelmts,
  * contain a pointers to the filter function and timing statistics.
  */
 typedef struct H5Z_class2_t {
-    int version;                /* Version number of the H5Z_class_t struct */
-    H5Z_filter_t id;		/* Filter ID number			     */
-    unsigned encoder_present;   /* Does this filter have an encoder? */
-    unsigned decoder_present;   /* Does this filter have a decoder? */
-    const char	*name;		/* Comment for debugging		     */
-    H5Z_can_apply_func_t can_apply; /* The "can apply" callback for a filter */
-    H5Z_set_local_func_t set_local; /* The "set local" callback for a filter */
-    H5Z_func_t filter;		/* The actual filter function		     */
+    int version;                    /* Version number of the H5Z_class_t struct     */
+    H5Z_filter_t id;                /* Filter ID number                             */
+    unsigned encoder_present;       /* Does this filter have an encoder?            */
+    unsigned decoder_present;       /* Does this filter have a decoder?             */
+    const char	*name;              /* Comment for debugging                        */
+    H5Z_can_apply_func_t can_apply; /* The "can apply" callback for a filter        */
+    H5Z_set_local_func_t set_local; /* The "set local" callback for a filter        */
+    H5Z_func_t filter;              /* The actual filter function                   */
 } H5Z_class2_t;
 
 H5_DLL herr_t H5Zregister(const void *cls);
diff --git a/src/H5system.c b/src/H5system.c
index a1cdf19..a8726c2 100644
--- a/src/H5system.c
+++ b/src/H5system.c
@@ -977,7 +977,7 @@ Wround(double arg)
 float
 Wroundf(float arg)
 {
-    return arg < 0.0F ? HDceil(arg - 0.5F) : HDfloor(arg + 0.5F);
+    return (float)(arg < 0.0F ? HDceil(arg - 0.5F) : HDfloor(arg + 0.5F));
 }
 
 #endif /* H5_HAVE_WIN32_API */