Tab to space conversions.

Re-applied tab to space conversions accidentally reverted in the
commit of the metadata cache skip list optimization, and performed
some additional tab to space conversions in passing.

Tested parallel / debug on Jelly.

7 files changed, 463 insertions, 465 deletions

diff --git a/src/H5AC.c b/src/H5AC.c
index 52f45c3..964ed4d 100644
--- a/src/H5AC.c
+++ b/src/H5AC.c
@@ -136,14 +136,14 @@ static const H5AC_class_t *const H5AC_class_s[] = {
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5AC_init
+ * Function:    H5AC_init
  *
  * Purpose:     Initialize the interface from some other layer.
  *
- * Return:	Success:	non-negative
- *		Failure:	negative
+ * Return:      Success:        non-negative
+ *              Failure:        negative
  *
- * Programmer:	Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Saturday, January 18, 2003
  *
  *-------------------------------------------------------------------------
@@ -162,13 +162,13 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5AC__init_package
+ * Function:    H5AC__init_package
  *
- * Purpose:	Initialize interface-specific information
+ * Purpose:     Initialize interface-specific information
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:	Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Thursday, July 18, 2002
  *
  *-------------------------------------------------------------------------
@@ -198,15 +198,15 @@ H5AC__init_package(void)
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5AC_term_package
+ * Function:    H5AC_term_package
  *
- * Purpose:	Terminate this interface.
+ * Purpose:     Terminate this interface.
  *
- * Return:	Success:	Positive if anything was done that might
- *				affect other interfaces; zero otherwise.
- * 		Failure:	Negative.
+ * Return:      Success:        Positive if anything was done that might
+ *                              affect other interfaces; zero otherwise.
+ *              Failure:        Negative.
  *
- * Programmer:	Quincey Koziol
+ * Programmer:  Quincey Koziol
  *              Thursday, July 18, 2002
  *
  *-------------------------------------------------------------------------
@@ -284,7 +284,7 @@ herr_t
 H5AC_create(const H5F_t *f, H5AC_cache_config_t *config_ptr, H5AC_cache_image_config_t * image_config_ptr)
 {
 #ifdef H5_HAVE_PARALLEL
-    char 	 prefix[H5C__PREFIX_LEN] = "";
+    char         prefix[H5C__PREFIX_LEN] = "";
     H5AC_aux_t * aux_ptr = NULL;
 #endif /* H5_HAVE_PARALLEL */
     struct H5C_cache_image_ctl_t int_ci_config = H5C__DEFAULT_CACHE_IMAGE_CTL;
@@ -309,9 +309,9 @@ H5AC_create(const H5F_t *f, H5AC_cache_config_t *config_ptr, H5AC_cache_image_co
 
 #ifdef H5_HAVE_PARALLEL
     if(H5F_HAS_FEATURE(f, H5FD_FEAT_HAS_MPI)) {
-        MPI_Comm	 mpi_comm;
-        int		 mpi_rank;
-        int	 	 mpi_size;
+        MPI_Comm    mpi_comm;
+        int         mpi_rank;
+        int         mpi_size;
 
         if(MPI_COMM_NULL == (mpi_comm = H5F_mpi_get_comm(f)))
             HGOTO_ERROR(H5E_VFL, H5E_CANTGET, FAIL, "can't get MPI communicator")
@@ -400,7 +400,7 @@ H5AC_create(const H5F_t *f, H5AC_cache_config_t *config_ptr, H5AC_cache_image_co
 #endif /* H5_HAVE_PARALLEL */
 
     if(NULL == f->shared->cache)
-	HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "memory allocation failed")
+        HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, FAIL, "memory allocation failed")
 
 #ifdef H5_HAVE_PARALLEL
     if(aux_ptr != NULL)
@@ -626,12 +626,12 @@ done:
  * Function:    H5AC_evict
  *
  * Purpose:     Evict all entries except the pinned entries
- *		in the cache.
+ *              in the cache.
  *
  * Return:      Non-negative on success/Negative on failure
  *
  * Programmer:  Vailin Choi
- *		Dec 2013
+ *              Dec 2013
  *
  *-------------------------------------------------------------------------
  */
@@ -665,9 +665,9 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5AC_expunge_entry
  *
- * Purpose:	Expunge the target entry from the cache without writing it
- * 		to disk even if it is dirty.  The entry must not be either
- * 		pinned or protected.
+ * Purpose:     Expunge the target entry from the cache without writing it
+ *              to disk even if it is dirty.  The entry must not be either
+ *              pinned or protected.
  *
  * Return:      Non-negative on success/Negative on failure
  *
@@ -708,13 +708,13 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5AC_flush
  *
- * Purpose:	Flush (and possibly destroy) the metadata cache associated
- *		with the specified file.
+ * Purpose:     Flush (and possibly destroy) the metadata cache associated
+ *              with the specified file.
  *
- *		If the cache contains protected entries, the function will
- *		fail, as protected entries cannot be flushed.  However
- *		all unprotected entries should be flushed before the
- *		function returns failure.
+ *              If the cache contains protected entries, the function will
+ *              fail, as protected entries cannot be flushed.  However
+ *              all unprotected entries should be flushed before the
+ *              function returns failure.
  *
  * Return:      Non-negative on success/Negative on failure if there was a
  *              request to flush all items and something was protected.
@@ -766,15 +766,15 @@ done:
  * Function:    H5AC_get_entry_status
  *
  * Purpose:     Given a file address, determine whether the metadata
- * 		cache contains an entry at that location.  If it does,
- * 		also determine whether the entry is dirty, protected,
- * 		pinned, etc. and return that information to the caller
- * 		in *status.
+ *              cache contains an entry at that location.  If it does,
+ *              also determine whether the entry is dirty, protected,
+ *              pinned, etc. and return that information to the caller
+ *              in *status.
  *
- * 		If the specified entry doesn't exist, set *status_ptr
- * 		to zero.
+ *              If the specified entry doesn't exist, set *status_ptr
+ *              to zero.
  *
- * 		On error, the value of *status is undefined.
+ *              On error, the value of *status is undefined.
  *
  * Return:      Non-negative on success/Negative on failure
  *
@@ -786,14 +786,14 @@ done:
 herr_t
 H5AC_get_entry_status(const H5F_t *f, haddr_t addr, unsigned *status)
 {
-    hbool_t	in_cache;               /* Entry @ addr is in the cache */
-    hbool_t	is_dirty;               /* Entry @ addr is in the cache and dirty */
-    hbool_t	is_protected;           /* Entry @ addr is in the cache and protected */
-    hbool_t	is_pinned;              /* Entry @ addr is in the cache and pinned */
-    hbool_t	is_corked;
-    hbool_t	is_flush_dep_child;     /* Entry @ addr is in the cache and is a flush dependency child */
-    hbool_t	is_flush_dep_parent;    /* Entry @ addr is in the cache and is a flush dependency parent */
-    hbool_t	image_is_up_to_date;    /* Entry @ addr is in the cache and has an up to date image */
+    hbool_t     in_cache;               /* Entry @ addr is in the cache */
+    hbool_t     is_dirty;               /* Entry @ addr is in the cache and dirty */
+    hbool_t     is_protected;           /* Entry @ addr is in the cache and protected */
+    hbool_t     is_pinned;              /* Entry @ addr is in the cache and pinned */
+    hbool_t     is_corked;
+    hbool_t     is_flush_dep_child;     /* Entry @ addr is in the cache and is a flush dependency child */
+    hbool_t     is_flush_dep_parent;    /* Entry @ addr is in the cache and is a flush dependency parent */
+    hbool_t     image_is_up_to_date;    /* Entry @ addr is in the cache and has an up to date image */
     herr_t      ret_value = SUCCEED;      /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
@@ -806,21 +806,21 @@ H5AC_get_entry_status(const H5F_t *f, haddr_t addr, unsigned *status)
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5C_get_entry_status() failed")
 
     if(in_cache) {
-	*status |= H5AC_ES__IN_CACHE;
-	if(is_dirty)
-	    *status |= H5AC_ES__IS_DIRTY;
-	if(is_protected)
-	    *status |= H5AC_ES__IS_PROTECTED;
-	if(is_pinned)
-	    *status |= H5AC_ES__IS_PINNED;
-	if(is_corked)
-	    *status |= H5AC_ES__IS_CORKED;
-	if(is_flush_dep_parent)
-	    *status |= H5AC_ES__IS_FLUSH_DEP_PARENT;
-	if(is_flush_dep_child)
-	    *status |= H5AC_ES__IS_FLUSH_DEP_CHILD;
-	if(image_is_up_to_date)
-	    *status |= H5AC_ES__IMAGE_IS_UP_TO_DATE;
+        *status |= H5AC_ES__IN_CACHE;
+        if(is_dirty)
+            *status |= H5AC_ES__IS_DIRTY;
+        if(is_protected)
+            *status |= H5AC_ES__IS_PROTECTED;
+        if(is_pinned)
+            *status |= H5AC_ES__IS_PINNED;
+        if(is_corked)
+            *status |= H5AC_ES__IS_CORKED;
+        if(is_flush_dep_parent)
+            *status |= H5AC_ES__IS_FLUSH_DEP_PARENT;
+        if(is_flush_dep_child)
+            *status |= H5AC_ES__IS_FLUSH_DEP_CHILD;
+        if(image_is_up_to_date)
+            *status |= H5AC_ES__IMAGE_IS_UP_TO_DATE;
     } /* end if */
     else
         *status = 0;
@@ -940,8 +940,8 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5AC_mark_entry_dirty
  *
- * Purpose:	Mark a pinned or protected entry as dirty.  The target
- * 		entry MUST be either pinned, protected, or both.
+ * Purpose:     Mark a pinned or protected entry as dirty.  The target
+ *              entry MUST be either pinned, protected, or both.
  *
  * Return:      Non-negative on success/Negative on failure
  *
@@ -995,8 +995,8 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5AC_mark_entry_clean
  *
- * Purpose:	Mark a pinned entry as clean.  The target
- * 		entry MUST be pinned.
+ * Purpose:     Mark a pinned entry as clean.  The target
+ *              entry MUST be pinned.
  *
  * Return:      Non-negative on success/Negative on failure
  *
@@ -1049,8 +1049,8 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5AC_mark_entry_unserialized
  *
- * Purpose:	Mark a pinned or protected entry as unserialized.  The target
- * 		entry MUST be either pinned, protected, or both.
+ * Purpose:     Mark a pinned or protected entry as unserialized.  The target
+ *              entry MUST be either pinned, protected, or both.
  *
  * Return:      Non-negative on success/Negative on failure
  *
@@ -1092,8 +1092,8 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5AC_mark_entry_serialized
  *
- * Purpose:	Mark a pinned entry as serialized.  The target
- * 		entry MUST be pinned.
+ * Purpose:     Mark a pinned entry as serialized.  The target
+ *              entry MUST be pinned.
  *
  * Return:      Non-negative on success/Negative on failure
  *
@@ -1193,7 +1193,7 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5AC_pin_protected_entry()
  *
- * Purpose:	Pin a protected cache entry.  The entry must be protected
+ * Purpose:     Pin a protected cache entry.  The entry must be protected
  *              at the time of call, and must be unpinned.
  *
  * Return:      Non-negative on success/Negative on failure
@@ -1378,7 +1378,7 @@ done:
  *
  * Function:    H5AC_create_flush_dependency()
  *
- * Purpose:	Create a flush dependency between two entries in the metadata
+ * Purpose:     Create a flush dependency between two entries in the metadata
  *              cache.
  *
  * Return:      Non-negative on success/Negative on failure
@@ -1424,16 +1424,16 @@ done:
  * Function:    H5AC_protect
  *
  * Purpose:     If the target entry is not in the cache, load it.  If
- *		necessary, attempt to evict one or more entries to keep
- *		the cache within its maximum size.
+ *              necessary, attempt to evict one or more entries to keep
+ *              the cache within its maximum size.
  *
- *		Mark the target entry as protected, and return its address
- *		to the caller.  The caller must call H5AC_unprotect() when
- *		finished with the entry.
+ *              Mark the target entry as protected, and return its address
+ *              to the caller.  The caller must call H5AC_unprotect() when
+ *              finished with the entry.
  *
- *		While it is protected, the entry may not be either evicted
- *		or flushed -- nor may it be accessed by another call to
- *		H5AC_protect.  Any attempt to do so will result in a failure.
+ *              While it is protected, the entry may not be either evicted
+ *              or flushed -- nor may it be accessed by another call to
+ *              H5AC_protect.  Any attempt to do so will result in a failure.
  *
  * Return:      Success:        Ptr to the object.
  *              Failure:        NULL
@@ -1475,7 +1475,7 @@ H5AC_protect(H5F_t *f, const H5AC_class_t *type, haddr_t addr, void *udata,
 
     /* Check for invalid access request */
     if((0 == (H5F_INTENT(f) & H5F_ACC_RDWR)) && (0 == (flags & H5C__READ_ONLY_FLAG)))
-	HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, NULL, "no write intent on file")
+        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, NULL, "no write intent on file")
 
 #if H5AC_DO_TAGGING_SANITY_CHECKS
     if(!H5C_get_ignore_tags(f->shared->cache) && H5AC__verify_tag(type) < 0)
@@ -1505,7 +1505,7 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5AC_resize_entry
  *
- * Purpose:	Resize a pinned or protected entry.
+ * Purpose:     Resize a pinned or protected entry.
  *
  * Return:      Non-negative on success/Negative on failure
  *
@@ -1559,8 +1559,8 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5AC_unpin_entry()
  *
- * Purpose:	Unpin a cache entry.  The entry must be unprotected at
- * 		the time of call, and must be pinned.
+ * Purpose:     Unpin a cache entry.  The entry must be unprotected at
+ *              the time of call, and must be pinned.
  *
  * Return:      Non-negative on success/Negative on failure
  *
@@ -1603,7 +1603,7 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5AC_destroy_flush_dependency()
  *
- * Purpose:	Destroy a flush dependency between two entries.
+ * Purpose:     Destroy a flush dependency between two entries.
  *
  * Return:      Non-negative on success/Negative on failure
  *
@@ -1647,27 +1647,27 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5AC_unprotect
  *
- * Purpose:	Undo an H5AC_protect() call -- specifically, mark the
- *		entry as unprotected, remove it from the protected list,
- *		and give it back to the replacement policy.
+ * Purpose:     Undo an H5AC_protect() call -- specifically, mark the
+ *              entry as unprotected, remove it from the protected list,
+ *              and give it back to the replacement policy.
  *
- *		The TYPE and ADDR arguments must be the same as those in
- *		the corresponding call to H5AC_protect() and the THING
- *		argument must be the value returned by that call to
- *		H5AC_protect().
+ *              The TYPE and ADDR arguments must be the same as those in
+ *              the corresponding call to H5AC_protect() and the THING
+ *              argument must be the value returned by that call to
+ *              H5AC_protect().
  *
- *		If the deleted flag is TRUE, simply remove the target entry
- *		from the cache, clear it, and free it without writing it to
- *		disk.
+ *              If the deleted flag is TRUE, simply remove the target entry
+ *              from the cache, clear it, and free it without writing it to
+ *              disk.
  *
- *		This version of the function is a complete re-write to
- *		use the new metadata cache.  While there isn't all that
- *		much difference between the old and new Purpose sections,
- *		the original version is given below.
+ *              This version of the function is a complete re-write to
+ *              use the new metadata cache.  While there isn't all that
+ *              much difference between the old and new Purpose sections,
+ *              the original version is given below.
  *
- *		Original purpose section:
+ *              Original purpose section:
  *
- *		This function should be called to undo the effect of
+ *              This function should be called to undo the effect of
  *              H5AC_protect().  The TYPE and ADDR arguments should be the
  *              same as the corresponding call to H5AC_protect() and the
  *              THING argument should be the value returned by H5AC_protect().
@@ -1686,8 +1686,8 @@ herr_t
 H5AC_unprotect(H5F_t *f, const H5AC_class_t *type, haddr_t addr, void *thing,
     unsigned flags)
 {
-    hbool_t		dirtied;
-    hbool_t		deleted;
+    hbool_t             dirtied;
+    hbool_t             deleted;
 #ifdef H5_HAVE_PARALLEL
     H5AC_aux_t        * aux_ptr = NULL;
 #endif /* H5_HAVE_PARALLEL */
@@ -1708,14 +1708,14 @@ H5AC_unprotect(H5F_t *f, const H5AC_class_t *type, haddr_t addr, void *thing,
     HDassert( ((H5AC_info_t *)thing)->type == type );
 
     dirtied = (hbool_t)(((flags & H5AC__DIRTIED_FLAG) == H5AC__DIRTIED_FLAG) ||
-		(((H5AC_info_t *)thing)->dirtied));
+                (((H5AC_info_t *)thing)->dirtied));
     deleted = (hbool_t)((flags & H5C__DELETED_FLAG) == H5C__DELETED_FLAG);
 
     /* Check if the size changed out from underneath us, if we're not deleting
      *  the entry.
      */
     if(dirtied && !deleted) {
-        size_t		curr_size = 0;
+        size_t          curr_size = 0;
 
         if((type->image_len)(thing, &curr_size) < 0)
             HGOTO_ERROR(H5E_CACHE, H5E_CANTGETSIZE, FAIL, "Can't get size of thing")
@@ -1802,7 +1802,7 @@ H5AC_get_cache_auto_resize_config(const H5AC_t *cache_ptr,
     if(internal_config.rpt_fcn == NULL)
         config_ptr->rpt_fcn_enabled = FALSE;
     else
-	config_ptr->rpt_fcn_enabled = TRUE;
+        config_ptr->rpt_fcn_enabled = TRUE;
     config_ptr->open_trace_file        = FALSE;
     config_ptr->close_trace_file       = FALSE;
     config_ptr->trace_file_name[0]     = '\0';
@@ -1835,12 +1835,12 @@ H5AC_get_cache_auto_resize_config(const H5AC_t *cache_ptr,
 
     if(NULL != (aux_ptr = (H5AC_aux_t *)H5C_get_aux_ptr(cache_ptr))) {
         config_ptr->dirty_bytes_threshold = aux_ptr->dirty_bytes_threshold;
-	config_ptr->metadata_write_strategy = aux_ptr->metadata_write_strategy;
+        config_ptr->metadata_write_strategy = aux_ptr->metadata_write_strategy;
     } /* end if */
     else {
 #endif /* H5_HAVE_PARALLEL */
         config_ptr->dirty_bytes_threshold = H5AC__DEFAULT_DIRTY_BYTES_THRESHOLD;
-	config_ptr->metadata_write_strategy = H5AC__DEFAULT_METADATA_WRITE_STRATEGY;
+        config_ptr->metadata_write_strategy = H5AC__DEFAULT_METADATA_WRITE_STRATEGY;
 #ifdef H5_HAVE_PARALLEL
     } /* end else */
 }
@@ -1977,7 +1977,7 @@ herr_t
 H5AC_set_cache_auto_resize_config(H5AC_t *cache_ptr, H5AC_cache_config_t *config_ptr)
 {
     H5C_auto_size_ctl_t internal_config;
-    herr_t  ret_value = SUCCEED;      	/* Return value */
+    herr_t  ret_value = SUCCEED;        /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
@@ -2057,16 +2057,16 @@ done:
  * Function:    H5AC_validate_config()
  *
  * Purpose:     Run a sanity check on the contents of the supplied
- *		instance of H5AC_cache_config_t.
+ *              instance of H5AC_cache_config_t.
  *
  *              Do nothing and return SUCCEED if no errors are detected,
  *              and flag an error and return FAIL otherwise.
  *
- *		At present, this function operates by packing the data
- *		from the instance of H5AC_cache_config_t into an instance
- *		of H5C_auto_size_ctl_t, and then calling
- *		H5C_validate_resize_config().  As H5AC_cache_config_t and
- *		H5C_auto_size_ctl_t diverge, we may have to change this.
+ *              At present, this function operates by packing the data
+ *              from the instance of H5AC_cache_config_t into an instance
+ *              of H5C_auto_size_ctl_t, and then calling
+ *              H5C_validate_resize_config().  As H5AC_cache_config_t and
+ *              H5C_auto_size_ctl_t diverge, we may have to change this.
  *
  * Return:      Non-negative on success/Negative on failure
  *
@@ -2091,7 +2091,7 @@ H5AC_validate_config(H5AC_cache_config_t *config_ptr)
 
     /* don't bother to test trace_file_name unless open_trace_file is TRUE */
     if(config_ptr->open_trace_file) {
-        size_t	        name_len;
+        size_t           name_len;
 
         /* Can't really test the trace_file_name field without trying to
          * open the file, so we will content ourselves with a couple of
@@ -2134,17 +2134,17 @@ done:
  * Function:    H5AC_validate_cache_image_config()
  *
  * Purpose:     Run a sanity check on the contents of the supplied
- *		instance of H5AC_cache_image_config_t.
+ *              instance of H5AC_cache_image_config_t.
  *
  *              Do nothing and return SUCCEED if no errors are detected,
  *              and flag an error and return FAIL otherwise.
  *
- *		At present, this function operates by packing the data
- *		from the instance of H5AC_cache_image_config_t into an
- *		instance of H5C_cache_image_ctl_t, and then calling
- *		H5C_validate_cache_image_config().  If and when
+ *              At present, this function operates by packing the data
+ *              from the instance of H5AC_cache_image_config_t into an
+ *              instance of H5C_cache_image_ctl_t, and then calling
+ *              H5C_validate_cache_image_config().  If and when
  *              H5AC_cache_image_config_t and H5C_cache_image_ctl_t
- *		diverge, we may have to change this.
+ *              diverge, we may have to change this.
  *
  * Return:      Non-negative on success/Negative on failure
  *
@@ -2190,13 +2190,13 @@ done:
  * Function:    H5AC__check_if_write_permitted
  *
  * Purpose:     Determine if a write is permitted under the current
- *		circumstances, and set *write_permitted_ptr accordingly.
- *		As a general rule it is, but when we are running in parallel
- *		mode with collective I/O, we must ensure that a read cannot
- *		cause a write.
+ *              circumstances, and set *write_permitted_ptr accordingly.
+ *              As a general rule it is, but when we are running in parallel
+ *              mode with collective I/O, we must ensure that a read cannot
+ *              cause a write.
  *
- *		In the event of failure, the value of *write_permitted_ptr
- *		is undefined.
+ *              In the event of failure, the value of *write_permitted_ptr
+ *              is undefined.
  *
  * Return:      Non-negative on success/Negative on failure.
  *
@@ -2212,9 +2212,9 @@ H5_ATTR_UNUSED
     *f, hbool_t *write_permitted_ptr)
 {
 #ifdef H5_HAVE_PARALLEL
-    H5AC_aux_t *	aux_ptr = NULL;
+    H5AC_aux_t *        aux_ptr = NULL;
 #endif /* H5_HAVE_PARALLEL */
-    hbool_t		write_permitted = TRUE;
+    hbool_t             write_permitted = TRUE;
 
     FUNC_ENTER_STATIC_NOERR
 
@@ -2228,9 +2228,9 @@ H5_ATTR_UNUSED
         HDassert(aux_ptr->magic == H5AC__H5AC_AUX_T_MAGIC);
 
         if((aux_ptr->mpi_rank == 0) || (aux_ptr->metadata_write_strategy == H5AC_METADATA_WRITE_STRATEGY__DISTRIBUTED))
-	    write_permitted = aux_ptr->write_permitted;
+            write_permitted = aux_ptr->write_permitted;
         else
-	    write_permitted = FALSE;
+            write_permitted = FALSE;
     } /* end if */
 #endif /* H5_HAVE_PARALLEL */
 
@@ -2244,12 +2244,12 @@ H5_ATTR_UNUSED
  * Function:    H5AC__ext_config_2_int_config()
  *
  * Purpose:     Utility function to translate an instance of
- *		H5AC_cache_config_t to an instance of H5C_auto_size_ctl_t.
+ *              H5AC_cache_config_t to an instance of H5C_auto_size_ctl_t.
  *
- *		Places translation in *int_conf_ptr and returns SUCCEED
- *		if successful.  Returns FAIL on failure.
+ *              Places translation in *int_conf_ptr and returns SUCCEED
+ *              if successful.  Returns FAIL on failure.
  *
- *		Does only minimal sanity checking.
+ *              Does only minimal sanity checking.
  *
  * Return:      Non-negative on success/Negative on failure
  *
@@ -2630,7 +2630,7 @@ done:
  * Purpose:     Given a file address, retrieve the ring for an entry at that
  *              address.
  *
- * 		On error, the value of *ring is not modified.
+ *              On error, the value of *ring is not modified.
  *
  * Return:      Non-negative on success/Negative on failure
  *
@@ -2708,11 +2708,11 @@ H5AC_set_ring(H5AC_ring_t ring, H5AC_ring_t *orig_ring)
  *              are in the process of a file shutdown, post an error
  *              message, and return FAIL.
  *
- *		Note that this function simply passes the call on to
- *		the metadata cache proper, and returns the result.
+ *              Note that this function simply passes the call on to
+ *              the metadata cache proper, and returns the result.
  *
- * Return:	Success:	Non-negative
- *		Failure:	Negative
+ * Return:      Success:        Non-negative
+ *              Failure:        Negative
  *
  * Programmer:  Quincey Koziol
  *              September 17, 2016
@@ -2785,7 +2785,7 @@ done:
  * Function:    H5AC_remove_entry()
  *
  * Purpose:     Remove an entry from the cache.  Must be not protected, pinned,
- *		dirty, involved in flush dependencies, etc.
+ *              dirty, involved in flush dependencies, etc.
  *
  * Return:      Non-negative on success/Negative on failure
  *
diff --git a/src/H5C.c b/src/H5C.c
index b70c6dc..17dc1d2 100644
--- a/src/H5C.c
+++ b/src/H5C.c
@@ -387,32 +387,32 @@ H5C_create(size_t		      max_cache_size,
     cache_ptr->dirty_index_size			= (size_t)0;
 
     for(i = 0; i < H5C_RING_NTYPES; i++) {
-	cache_ptr->index_ring_len[i]		= 0;
-	cache_ptr->index_ring_size[i]		= (size_t)0;
-	cache_ptr->clean_index_ring_size[i]	= (size_t)0;
-	cache_ptr->dirty_index_ring_size[i]	= (size_t)0;
+        cache_ptr->index_ring_len[i]            = 0;
+        cache_ptr->index_ring_size[i]           = (size_t)0;
+        cache_ptr->clean_index_ring_size[i]     = (size_t)0;
+        cache_ptr->dirty_index_ring_size[i]     = (size_t)0;
 
-	cache_ptr->slist_ring_len[i]		= 0;
-	cache_ptr->slist_ring_size[i]		= (size_t)0;
+        cache_ptr->slist_ring_len[i]            = 0;
+        cache_ptr->slist_ring_size[i]           = (size_t)0;
     } /* end for */
 
     for(i = 0; i < H5C__HASH_TABLE_LEN; i++)
         (cache_ptr->index)[i] = NULL;
 
-    cache_ptr->il_len				= 0;
-    cache_ptr->il_size				= (size_t)0;
-    cache_ptr->il_head				= NULL;
-    cache_ptr->il_tail				= NULL;
+    cache_ptr->il_len                           = 0;
+    cache_ptr->il_size                          = (size_t)0;
+    cache_ptr->il_head                          = NULL;
+    cache_ptr->il_tail                          = NULL;
 
     /* Tagging Field Initializations */
     cache_ptr->ignore_tags                      = FALSE;
     cache_ptr->num_objs_corked                  = 0;
 
     /* slist field initializations */
-    cache_ptr->slist_enabled			= ! H5C__SLIST_OPT_ENABLED;
-    cache_ptr->slist_changed			= FALSE;
-    cache_ptr->slist_len			= 0;
-    cache_ptr->slist_size			= (size_t)0;
+    cache_ptr->slist_enabled                    = ! H5C__SLIST_OPT_ENABLED;
+    cache_ptr->slist_changed                    = FALSE;
+    cache_ptr->slist_len                        = 0;
+    cache_ptr->slist_size                       = (size_t)0;
 
     /* slist_ring_len, slist_ring_size, and 
      * slist_ptr initializaed above.
@@ -1056,7 +1056,6 @@ H5C_evict(H5F_t * f)
     if ( H5C_set_slist_enabled(f->shared->cache, TRUE, FALSE) < 0 )
 
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "set slist enabled failed")
- 
 
     /* Flush and invalidate all cache entries except the pinned entries */
     if ( H5C__flush_invalidate_cache(f, H5C__EVICT_ALLOW_LAST_PINS_FLAG) < 0 )
@@ -3219,8 +3218,8 @@ done:
  * Programmer:  John Mainzer
  *              3/22/06
  *
- * Changes:	Added extreme sanity checks on entry and exit.
- *              				JRM -- 4/26/14
+ * Changes:     Added extreme sanity checks on entry and exit.
+ *                                      JRM -- 4/26/14
  *
  *-------------------------------------------------------------------------
  */
@@ -3438,16 +3437,16 @@ H5C_unprotect(H5F_t *f, haddr_t	addr, void *thing, unsigned flags)
     if ( entry_ptr->ro_ref_count > 1 ) {
 
         /* Sanity check */
-	HDassert(entry_ptr->is_protected);
+        HDassert(entry_ptr->is_protected);
         HDassert(entry_ptr->is_read_only);
 
-	if ( dirtied )
+        if ( dirtied )
 
             HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, \
                         "Read only entry modified??")
 
         /* Reduce the RO ref count */
-	(entry_ptr->ro_ref_count)--;
+        (entry_ptr->ro_ref_count)--;
 
         /* Pin or unpin the entry as requested. */
         if ( pin_entry ) {
@@ -3469,20 +3468,20 @@ H5C_unprotect(H5F_t *f, haddr_t	addr, void *thing, unsigned flags)
         } /* end if */
     } else {
 
-	if ( entry_ptr->is_read_only ) {
+        if ( entry_ptr->is_read_only ) {
 
             /* Sanity check */
-	    HDassert(entry_ptr->ro_ref_count == 1);
+            HDassert(entry_ptr->ro_ref_count == 1);
 
-	    if ( dirtied )
+            if ( dirtied )
 
                 HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, \
                             "Read only entry modified??")
 
-	    entry_ptr->is_read_only = FALSE;
-	    entry_ptr->ro_ref_count = 0;
+            entry_ptr->is_read_only = FALSE;
+            entry_ptr->ro_ref_count = 0;
 
-	} /* end if */
+        } /* end if */
 
 #ifdef H5_HAVE_PARALLEL
         /* When the H5C code is used to implement the metadata cache in the
@@ -3518,15 +3517,15 @@ H5C_unprotect(H5F_t *f, haddr_t	addr, void *thing, unsigned flags)
         /* Mark the entry as dirty if appropriate */
         entry_ptr->is_dirty = (entry_ptr->is_dirty || dirtied);
 
-	if ( dirtied ) {
+        if ( dirtied ) {
 
-	    if ( entry_ptr->image_up_to_date ) {
+            if ( entry_ptr->image_up_to_date ) {
 
-	        entry_ptr->image_up_to_date = FALSE;
+                entry_ptr->image_up_to_date = FALSE;
 
-	        if ( entry_ptr->flush_dep_nparents > 0 ) {
+                if ( entry_ptr->flush_dep_nparents > 0 ) {
 
-		    if ( H5C__mark_flush_dep_unserialized(entry_ptr) < 0 )
+                    if ( H5C__mark_flush_dep_unserialized(entry_ptr) < 0 )
 
                         HGOTO_ERROR(H5E_CACHE, H5E_CANTNOTIFY, FAIL, \
                           "Can't propagate serialization status to fd parents")
@@ -3700,7 +3699,6 @@ H5C_unprotect(H5F_t *f, haddr_t	addr, void *thing, unsigned flags)
             if ( H5C__flush_single_entry(f, entry_ptr, 
                                       H5C__FLUSH_CLEAR_ONLY_FLAG | 
                                       H5C__DEL_FROM_SLIST_ON_DESTROY_FLAG) < 0 )
-
                 HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, \
                             "Can't clear entry")
 
@@ -5753,36 +5751,36 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5C_flush_invalidate_ring
  *
- * Purpose:	Flush and destroy the entries contained in the target
- *		cache and ring.
+ * Purpose:     Flush and destroy the entries contained in the target
+ *              cache and ring.
  *
- *		If the ring contains protected entries, the function will
- *		fail, as protected entries cannot be either flushed or
- *		destroyed.  However all unprotected entries should be
- *		flushed and destroyed before the function returns failure.
+ *              If the ring contains protected entries, the function will
+ *              fail, as protected entries cannot be either flushed or
+ *              destroyed.  However all unprotected entries should be
+ *              flushed and destroyed before the function returns failure.
  *
- *		While pinned entries can usually be flushed, they cannot
- *		be destroyed.  However, they should be unpinned when all
- *		the entries that reference them have been destroyed (thus
- *		reduding the pinned entry's reference count to 0, allowing
- *		it to be unpinned).
+ *              While pinned entries can usually be flushed, they cannot
+ *              be destroyed.  However, they should be unpinned when all
+ *              the entries that reference them have been destroyed (thus
+ *              reduding the pinned entry's reference count to 0, allowing
+ *              it to be unpinned).
  *
- *		If pinned entries are present, the function makes repeated
- *		passes through the cache, flushing all dirty entries
- *		(including the pinned dirty entries where permitted) and
- *		destroying all unpinned entries.  This process is repeated
- *		until either the cache is empty, or the number of pinned
- *		entries stops decreasing on each pass.
+ *              If pinned entries are present, the function makes repeated
+ *              passes through the cache, flushing all dirty entries
+ *              (including the pinned dirty entries where permitted) and
+ *              destroying all unpinned entries.  This process is repeated
+ *              until either the cache is empty, or the number of pinned
+ *              entries stops decreasing on each pass.
  *
- *		If flush dependencies appear in the target ring, the
- *		function makes repeated passes through the cache flushing
- *		entries in flush dependency order.
+ *              If flush dependencies appear in the target ring, the
+ *              function makes repeated passes through the cache flushing
+ *              entries in flush dependency order.
  *
  * Return:      Non-negative on success/Negative on failure or if there was
- *		a request to flush all items and something was protected.
+ *              a request to flush all items and something was protected.
  *
  * Programmer:  John Mainzer
- *		9/1/15
+ *              9/1/15
  *
  * Changes:     Added support for the H5C__EVICT_ALLOW_LAST_PINS_FLAG.
  *              This flag is used to flush and evict all entries in 
@@ -6317,24 +6315,24 @@ done:
  *
  * Function:    H5C__flush_ring
  *
- * Purpose:	Flush the entries contained in the specified cache and
- *		ring.  All entries in rings outside the specified ring
- *		must have been flushed on entry.
+ * Purpose:     Flush the entries contained in the specified cache and
+ *              ring.  All entries in rings outside the specified ring
+ *              must have been flushed on entry.
  *
- *		If the cache contains protected entries in the specified
- *		ring, the function will fail, as protected entries cannot
- *		be flushed.  However all unprotected entries in the target
- *		ring should be flushed before the function returns failure.
+ *              If the cache contains protected entries in the specified
+ *              ring, the function will fail, as protected entries cannot
+ *              be flushed.  However all unprotected entries in the target
+ *              ring should be flushed before the function returns failure.
  *
- *		If flush dependencies appear in the target ring, the
- *		function makes repeated passes through the slist flushing
- *		entries in flush dependency order.
+ *              If flush dependencies appear in the target ring, the
+ *              function makes repeated passes through the slist flushing
+ *              entries in flush dependency order.
  *
  * Return:      Non-negative on success/Negative on failure or if there was
- *		a request to flush all items and something was protected.
+ *              a request to flush all items and something was protected.
  *
  * Programmer:  John Mainzer
- *		9/1/15
+ *              9/1/15
  *
  * Changes:     A recent optimization turns off the slist unless a flush
  *              is in progress.  This should not effect this function, as
@@ -6392,7 +6390,7 @@ H5C__flush_ring(H5F_t *f, H5C_ring_t ring, unsigned flags)
 
         for ( i = (int)H5C_RING_UNDEFINED; i < (int)ring; i++ ) {
 
-	    HDassert(cache_ptr->slist_ring_len[i] == 0);
+            HDassert(cache_ptr->slist_ring_len[i] == 0);
         }
     }
 
@@ -6416,8 +6414,8 @@ H5C__flush_ring(H5F_t *f, H5C_ring_t ring, unsigned flags)
     cache_ptr->slist_changed = FALSE;
 
     while ( ( cache_ptr->slist_ring_len[ring] > 0 ) &&
-	    ( protected_entries == 0 )  &&
-	    ( flushed_entries_last_pass ) ) {
+            ( protected_entries == 0 )  &&
+            ( flushed_entries_last_pass ) ) {
 
         flushed_entries_last_pass = FALSE;
 
@@ -6641,23 +6639,23 @@ done:
  * Function:    H5C__flush_single_entry
  *
  * Purpose:     Flush or clear (and evict if requested) the cache entry
- *		with the specified address and type.  If the type is NULL,
- *		any unprotected entry at the specified address will be
- *		flushed (and possibly evicted).
+ *              with the specified address and type.  If the type is NULL,
+ *              any unprotected entry at the specified address will be
+ *              flushed (and possibly evicted).
  *
- *		Attempts to flush a protected entry will result in an
- *		error.
+ *              Attempts to flush a protected entry will result in an
+ *              error.
  *
- *		If the H5C__FLUSH_INVALIDATE_FLAG flag is set, the entry will
- *		be cleared and not flushed, and the call can't be part of a
+ *              If the H5C__FLUSH_INVALIDATE_FLAG flag is set, the entry will
+ *              be cleared and not flushed, and the call can't be part of a
  *              sequence of flushes.
  *
- *		The function does nothing silently if there is no entry
- *		at the supplied address, or if the entry found has the
- *		wrong type.
+ *              The function does nothing silently if there is no entry
+ *              at the supplied address, or if the entry found has the
+ *              wrong type.
  *
  * Return:      Non-negative on success/Negative on failure or if there was
- *		an attempt to flush a protected item.
+ *              an attempt to flush a protected item.
  *
  * Programmer:  John Mainzer, 5/5/04
  *
@@ -6729,22 +6727,22 @@ done:
 herr_t
 H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags)
 {
-    H5C_t *	     	cache_ptr;              /* Cache for file */
-    hbool_t		destroy;		/* external flag */
-    hbool_t		clear_only;		/* external flag */
-    hbool_t		free_file_space;	/* external flag */
-    hbool_t		take_ownership;		/* external flag */
-    hbool_t             del_from_slist_on_destroy;    /* external flag */
-    hbool_t		during_flush;		/* external flag */
-    hbool_t		write_entry;		/* internal flag */
-    hbool_t		destroy_entry;		/* internal flag */
-    hbool_t		generate_image;		/* internal flag */
-    hbool_t		update_page_buffer;	/* internal flag */
-    hbool_t		was_dirty;
-    hbool_t		suppress_image_entry_writes = FALSE;
-    hbool_t		suppress_image_entry_frees = FALSE;
-    haddr_t             entry_addr = HADDR_UNDEF;
-    herr_t		ret_value = SUCCEED;      /* Return value */
+    H5C_t *     cache_ptr;                      /* Cache for file */
+    hbool_t     destroy;                        /* external flag */
+    hbool_t     clear_only;                     /* external flag */
+    hbool_t     free_file_space;                /* external flag */
+    hbool_t     take_ownership;                 /* external flag */
+    hbool_t     del_from_slist_on_destroy;      /* external flag */
+    hbool_t     during_flush;                   /* external flag */
+    hbool_t     write_entry;                    /* internal flag */
+    hbool_t     destroy_entry;                  /* internal flag */
+    hbool_t     generate_image;                 /* internal flag */
+    hbool_t     update_page_buffer;             /* internal flag */
+    hbool_t     was_dirty;
+    hbool_t     suppress_image_entry_writes = FALSE;
+    hbool_t     suppress_image_entry_frees = FALSE;
+    haddr_t     entry_addr = HADDR_UNDEF;
+    herr_t      ret_value = SUCCEED;            /* Return value */
 
     FUNC_ENTER_PACKAGE
 
@@ -7101,9 +7099,9 @@ H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags)
             HGOTO_ERROR(H5E_CACHE, H5E_CANTREMOVE, FAIL, \
                         "can't remove entry from tag list")
 
-	/* verify that the entry is no longer part of any flush dependencies */
+        /* verify that the entry is no longer part of any flush dependencies */
         HDassert(entry_ptr->flush_dep_nparents == 0);
-	HDassert(entry_ptr->flush_dep_nchildren == 0);
+        HDassert(entry_ptr->flush_dep_nchildren == 0);
 
     } /* end if */
     else {
@@ -7118,7 +7116,7 @@ H5C__flush_single_entry(H5F_t *f, H5C_cache_entry_t *entry_ptr, unsigned flags)
          * view of the replacement policy and the slist.
          * Hence no differentiation between them.
          *
-         * 					JRM -- 7/7/07
+         *                              JRM -- 7/7/07
          */
 
         H5C__UPDATE_RP_FOR_FLUSH(cache_ptr, entry_ptr, FAIL)
@@ -9482,7 +9480,7 @@ done:
  *
  * Purpose:     Serialize an entry and generate its image.
  *
- * Note:	This may cause the entry to be re-sized and/or moved in
+ * Note:        This may cause the entry to be re-sized and/or moved in
  *              the cache.
  *
  *              As we will not update the metadata cache's data structures
@@ -9505,9 +9503,9 @@ done:
 herr_t
 H5C__generate_image(H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t *entry_ptr)
 {
-    haddr_t		new_addr = HADDR_UNDEF;
-    haddr_t		old_addr = HADDR_UNDEF;
-    size_t		new_len = 0;
+    haddr_t             new_addr = HADDR_UNDEF;
+    haddr_t             old_addr = HADDR_UNDEF;
+    size_t              new_len = 0;
     unsigned            serialize_flags = H5C__SERIALIZE_NO_FLAGS_SET;
     herr_t              ret_value = SUCCEED;
 
diff --git a/src/H5Cdbg.c b/src/H5Cdbg.c
index 085ac77..810c1e3 100644
--- a/src/H5Cdbg.c
+++ b/src/H5Cdbg.c
@@ -264,8 +264,8 @@ H5C_dump_cache_LRU(H5C_t *cache_ptr, const char *cache_name)
  * Function:    H5C_dump_cache_skip_list
  *
  * Purpose:     Debugging routine that prints a summary of the contents of
- *		the skip list used by the metadata cache metadata cache to
- *		maintain an address sorted list of dirty entries.
+ *              the skip list used by the metadata cache metadata cache to
+ *              maintain an address sorted list of dirty entries.
  *
  * Return:      Non-negative on success/Negative on failure
  *
diff --git a/src/H5Cimage.c b/src/H5Cimage.c
index 9dd2ac6..0373098 100644
--- a/src/H5Cimage.c
+++ b/src/H5Cimage.c
@@ -431,33 +431,33 @@ done:
  * Function:    H5C__deserialize_prefetched_entry()
  *
  * Purpose:     Deserialize the supplied prefetched entry entry, and return
- *		a pointer to the deserialized entry in *entry_ptr_ptr.
- *		If successful, remove the prefetched entry from the cache,
- *		and free it.  Insert the deserialized entry into the cache.
- *
- *		Note that the on disk image of the entry is not freed --
- *		a pointer to it is stored in the deserialized entries'
- *		image_ptr field, and its image_up_to_date field is set to
- *		TRUE unless the entry is dirtied by the deserialize call.
- *
- *		If the prefetched entry is a flush dependency child,
- *		destroy that flush dependency prior to calling the
- *		deserialize callback.  If appropriate, the flush dependency
- *		relationship will be recreated by the cache client.
- *
- *		If the prefetched entry is a flush dependency parent,
- *		destroy the flush dependency relationship with all its
- *		children.  As all these children must be prefetched entries,
- *		recreate these flush dependency relationships with
- *		deserialized entry after it is inserted in the cache.
- *
- *		Since deserializing a prefetched entry is semantically
- *		equivalent to a load, issue an entry loaded nofification
- *		if the notify callback is defined.
+ *              a pointer to the deserialized entry in *entry_ptr_ptr.
+ *              If successful, remove the prefetched entry from the cache,
+ *              and free it.  Insert the deserialized entry into the cache.
+ *
+ *              Note that the on disk image of the entry is not freed --
+ *              a pointer to it is stored in the deserialized entries'
+ *              image_ptr field, and its image_up_to_date field is set to
+ *              TRUE unless the entry is dirtied by the deserialize call.
+ *
+ *              If the prefetched entry is a flush dependency child,
+ *              destroy that flush dependency prior to calling the
+ *              deserialize callback.  If appropriate, the flush dependency
+ *              relationship will be recreated by the cache client.
+ *
+ *              If the prefetched entry is a flush dependency parent,
+ *              destroy the flush dependency relationship with all its
+ *              children.  As all these children must be prefetched entries,
+ *              recreate these flush dependency relationships with
+ *              deserialized entry after it is inserted in the cache.
+ *
+ *              Since deserializing a prefetched entry is semantically
+ *              equivalent to a load, issue an entry loaded nofification
+ *              if the notify callback is defined.
  *
  * Return:      SUCCEED on success, and FAIL on failure.
  *
- *		Note that *entry_ptr_ptr is undefined on failure.
+ *              Note that *entry_ptr_ptr is undefined on failure.
  *
  * Programmer:  John Mainzer, 8/10/15
  *
@@ -472,11 +472,11 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr,
     H5C_cache_entry_t **entry_ptr_ptr, const H5C_class_t *type,
     haddr_t addr, void *udata)
 {
-    hbool_t		dirty = FALSE;  /* Flag indicating whether thing was
+    hbool_t             dirty = FALSE;  /* Flag indicating whether thing was
                                          * dirtied during deserialize
                                          */
     size_t              len;            /* Size of image in file */
-    void *		thing = NULL;   /* Pointer to thing loaded */
+    void *              thing = NULL;   /* Pointer to thing loaded */
     H5C_cache_entry_t * pf_entry_ptr;   /* pointer to the prefetched entry   */
                                         /* supplied in *entry_ptr_ptr.       */
     H5C_cache_entry_t *	ds_entry_ptr;   /* Alias for thing loaded, as cache
@@ -488,8 +488,8 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr,
                                         /* the prefetched entry, or NULL if  */
                                         /* that array does not exist.        */
     unsigned            flush_flags = (H5C__FLUSH_INVALIDATE_FLAG |
-				       H5C__FLUSH_CLEAR_ONLY_FLAG);
-    int			i;
+                                       H5C__FLUSH_CLEAR_ONLY_FLAG);
+    int                 i;
     herr_t      	ret_value = SUCCEED;      /* Return value */
 
     FUNC_ENTER_PACKAGE
@@ -608,73 +608,73 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr,
 
     HDassert( ( dirty == FALSE ) || ( type->id == 5 || type->id == 6) );
 
-    ds_entry_ptr->magic                     	= H5C__H5C_CACHE_ENTRY_T_MAGIC;
-    ds_entry_ptr->cache_ptr                 	= f->shared->cache;
-    ds_entry_ptr->addr                      	= addr;
-    ds_entry_ptr->size                      	= len;
+    ds_entry_ptr->magic                     = H5C__H5C_CACHE_ENTRY_T_MAGIC;
+    ds_entry_ptr->cache_ptr                 = f->shared->cache;
+    ds_entry_ptr->addr                      = addr;
+    ds_entry_ptr->size                      = len;
     HDassert(ds_entry_ptr->size < H5C_MAX_ENTRY_SIZE);
-    ds_entry_ptr->image_ptr                 	= pf_entry_ptr->image_ptr;
-    ds_entry_ptr->image_up_to_date          	= !dirty;
-    ds_entry_ptr->type                      	= type;
-    ds_entry_ptr->is_dirty	            	= dirty | pf_entry_ptr->is_dirty;
-    ds_entry_ptr->dirtied                   	= FALSE;
-    ds_entry_ptr->is_protected              	= FALSE;
-    ds_entry_ptr->is_read_only              	= FALSE;
-    ds_entry_ptr->ro_ref_count              	= 0;
-    ds_entry_ptr->is_pinned                 	= FALSE;
-    ds_entry_ptr->in_slist                  	= FALSE;
-    ds_entry_ptr->flush_marker              	= FALSE;
+    ds_entry_ptr->image_ptr                 = pf_entry_ptr->image_ptr;
+    ds_entry_ptr->image_up_to_date          = !dirty;
+    ds_entry_ptr->type                      = type;
+    ds_entry_ptr->is_dirty	                = dirty | pf_entry_ptr->is_dirty;
+    ds_entry_ptr->dirtied                   = FALSE;
+    ds_entry_ptr->is_protected              = FALSE;
+    ds_entry_ptr->is_read_only              = FALSE;
+    ds_entry_ptr->ro_ref_count              = 0;
+    ds_entry_ptr->is_pinned                 = FALSE;
+    ds_entry_ptr->in_slist                  = FALSE;
+    ds_entry_ptr->flush_marker              = FALSE;
 #ifdef H5_HAVE_PARALLEL
-    ds_entry_ptr->clear_on_unprotect        	= FALSE;
-    ds_entry_ptr->flush_immediately         	= FALSE;
-    ds_entry_ptr->coll_access               	= FALSE;
+    ds_entry_ptr->clear_on_unprotect        = FALSE;
+    ds_entry_ptr->flush_immediately         = FALSE;
+    ds_entry_ptr->coll_access               = FALSE;
 #endif /* H5_HAVE_PARALLEL */
-    ds_entry_ptr->flush_in_progress         	= FALSE;
-    ds_entry_ptr->destroy_in_progress       	= FALSE;
+    ds_entry_ptr->flush_in_progress         = FALSE;
+    ds_entry_ptr->destroy_in_progress       = FALSE;
 
-    ds_entry_ptr->ring		            	= pf_entry_ptr->ring;
+    ds_entry_ptr->ring                      = pf_entry_ptr->ring;
 
     /* Initialize flush dependency height fields */
-    ds_entry_ptr->flush_dep_parent          	= NULL;
-    ds_entry_ptr->flush_dep_nparents        	= 0;
-    ds_entry_ptr->flush_dep_parent_nalloc   	= 0;
-    ds_entry_ptr->flush_dep_nchildren       	= 0;
-    ds_entry_ptr->flush_dep_ndirty_children 	= 0;
-    ds_entry_ptr->flush_dep_nunser_children 	= 0;
+    ds_entry_ptr->flush_dep_parent          = NULL;
+    ds_entry_ptr->flush_dep_nparents        = 0;
+    ds_entry_ptr->flush_dep_parent_nalloc   = 0;
+    ds_entry_ptr->flush_dep_nchildren       = 0;
+    ds_entry_ptr->flush_dep_ndirty_children = 0;
+    ds_entry_ptr->flush_dep_nunser_children = 0;
 
     /* Initialize fields supporting the hash table: */
-    ds_entry_ptr->ht_next                   	= NULL;
-    ds_entry_ptr->ht_prev                   	= NULL;
-    ds_entry_ptr->il_next                   	= NULL;
-    ds_entry_ptr->il_prev                   	= NULL;
+    ds_entry_ptr->ht_next                   = NULL;
+    ds_entry_ptr->ht_prev                   = NULL;
+    ds_entry_ptr->il_next                   = NULL;
+    ds_entry_ptr->il_prev                   = NULL;
 
     /* Initialize fields supporting replacement policies: */
-    ds_entry_ptr->next                      	= NULL;
-    ds_entry_ptr->prev                      	= NULL;
+    ds_entry_ptr->next                      = NULL;
+    ds_entry_ptr->prev                      = NULL;
 #if H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS
-    ds_entry_ptr->aux_next                  	= NULL;
-    ds_entry_ptr->aux_prev                  	= NULL;
+    ds_entry_ptr->aux_next                  = NULL;
+    ds_entry_ptr->aux_prev                  = NULL;
 #endif /* H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS */
 #ifdef H5_HAVE_PARALLEL
-    pf_entry_ptr->coll_next                 	= NULL;
-    pf_entry_ptr->coll_prev                 	= NULL;
+    pf_entry_ptr->coll_next                 = NULL;
+    pf_entry_ptr->coll_prev                 = NULL;
 #endif /* H5_HAVE_PARALLEL */
 
     /* Initialize cache image related fields */
-    ds_entry_ptr->include_in_image          	= FALSE;
-    ds_entry_ptr->lru_rank	            	= 0;
-    ds_entry_ptr->image_dirty	            	= FALSE;
-    ds_entry_ptr->fd_parent_count           	= 0;
-    ds_entry_ptr->fd_parent_addrs           	= NULL;
-    ds_entry_ptr->fd_child_count            	= pf_entry_ptr->fd_child_count;
-    ds_entry_ptr->fd_dirty_child_count      	= 0;
-    ds_entry_ptr->image_fd_height           	= 0;
-    ds_entry_ptr->prefetched	            	= FALSE;
-    ds_entry_ptr->prefetch_type_id          	= 0;
-    ds_entry_ptr->age		          	= 0;
-    ds_entry_ptr->prefetched_dirty              = pf_entry_ptr->prefetched_dirty;
+    ds_entry_ptr->include_in_image          = FALSE;
+    ds_entry_ptr->lru_rank	                = 0;
+    ds_entry_ptr->image_dirty	             = FALSE;
+    ds_entry_ptr->fd_parent_count           = 0;
+    ds_entry_ptr->fd_parent_addrs           = NULL;
+    ds_entry_ptr->fd_child_count            = pf_entry_ptr->fd_child_count;
+    ds_entry_ptr->fd_dirty_child_count      = 0;
+    ds_entry_ptr->image_fd_height           = 0;
+    ds_entry_ptr->prefetched	              = FALSE;
+    ds_entry_ptr->prefetch_type_id          = 0;
+    ds_entry_ptr->age                       = 0;
+    ds_entry_ptr->prefetched_dirty          = pf_entry_ptr->prefetched_dirty;
 #ifndef NDEBUG  /* debugging field */
-    ds_entry_ptr->serialization_count           = 0;
+    ds_entry_ptr->serialization_count       = 0;
 #endif /* NDEBUG */
 
     H5C__RESET_CACHE_ENTRY_STATS(ds_entry_ptr);
@@ -698,7 +698,7 @@ H5C__deserialize_prefetched_entry(H5F_t *f, H5C_t *cache_ptr,
      *
      *  1) Set pf_entry_ptr->image_ptr to NULL.  Since we have already
      *     transferred the buffer containing the image to *ds_entry_ptr,
-     *	   this is not a memory leak.
+     *     this is not a memory leak.
      *
      *  2) Call H5C__flush_single_entry() with the H5C__FLUSH_INVALIDATE_FLAG
      *     and H5C__FLUSH_CLEAR_ONLY_FLAG flags set.
diff --git a/src/H5Cmpio.c b/src/H5Cmpio.c
index 31dc647..6ec0513 100644
--- a/src/H5Cmpio.c
+++ b/src/H5Cmpio.c
@@ -34,14 +34,14 @@
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"		/* Generic Functions			*/
+#include "H5private.h"          /* Generic Functions                    */
 #include "H5ACprivate.h"        /* Metadata cache                       */
-#include "H5Cpkg.h"		/* Cache				*/
+#include "H5Cpkg.h"             /* Cache                                */
 #include "H5CXprivate.h"        /* API Contexts                         */
-#include "H5Eprivate.h"		/* Error handling		  	*/
-#include "H5Fpkg.h"		/* Files				*/
-#include "H5FDprivate.h"	/* File drivers				*/
-#include "H5MMprivate.h"	/* Memory management			*/
+#include "H5Eprivate.h"         /* Error handling                       */
+#include "H5Fpkg.h"             /* Files                                */
+#include "H5FDprivate.h"        /* File drivers                         */
+#include "H5MMprivate.h"        /* Memory management                    */
 
 
 #ifdef H5_HAVE_PARALLEL
@@ -87,74 +87,74 @@ static herr_t H5C__flush_candidates_in_ring(H5F_t *f, H5C_ring_t ring,
  *
  * Purpose:     Apply the supplied candidate list.
  *
- *		We used to do this by simply having each process write
- *		every mpi_size-th entry in the candidate list, starting
- *		at index mpi_rank, and mark all the others clean.
+ *              We used to do this by simply having each process write
+ *              every mpi_size-th entry in the candidate list, starting
+ *              at index mpi_rank, and mark all the others clean.
  *
- *		However, this can cause unnecessary contention in a file
- *		system by increasing the number of processes writing to
- *		adjacent locations in the HDF5 file.
+ *              However, this can cause unnecessary contention in a file
+ *              system by increasing the number of processes writing to
+ *              adjacent locations in the HDF5 file.
  *
- *		To attempt to minimize this, we now arange matters such
- *		that each process writes n adjacent entries in the
- *		candidate list, and marks all others clean.  We must do
- *		this in such a fashion as to guarantee that each entry
- *		on the candidate list is written by exactly one process,
- *		and marked clean by all others.
+ *              To attempt to minimize this, we now arange matters such
+ *              that each process writes n adjacent entries in the
+ *              candidate list, and marks all others clean.  We must do
+ *              this in such a fashion as to guarantee that each entry
+ *              on the candidate list is written by exactly one process,
+ *              and marked clean by all others.
  *
- *		To do this, first construct a table mapping mpi_rank
- *		to the index of the first entry in the candidate list to
- *		be written by the process of that mpi_rank, and then use
- *		the table to control which entries are written and which
- *		are marked as clean as a function of the mpi_rank.
+ *              To do this, first construct a table mapping mpi_rank
+ *              to the index of the first entry in the candidate list to
+ *              be written by the process of that mpi_rank, and then use
+ *              the table to control which entries are written and which
+ *              are marked as clean as a function of the mpi_rank.
  *
- *		Note that the table must be identical on all processes, as
- *		all see the same candidate list, mpi_size, and mpi_rank --
- *		the inputs used to construct the table.
+ *              Note that the table must be identical on all processes, as
+ *              all see the same candidate list, mpi_size, and mpi_rank --
+ *              the inputs used to construct the table.
  *
- *		We construct the table as follows.  Let:
+ *              We construct the table as follows.  Let:
  *
- *			n = num_candidates / mpi_size;
+ *                      n = num_candidates / mpi_size;
  *
- *			m = num_candidates % mpi_size;
+ *                      m = num_candidates % mpi_size;
  *
- *		Now allocate an array of integers of length mpi_size + 1,
- *		and call this array candidate_assignment_table.
+ *              Now allocate an array of integers of length mpi_size + 1,
+ *              and call this array candidate_assignment_table.
  *
- *		Conceptually, if the number of candidates is a multiple
- *		of the mpi_size, we simply pass through the candidate list
- *		and assign n entries to each process to flush, with the
- *		index of the first entry to flush in the location in
- *		the candidate_assignment_table indicated by the mpi_rank
- *		of the process.
+ *              Conceptually, if the number of candidates is a multiple
+ *              of the mpi_size, we simply pass through the candidate list
+ *              and assign n entries to each process to flush, with the
+ *              index of the first entry to flush in the location in
+ *              the candidate_assignment_table indicated by the mpi_rank
+ *              of the process.
  *
- *		In the more common case in which the candidate list isn't
- *		isn't a multiple of the mpi_size, we pretend it is, and
- *		give num_candidates % mpi_size processes one extra entry
- *		each to make things work out.
+ *              In the more common case in which the candidate list isn't
+ *              isn't a multiple of the mpi_size, we pretend it is, and
+ *              give num_candidates % mpi_size processes one extra entry
+ *              each to make things work out.
  *
- *		Once the table is constructed, we determine the first and
- *		last entry this process is to flush as follows:
+ *              Once the table is constructed, we determine the first and
+ *              last entry this process is to flush as follows:
  *
- *	 	first_entry_to_flush = candidate_assignment_table[mpi_rank]
+ *              first_entry_to_flush = candidate_assignment_table[mpi_rank]
  *
- *		last_entry_to_flush =
- *			candidate_assignment_table[mpi_rank + 1] - 1;
+ *              last_entry_to_flush =
+ *                      candidate_assignment_table[mpi_rank + 1] - 1;
  *
- *		With these values determined, we simply scan through the
- *		candidate list, marking all entries in the range
- *		[first_entry_to_flush, last_entry_to_flush] for flush,
- *		and all others to be cleaned.
+ *              With these values determined, we simply scan through the
+ *              candidate list, marking all entries in the range
+ *              [first_entry_to_flush, last_entry_to_flush] for flush,
+ *              and all others to be cleaned.
  *
- *		Finally, we scan the LRU from tail to head, flushing
- *		or marking clean the candidate entries as indicated.
- *		If necessary, we scan the pinned list as well.
+ *              Finally, we scan the LRU from tail to head, flushing
+ *              or marking clean the candidate entries as indicated.
+ *              If necessary, we scan the pinned list as well.
  *
- *		Note that this function will fail if any protected or
- *		clean entries appear on the candidate list.
+ *              Note that this function will fail if any protected or
+ *              clean entries appear on the candidate list.
  *
- *		This function is used in managing sync points, and
- *		shouldn't be used elsewhere.
+ *              This function is used in managing sync points, and
+ *              shouldn't be used elsewhere.
  *
  * Return:      Success:        SUCCEED
  *
@@ -187,15 +187,15 @@ H5C_apply_candidate_list(H5F_t * f,
     unsigned          * candidate_assignment_table = NULL;
     unsigned            entries_to_flush[H5C_RING_NTYPES];
     unsigned            entries_to_clear[H5C_RING_NTYPES];
-    haddr_t		addr;
-    H5C_cache_entry_t *	entry_ptr = NULL;
+    haddr_t             addr;
+    H5C_cache_entry_t * entry_ptr = NULL;
 
 #if H5C_DO_SANITY_CHECKS
-    haddr_t		last_addr;
+    haddr_t             last_addr;
 #endif /* H5C_DO_SANITY_CHECKS */
 
 #if H5C_APPLY_CANDIDATE_LIST__DEBUG
-    char		tbl_buf[1024];
+    char                tbl_buf[1024];
 #endif /* H5C_APPLY_CANDIDATE_LIST__DEBUG */
 
     unsigned            u;                      /* Local index variable */
@@ -422,10 +422,10 @@ done:
  * Function:    H5C_construct_candidate_list__clean_cache
  *
  * Purpose:     Construct the list of entries that should be flushed to
- *		clean all entries in the cache.
+ *              clean all entries in the cache.
  *
- *		This function is used in managing sync points, and
- *		shouldn't be used elsewhere.
+ *              This function is used in managing sync points, and
+ *              shouldn't be used elsewhere.
  *
  * Return:      Success:        SUCCEED
  *
@@ -572,10 +572,10 @@ done:
  * Function:    H5C_construct_candidate_list__min_clean
  *
  * Purpose:     Construct the list of entries that should be flushed to
- *		get the cache back within its min clean constraints.
+ *              get the cache back within its min clean constraints.
  *
- *		This function is used in managing sync points, and
- *		shouldn't be used elsewhere.
+ *              This function is used in managing sync points, and
+ *              shouldn't be used elsewhere.
  *
  * Return:      Success:        SUCCEED
  *
@@ -691,24 +691,24 @@ done:
  * Function:    H5C_mark_entries_as_clean
  *
  * Purpose:     When the H5C code is used to implement the metadata caches
- *		in PHDF5, only the cache with MPI_rank 0 is allowed to
- *		actually write entries to disk -- all other caches must
- *		retain dirty entries until they are advised that the
- *		entries are clean.
+ *              in PHDF5, only the cache with MPI_rank 0 is allowed to
+ *              actually write entries to disk -- all other caches must
+ *              retain dirty entries until they are advised that the
+ *              entries are clean.
  *
- *		This function exists to allow the H5C code to receive these
- *		notifications.
+ *              This function exists to allow the H5C code to receive these
+ *              notifications.
  *
- *		The function receives a list of entry base addresses
- *		which must refer to dirty entries in the cache.  If any
- *		of the entries are either clean or don't exist, the
- *		function flags an error.
+ *              The function receives a list of entry base addresses
+ *              which must refer to dirty entries in the cache.  If any
+ *              of the entries are either clean or don't exist, the
+ *              function flags an error.
  *
- *		The function scans the list of entries and flushes all
- *		those that are currently unprotected with the
- *		H5C__FLUSH_CLEAR_ONLY_FLAG.  Those that are currently
- *		protected are flagged for clearing when they are
- *		unprotected.
+ *              The function scans the list of entries and flushes all
+ *              those that are currently unprotected with the
+ *              H5C__FLUSH_CLEAR_ONLY_FLAG.  Those that are currently
+ *              protected are flagged for clearing when they are
+ *              unprotected.
  *
  * Return:      Non-negative on success/Negative on failure
  *
@@ -723,22 +723,22 @@ H5C_mark_entries_as_clean(H5F_t *  f,
                           haddr_t * ce_array_ptr)
 {
     H5C_t *             cache_ptr;
-    unsigned		entries_cleared;
+    unsigned            entries_cleared;
     unsigned            pinned_entries_cleared;
     hbool_t             progress;
-    unsigned		entries_examined;
-    unsigned		initial_list_len;
-    haddr_t		addr;
-    unsigned		pinned_entries_marked = 0;
+    unsigned            entries_examined;
+    unsigned            initial_list_len;
+    haddr_t             addr;
+    unsigned            pinned_entries_marked = 0;
 #if H5C_DO_SANITY_CHECKS
-    unsigned		protected_entries_marked = 0;
-    unsigned		other_entries_marked = 0;
-    haddr_t		last_addr;
+    unsigned            protected_entries_marked = 0;
+    unsigned            other_entries_marked = 0;
+    haddr_t             last_addr;
 #endif /* H5C_DO_SANITY_CHECKS */
-    H5C_cache_entry_t *	clear_ptr = NULL;
-    H5C_cache_entry_t *	entry_ptr = NULL;
+    H5C_cache_entry_t * clear_ptr = NULL;
+    H5C_cache_entry_t * entry_ptr = NULL;
     unsigned            u;
-    herr_t		ret_value = SUCCEED;      /* Return value */
+    herr_t              ret_value = SUCCEED;      /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
@@ -785,7 +785,7 @@ H5C_mark_entries_as_clean(H5F_t *  f,
 
         if(entry_ptr == NULL) {
 #if H5C_DO_SANITY_CHECKS
-	    HDfprintf(stdout,
+            HDfprintf(stdout,
                   "H5C_mark_entries_as_clean: entry[%u] = %a not in cache.\n",
                       u,
                       addr);
@@ -794,7 +794,7 @@ H5C_mark_entries_as_clean(H5F_t *  f,
         } /* end if */
         else if(!entry_ptr->is_dirty) {
 #if H5C_DO_SANITY_CHECKS
-	    HDfprintf(stdout,
+            HDfprintf(stdout,
                       "H5C_mark_entries_as_clean: entry %a is not dirty!?!\n",
                       addr);
 #endif /* H5C_DO_SANITY_CHECKS */
@@ -814,13 +814,13 @@ H5C_mark_entries_as_clean(H5F_t *  f,
             } /* end if */
 
             entry_ptr->clear_on_unprotect = TRUE;
-	    if(entry_ptr->is_pinned)
-		pinned_entries_marked++;
+            if(entry_ptr->is_pinned)
+                pinned_entries_marked++;
 #if H5C_DO_SANITY_CHECKS
-	    else if(entry_ptr->is_protected)
-		protected_entries_marked++;
-	    else
-		other_entries_marked++;
+            else if(entry_ptr->is_protected)
+                protected_entries_marked++;
+            else
+                other_entries_marked++;
 #endif /* H5C_DO_SANITY_CHECKS */
         }
     }
@@ -848,7 +848,7 @@ H5C_mark_entries_as_clean(H5F_t *  f,
      * of the pre_serialize / serialize routines, this may
      * cease to be the case -- requiring a review of this
      * point.
-     *					JRM -- 4/7/15
+     *                                  JRM -- 4/7/15
      */
     entries_cleared = 0;
     entries_examined = 0;
@@ -952,8 +952,8 @@ done:
 herr_t
 H5C_clear_coll_entries(H5C_t *cache_ptr, hbool_t partial)
 {
-    uint32_t		clear_cnt;
-    H5C_cache_entry_t *	entry_ptr = NULL;
+    uint32_t            clear_cnt;
+    H5C_cache_entry_t * entry_ptr = NULL;
     herr_t              ret_value = SUCCEED;
 
     FUNC_ENTER_NOAPI_NOINIT
@@ -1163,7 +1163,7 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5C__flush_candidate_entries
  *
- * Purpose:	Flush or clear (as indicated) the candidate entries that
+ * Purpose:     Flush or clear (as indicated) the candidate entries that
  *              have been marked in the metadata cache.  In so doing,
  *              observe rings and flush dependencies.
  *
@@ -1192,9 +1192,9 @@ done:
  * Return:      Non-negative on success/Negative on failure.
  *
  * Programmer:  John Mainzer
- *		2/10/17
+ *              2/10/17
  *
- * Changes:	None.
+ * Changes:     None.
  *
  *-------------------------------------------------------------------------
  */
@@ -1203,17 +1203,17 @@ H5C__flush_candidate_entries(H5F_t *f, unsigned entries_to_flush[H5C_RING_NTYPES
     unsigned entries_to_clear[H5C_RING_NTYPES])
 {
 #if H5C_DO_SANITY_CHECKS
-    int			i;
-    uint32_t		index_len = 0;
-    size_t		index_size = (size_t)0;
-    size_t		clean_index_size = (size_t)0;
-    size_t		dirty_index_size = (size_t)0;
-    size_t		slist_size = (size_t)0;
-    uint32_t		slist_len = 0;
+    int                 i;
+    uint32_t            index_len = 0;
+    size_t              index_size = (size_t)0;
+    size_t              clean_index_size = (size_t)0;
+    size_t              dirty_index_size = (size_t)0;
+    size_t              slist_size = (size_t)0;
+    uint32_t            slist_len = 0;
 #endif /* H5C_DO_SANITY_CHECKS */
-    H5C_ring_t		ring;
+    H5C_ring_t          ring;
     H5C_t             * cache_ptr;
-    herr_t		ret_value = SUCCEED;
+    herr_t              ret_value = SUCCEED;
 
     FUNC_ENTER_STATIC
 
@@ -1243,7 +1243,7 @@ H5C__flush_candidate_entries(H5F_t *f, unsigned entries_to_flush[H5C_RING_NTYPES
         clean_index_size += cache_ptr->clean_index_ring_size[i];
         dirty_index_size += cache_ptr->dirty_index_ring_size[i];
 
-	slist_len += cache_ptr->slist_ring_len[i];
+        slist_len += cache_ptr->slist_ring_len[i];
         slist_size += cache_ptr->slist_ring_size[i];
     } /* end for */
 
@@ -1285,7 +1285,7 @@ done:
 /*-------------------------------------------------------------------------
  * Function:    H5C__flush_candidates_in_ring
  *
- * Purpose:	Flush or clear (as indicated) the candidate entries
+ * Purpose:     Flush or clear (as indicated) the candidate entries
  *              contained in the specified cache and ring.  All candidate
  *              entries in rings outside the specified ring must have been
  *              flushed (or cleared) on entry.
@@ -1314,7 +1314,7 @@ done:
  * Return:      Non-negative on success/Negative on failure.
  *
  * Programmer:  John Mainzer
- *		2/10/17
+ *              2/10/17
  *
  *-------------------------------------------------------------------------
  */
diff --git a/src/H5Cpkg.h b/src/H5Cpkg.h
index ac761f6..445801d 100644
--- a/src/H5Cpkg.h
+++ b/src/H5Cpkg.h
@@ -1707,8 +1707,8 @@ if ( ( (cache_ptr)->index_size !=                                           \
  * Function:    H5C__REMOVE_ENTRY_FROM_SLIST
  *
  * Purpose:     Remove the specified instance of H5C_cache_entry_t from the
- *		index skip list in the specified instance of H5C_t.  Update
- *		the associated length and size fields.
+ *              index skip list in the specified instance of H5C_t.  Update
+ *              the associated length and size fields.
  *
  * Return:      N/A
  *
@@ -1845,7 +1845,7 @@ if ( ( (cache_ptr)->index_size !=                                           \
  * Function:    H5C__UPDATE_SLIST_FOR_SIZE_CHANGE
  *
  * Purpose:     Update cache_ptr->slist_size for a change in the size of
- *		and entry in the slist.
+ *              and entry in the slist.
  *
  * Return:      N/A
  *
@@ -1853,24 +1853,24 @@ if ( ( (cache_ptr)->index_size !=                                           \
  *
  * Modifications:
  *
- *		JRM -- 8/27/06
- *		Added the H5C_DO_SANITY_CHECKS version of the macro.
+ *              JRM -- 8/27/06
+ *              Added the H5C_DO_SANITY_CHECKS version of the macro.
  *
- *		This version maintains the slist_size_increase field
- *		that are used in sanity checks in the flush routines.
+ *              This version maintains the slist_size_increase field
+ *              that are used in sanity checks in the flush routines.
  *
- *		All this is needed as the fractal heap needs to be
- *		able to dirty, resize and/or move entries during the
- *		flush.
+ *              All this is needed as the fractal heap needs to be
+ *              able to dirty, resize and/or move entries during the
+ *              flush.
  *
- *		JRM -- 12/13/14
- *		Note that we do not set cache_ptr->slist_changed to TRUE
- *		in this case, as the structure of the slist is not
- *		modified.
+ *              JRM -- 12/13/14
+ *              Note that we do not set cache_ptr->slist_changed to TRUE
+ *              in this case, as the structure of the slist is not
+ *              modified.
  *
- *		JRM -- 9/1/15
- *		Added code to maintain the cache_ptr->slist_ring_len
- *		and cache_ptr->slist_ring_size arrays.
+ *              JRM -- 9/1/15
+ *              Added code to maintain the cache_ptr->slist_ring_len
+ *              and cache_ptr->slist_ring_size arrays.
  *
  *              JRM -- 4/29/20
  *              Reworked macro to support the slist_enabled field 
@@ -3852,7 +3852,7 @@ typedef struct H5C_tag_info_t {
  *		one.
  *
  * entry_watched_for_removal:	Pointer to an instance of H5C_cache_entry_t
- *		which contains the 'next' entry for an iteration.  Removing
+ *              which contains the 'next' entry for an iteration.  Removing
  *              this entry must trigger a rescan of the iteration, so each
  *              entry removed from the cache is compared against this pointer
  *              and the pointer is reset to NULL if the watched entry is 
diff --git a/test/cache.c b/test/cache.c
index f728ce1..46d8481 100644
--- a/test/cache.c
+++ b/test/cache.c
@@ -3067,15 +3067,15 @@ check_insert_entry(unsigned paged)
             /* Verify that the flush marker got set correctly */
         if((i == 1) || (i == 3)) {
 
-        if(!((entry_ptr->header).flush_marker)) {
+            if(!((entry_ptr->header).flush_marker)) {
 
                     pass = FALSE;
                     failure_mssg = "Unexpected insert results 5.";
-        }
+            }
         } else if((entry_ptr->header).flush_marker) {
 
-                pass = FALSE;
-                failure_mssg = "Unexpected insert results 6.";
+            pass = FALSE;
+            failure_mssg = "Unexpected insert results 6.";
         }
     }