HDFFV-10328 - remove plugin allocation changes

2 files changed, 355 insertions, 337 deletions

diff --git a/src/H5PLplugin_cache.c b/src/H5PLplugin_cache.c
index d826ba0..e483e01 100644
--- a/src/H5PLplugin_cache.c
+++ b/src/H5PLplugin_cache.c
@@ -283,11 +283,11 @@ H5PL__find_plugin_in_cache(const H5PL_search_params_t *search_params, hbool_t *f
 
             /* 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/H5Z.c b/src/H5Z.c
index 1d023b5..1f1a905 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,23 +86,23 @@ H5Z__init_package(void)
     FUNC_ENTER_PACKAGE
 
     /* Internal filters */
-    if(H5Z_register(H5Z_SHUFFLE) < 0)
-        HGOTO_ERROR(H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register shuffle filter")
-    if(H5Z_register(H5Z_FLETCHER32) < 0)
-        HGOTO_ERROR(H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register fletcher32 filter")
-    if(H5Z_register(H5Z_NBIT) < 0)
-        HGOTO_ERROR(H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register nbit filter")
-    if(H5Z_register(H5Z_SCALEOFFSET) < 0)
-        HGOTO_ERROR(H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register scaleoffset filter")
+    if (H5Z_register (H5Z_SHUFFLE) < 0)
+        HGOTO_ERROR (H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register shuffle filter")
+    if (H5Z_register (H5Z_FLETCHER32) < 0)
+        HGOTO_ERROR (H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register fletcher32 filter")
+    if (H5Z_register (H5Z_NBIT) < 0)
+        HGOTO_ERROR (H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register nbit filter")
+    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)
+    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)
+    if (H5Z_register (H5Z_SZIP) < 0)
         HGOTO_ERROR (H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register szip filter")
 #endif /* H5_HAVE_FILTER_SZIP */
 
@@ -211,8 +211,8 @@ 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);
@@ -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;
@@ -251,19 +251,19 @@ H5Zregister(const void *cls)
 
 #else /* H5_NO_DEPRECATED_SYMBOLS */
         /* Deprecated symbols not allowed, throw an error */
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid H5Z_class_t version number");
+        HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "invalid H5Z_class_t version number");
 #endif /* H5_NO_DEPRECATED_SYMBOLS */
     } /* end if */
 
-    if (cls_real->id<0 || cls_real->id>H5Z_FILTER_MAX)
+    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)
+    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")
+    if (cls_real->filter == NULL)
+        HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no filter function specified")
 
     /* Do it */
-    if (H5Z_register (cls_real)<0)
+    if (H5Z_register (cls_real) < 0)
         HGOTO_ERROR (H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register filter")
 
 done:
@@ -277,39 +277,40 @@ done:
  * Purpose:  Same as the public version except this one allows filters
  *           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)
 
-    HDassert(cls);
-    HDassert(cls->id >= 0 && cls->id <= H5Z_FILTER_MAX);
+    HDassert (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)
-                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to extend filter 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)
-                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "unable to extend filter statistics 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 */
             H5Z_table_alloc_g = n;
@@ -317,15 +318,15 @@ H5Z_register (const H5Z_class2_t *cls)
 
         /* Initialize */
         i = H5Z_table_used_g++;
-        HDmemcpy(H5Z_table_g+i, cls, sizeof(H5Z_class2_t));
+        HDmemcpy (H5Z_table_g+i, cls, sizeof(H5Z_class2_t));
 #ifdef H5Z_DEBUG
-        HDmemset(H5Z_stat_table_g+i, 0, sizeof(H5Z_stats_t));
+        HDmemset (H5Z_stat_table_g+i, 0, sizeof(H5Z_stats_t));
 #endif /* H5Z_DEBUG */
     } /* end if */
     /* Filter already registered */
     else {
         /* Replace old contents */
-        HDmemcpy(H5Z_table_g+i, cls, sizeof(H5Z_class2_t));
+        HDmemcpy (H5Z_table_g+i, cls, sizeof(H5Z_class2_t));
     } /* end else */
 
 done:
@@ -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,12 +449,12 @@ 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)))
-        HGOTO_ERROR(H5E_PLINE, H5E_BADATOM, FAIL, "can't find object for ID")
+    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)
-        HGOTO_ERROR(H5E_PLINE, H5E_CANTGET, FAIL, "can't check filter in pipeline")
+    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:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -483,25 +486,25 @@ 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)
-        HGOTO_ERROR(H5E_PLINE, H5E_CANTGET, FAIL, "can't get group creation property list")
+    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)
-        HGOTO_ERROR(H5E_PLINE, H5E_CANTGET, FAIL, "can't check filter in pipeline")
+    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)
-            HDONE_ERROR(H5E_PLINE, H5E_CANTDEC, FAIL, "can't release plist")
+    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)
 } /* end H5Z__check_unregister_group_cb() */
@@ -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
@@ -529,28 +532,28 @@ H5Z__check_unregister_dset_cb(void *obj_ptr, hid_t H5_ATTR_UNUSED obj_id, void *
 
     FUNC_ENTER_STATIC
 
-    HDassert(obj_ptr);
+    HDassert (obj_ptr);
 
     /* Get the dataset creation property */
-    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")
+    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)
-        HGOTO_ERROR(H5E_PLINE, H5E_CANTGET, FAIL, "can't check filter in pipeline")
+    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)
-            HDONE_ERROR(H5E_PLINE, H5E_CANTDEC, FAIL, "can't release plist")
+    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)
 } /* end H5Z__check_unregister_dset_cb() */
@@ -569,17 +572,17 @@ 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
 
-    HDassert(obj_ptr);
+    HDassert (obj_ptr);
 
     /* 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)
-            HGOTO_ERROR(H5E_PLINE, H5E_CANTFLUSH, FAIL, "unable to flush file hierarchy")
+    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 */
 
 done:
@@ -598,17 +601,17 @@ 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)
+    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)
-        HGOTO_ERROR(H5E_PLINE, H5E_NOTFOUND, FAIL, "unable to check the availability of the filter")
+    if ((ret_value = H5Z_filter_avail(id)) < 0)
+        HGOTO_ERROR (H5E_PLINE, H5E_NOTFOUND, FAIL, "unable to check the availability of the filter")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -626,21 +629,21 @@ 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 */
+    size_t    i;                   /* Local index variable */
+    H5Z_class2_t *filter_info;
+    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)
-            HGOTO_DONE(TRUE)
-
-    if(NULL != (filter_info = (const H5Z_class2_t *)H5PL_load(H5PL_TYPE_FILTER, (int)id))) {
-        if(H5Z_register(filter_info) < 0)
-            HGOTO_ERROR(H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register loaded filter")
-        HGOTO_DONE(TRUE)
+    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)
+            HGOTO_ERROR (H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register loaded filter")
+        HGOTO_DONE (TRUE)
     }
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -666,59 +669,59 @@ 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")
+                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)
-                        HGOTO_ERROR(H5E_PLINE, H5E_NOENCODER, FAIL, "Filter present but encoding is disabled.");
+                    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")
+                            HGOTO_ERROR (H5E_PLINE, H5E_SETLOCAL, FAIL, "error during user callback")
                     } /* end if */
                     break;
 
                 default:
-                    HDassert("invalid prelude type" && 0);
+                    HDassert ("invalid prelude type" && 0);
             } /* end switch */
         } /* end else */
     } /* end for */
@@ -745,62 +748,62 @@ 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 */
+    herr_t  ret_value = SUCCEED;      /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
-    HDassert(H5I_GENPROP_LST == H5I_get_type(dcpl_id));
-    HDassert(H5I_DATATYPE == H5I_get_type(type_id));
+    HDassert (H5I_GENPROP_LST == H5I_get_type(dcpl_id));
+    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 */
+        H5O_layout_t        dcpl_layout;    /* Dataset's layout information */
 
         /* 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++)
+                /* 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")
+                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) {
-                    (void)H5S_close(space);
-                    HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register dataspace ID")
+                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 */
 
                 /* 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")
+                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 */
 
 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")
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -814,7 +817,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,8 +833,8 @@ 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)
-        HGOTO_ERROR(H5E_PLINE, H5E_CANAPPLY, FAIL, "unable to apply filter")
+    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:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -844,7 +848,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,8 +864,8 @@ 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)
-        HGOTO_ERROR(H5E_PLINE, H5E_SETLOCAL, FAIL, "local filter parameters not set")
+    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:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -874,7 +879,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
@@ -884,11 +890,11 @@ H5Z_can_apply_direct(const H5O_pline_t *pline)
 
     FUNC_ENTER_NOAPI(FAIL)
 
-    HDassert(pline->nused > 0);
+    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)
-        HGOTO_ERROR(H5E_PLINE, H5E_CANAPPLY, FAIL, "unable to apply filter")
+    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:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -902,7 +908,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
@@ -916,11 +923,11 @@ H5Z_set_local_direct(const H5O_pline_t *pline)
 
     FUNC_ENTER_NOAPI(FAIL)
 
-    HDassert(pline->nused > 0);
+    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)
-        HGOTO_ERROR(H5E_PLINE, H5E_SETLOCAL, FAIL, "local filter parameters not set")
+    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:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -930,58 +937,59 @@ 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)
 
-    HDassert(pline);
-    HDassert(filter >= 0 && filter <= H5Z_FILTER_MAX);
-    HDassert(0 == (flags & ~((unsigned)H5Z_FLAG_DEFMASK)));
-    HDassert(0 == cd_nelmts || cd_values);
+    HDassert (pline);
+    HDassert (filter >= 0 && filter <= H5Z_FILTER_MAX);
+    HDassert (0 == (flags & ~((unsigned)H5Z_FLAG_DEFMASK)));
+    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)
-        HGOTO_ERROR(H5E_PLINE, H5E_NOTFOUND, FAIL, "filter not in pipeline")
+    if (idx > pline->nused)
+        HGOTO_ERROR (H5E_PLINE, H5E_NOTFOUND, FAIL, "filter not in pipeline")
 
     /* Change parameters for filter */
     pline->filter[idx].flags = 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)
-                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for filter parameters")
+            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,36 +1004,37 @@ 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)
 
-    HDassert(pline);
-    HDassert(filter >= 0 && filter <= H5Z_FILTER_MAX);
-    HDassert(0 == (flags & ~((unsigned)H5Z_FLAG_DEFMASK)));
-    HDassert(0 == cd_nelmts || cd_values);
+    HDassert (pline);
+    HDassert (filter >= 0 && filter <= H5Z_FILTER_MAX);
+    HDassert (0 == (flags & ~((unsigned)H5Z_FLAG_DEFMASK)));
+    HDassert (0 == cd_nelmts || cd_values);
 
     /*
      * 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,14 +1045,14 @@ 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.
@@ -1061,22 +1070,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)
-                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for filter")
+            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 +1104,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 +1116,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 +1131,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)
-        HGOTO_ERROR(H5E_PLINE, H5E_NOTFOUND, NULL, "required filter %d is not registered", id)
+    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 +1158,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,51 +1184,51 @@ 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(buf && *buf);
-    HDassert(!pline || pline->nused < H5Z_MAX_NFILTERS);
+    HDassert (0 == (flags & ~((unsigned)H5Z_FLAG_INVMASK)));
+    HDassert (filter_mask);
+    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;
-                const H5Z_class2_t    *filter_info;
+                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)))) {
+                if (NULL != (filter_info = (const H5Z_class2_t *)H5PL_load(H5PL_TYPE_FILTER, (int)(pline->filter[idx].id)))) {
                     /* Register the filter we loaded */
-                    if(H5Z_register(filter_info) < 0)
-                        HGOTO_ERROR(H5E_PLINE, H5E_CANTINIT, FAIL, "unable to register filter")
+                    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
@@ -1227,8 +1237,8 @@ H5Z_pipeline(const H5O_pline_t *pline, unsigned flags,
                 /* Check for 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")
@@ -1238,26 +1248,26 @@ H5Z_pipeline(const H5O_pline_t *pline, unsigned flags,
             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;
 #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)
-                    HGOTO_ERROR(H5E_PLINE, H5E_READERROR, FAIL, "filter returned failure during read")
+            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 {
                 *nbytes = new_nbytes;
@@ -1276,35 +1286,34 @@ 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;
 #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)
-                        HGOTO_ERROR(H5E_PLINE, H5E_WRITEERROR, FAIL, "filter returned failure")
+                    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 +1329,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 *
@@ -1331,17 +1341,17 @@ H5Z_filter_info(const H5O_pline_t *pline, H5Z_filter_t filter)
 
     FUNC_ENTER_NOAPI(NULL)
 
-    HDassert(pline);
-    HDassert(filter >= 0 && filter <= H5Z_FILTER_MAX);
+    HDassert (pline);
+    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)
-        HGOTO_ERROR(H5E_PLINE, H5E_NOTFOUND, NULL, "filter not in pipeline")
+    if (idx >= pline->nused)
+        HGOTO_ERROR (H5E_PLINE, H5E_NOTFOUND, NULL, "filter not in pipeline")
 
     /* Set return value */
     ret_value = &pline->filter[idx];
@@ -1365,21 +1375,21 @@ 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)
 
-    HDassert(pline);
-    HDassert(filter >= 0 && filter <= H5Z_FILTER_MAX);
+    HDassert (pline);
+    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,30 +1404,31 @@ 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)
 
     /* Check args */
-    HDassert(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)
-            HGOTO_DONE(FALSE)
+        if (j == H5Z_table_used_g)
+            HGOTO_DONE (FALSE)
     } /* end for */
 
 done:
@@ -1432,7 +1443,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
@@ -1443,52 +1455,52 @@ H5Z_delete(H5O_pline_t *pline, H5Z_filter_t filter)
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Check args */
-    HDassert(pline);
-    HDassert(filter >= 0 && filter <= H5Z_FILTER_MAX);
+    HDassert (pline);
+    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)
-            HGOTO_ERROR(H5E_PLINE, H5E_NOTFOUND, FAIL, "filter not in pipeline")
+        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)
-            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)
+            HDassert ((HDstrlen(pline->filter[idx].name) + 1) > H5Z_COMMON_NAME_LEN);
+        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)
-            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)
+            HDassert (pline->filter[idx].cd_nelmts > H5Z_COMMON_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 */
@@ -1497,7 +1509,7 @@ H5Z_delete(H5O_pline_t *pline, H5Z_filter_t filter)
         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 +1522,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 +1536,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 +1549,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 +1563,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)))
-        HGOTO_ERROR(H5E_PLINE, H5E_BADVALUE, FAIL, "Filter not defined")
+    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 */