[svn-r27707] Description:

    Misc. minor cleanups in preparation for merging "metadata rings" branch to
trunk.

Tested on:
    MacOSX/64 10.10.5 (amazon) w/serial
    (Too minor to require h5committest)

4 files changed, 97 insertions, 157 deletions

diff --git a/src/H5C.c b/src/H5C.c
index c478173..b360e9d 100644
--- a/src/H5C.c
+++ b/src/H5C.c
@@ -1009,13 +1009,6 @@ done:
  *		all unprotected entries should be flushed before the
  *		function returns failure.
  *
- *		The primary_dxpl_id and secondary_dxpl_id parameters
- *		specify the dxpl_ids used on the first write occasioned
- *		by the flush (primary_dxpl_id), and on all subsequent
- *		writes (secondary_dxpl_id).  This is useful in the metadata
- *		cache, but may not be needed elsewhere.  If so, just use the
- *		same dxpl_id for both parameters.
- *
  * Return:      Non-negative on success/Negative on failure or if there was
  *		a request to flush all items and something was protected.
  *
@@ -1072,17 +1065,13 @@ H5C_flush_cache(H5F_t *f, hid_t dxpl_id, unsigned flags)
     HDassert( cache_ptr->slist_ptr );
 
 #if H5C_DO_EXTREME_SANITY_CHECKS
-    if ( ( H5C_validate_protected_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
-         ( H5C_validate_lru_list(cache_ptr) < 0 ) ) {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                    "an extreme sanity check failed on entry.\n");
-    }
+    if((H5C_validate_protected_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_pinned_entry_list(cache_ptr) < 0) ||
+            (H5C_validate_lru_list(cache_ptr) < 0))
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "an extreme sanity check failed on entry.\n");
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
 
     ignore_protected = ( (flags & H5C__FLUSH_IGNORE_PROTECTED_FLAG) != 0 );
-
     destroy = ( (flags & H5C__FLUSH_INVALIDATE_FLAG) != 0 );
 
     /* note that flush_marked_entries is set to FALSE if destroy is TRUE */
@@ -1092,12 +1081,11 @@ H5C_flush_cache(H5F_t *f, hid_t dxpl_id, unsigned flags)
                            );
 
     HDassert( ! ( destroy && ignore_protected ) );
-
     HDassert( ! ( cache_ptr->flush_in_progress ) );
 
     cache_ptr->flush_in_progress = TRUE;
 
-    if ( destroy ) {
+    if(destroy) {
         if(H5C_flush_invalidate_cache(f, dxpl_id, flags) < 0)
             HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "flush invalidate failed.")
     } else {
@@ -1433,11 +1421,9 @@ H5C_flush_cache(H5F_t *f, hid_t dxpl_id, unsigned flags)
     }
 
 done:
-
     cache_ptr->flush_in_progress = FALSE;
 
     FUNC_LEAVE_NOAPI(ret_value)
-
 } /* H5C_flush_cache() */
 
 
@@ -2928,7 +2914,7 @@ H5C_protect(H5F_t *		f,
          ( H5C_validate_pinned_entry_list(cache_ptr) < 0 ) ||
          ( H5C_validate_lru_list(cache_ptr) < 0 ) ) {
 
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, NULL, \
                     "an extreme sanity check failed on entry.\n");
     }
 #endif /* H5C_DO_EXTREME_SANITY_CHECKS */
@@ -6892,11 +6878,9 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5C_flush_invalidate_cache(const H5F_t * f,
-                           hid_t    dxpl_id,
-			   unsigned flags)
+H5C_flush_invalidate_cache(const H5F_t * f, hid_t dxpl_id, unsigned flags)
 {
-    H5C_t *		cache_ptr = f->shared->cache;
+    H5C_t *		cache_ptr;
     hbool_t             restart_slist_scan;
     int32_t		protected_entries = 0;
     int32_t		i;
@@ -6921,10 +6905,12 @@ H5C_flush_invalidate_cache(const H5F_t * f,
 
     FUNC_ENTER_NOAPI(FAIL)
 
-    HDassert( f );
-    HDassert( cache_ptr );
-    HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
-    HDassert( cache_ptr->slist_ptr );
+    HDassert(f);
+    HDassert(f->shared);
+    cache_ptr = f->shared->cache;
+    HDassert(cache_ptr);
+    HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC);
+    HDassert(cache_ptr->slist_ptr);
 
     /* Filter out the flags that are not relevant to the flush/invalidate.
      * At present, only the H5C__FLUSH_CLEAR_ONLY_FLAG is kept.
@@ -7034,37 +7020,26 @@ H5C_flush_invalidate_cache(const H5F_t * f,
             cache_ptr->slist_change_in_serialize = FALSE;
 
             /* this done, start the scan of the slist */
-
             restart_slist_scan = TRUE;
-
-            while ( ( restart_slist_scan ) || ( node_ptr != NULL ) )
-            {
-                if ( restart_slist_scan )
-                {
+            while(restart_slist_scan || (node_ptr != NULL)) {
+                if(restart_slist_scan) {
                     restart_slist_scan = FALSE;
 
                     /* Start at beginning of skip list */
                     node_ptr = H5SL_first(cache_ptr->slist_ptr);
-
-                    if ( node_ptr == NULL )
-                    {
+                    if(node_ptr == NULL)
                         /* the slist is empty -- break out of inner loop */
                         break;
-                    }
-                    HDassert( node_ptr != NULL );
 
                     /* Get cache entry for this node */
                     next_entry_ptr = (H5C_cache_entry_t *)H5SL_item(node_ptr);
+                    if ( NULL == next_entry_ptr )
+                        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "next_entry_ptr == NULL ?!?!")
 
-                    if(NULL == next_entry_ptr)
-                        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                                    "next_entry_ptr == NULL ?!?!")
-
-                    HDassert( next_entry_ptr->magic == \
-                              H5C__H5C_CACHE_ENTRY_T_MAGIC );
-                    HDassert( next_entry_ptr->is_dirty );
-                    HDassert( next_entry_ptr->in_slist );
-                }
+                    HDassert(next_entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+                    HDassert(next_entry_ptr->is_dirty);
+                    HDassert(next_entry_ptr->in_slist);
+                } /* end if */
 
                 entry_ptr = next_entry_ptr;
 
@@ -7079,27 +7054,25 @@ H5C_flush_invalidate_cache(const H5F_t * f,
                  * slist if we find them.  However, best we do some extra
                  * sanity checking just in case.
                  */
-
-                HDassert( entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC );
-                HDassert( entry_ptr->in_slist );
-                HDassert( entry_ptr->is_dirty );
+                HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+                HDassert(entry_ptr->in_slist);
+                HDassert(entry_ptr->is_dirty);
 
                 /* increment node pointer now, before we delete its target
                  * from the slist.
                  */
-
                 node_ptr = H5SL_next(node_ptr);
-                if ( node_ptr != NULL ) {
+                if(node_ptr != NULL) {
                     next_entry_ptr = (H5C_cache_entry_t *)H5SL_item(node_ptr);
-                    if ( NULL == next_entry_ptr )
+                    if(NULL == next_entry_ptr)
                         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "next_entry_ptr == NULL ?!?!")
-                    HDassert( next_entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC );
-                    HDassert( next_entry_ptr->is_dirty );
-                    HDassert( next_entry_ptr->in_slist );
-                    HDassert( entry_ptr != next_entry_ptr );
-                } else {
+                    HDassert(next_entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
+                    HDassert(next_entry_ptr->is_dirty);
+                    HDassert(next_entry_ptr->in_slist);
+                    HDassert(entry_ptr != next_entry_ptr);
+                } /* end if */
+                else
                     next_entry_ptr = NULL;
-	        }
 
                 /* Note that we now remove nodes from the slist as we flush
                  * the associated entries, instead of leaving them there
@@ -7111,30 +7084,26 @@ H5C_flush_invalidate_cache(const H5F_t * f,
                  * flush, we must keep the slist in cannonical form at all
                  * times.
                  */
-
-                HDassert( entry_ptr != NULL );
-                HDassert( entry_ptr->in_slist );
+                HDassert(entry_ptr != NULL);
+                HDassert(entry_ptr->in_slist);
 
                 if ( ( ! entry_ptr->flush_me_last ) ||
                      ( ( entry_ptr->flush_me_last ) &&
                        ( cache_ptr->num_last_entries >=
                          cache_ptr->slist_len ) ) ) {
-
-                    if ( entry_ptr->is_protected ) {
-
+                    if(entry_ptr->is_protected) {
                         /* we have major problems -- but lets flush
                          * everything we can before we flag an error.
                          */
                         protected_entries++;
-
-                    } else if ( entry_ptr->is_pinned ) {
+                    } else if(entry_ptr->is_pinned) {
 
                         /* Test to see if we are can flush the entry now.
                          * If we can, go ahead and flush, but don't tell
                          * H5C__flush_single_entry() to destroy the entry
                          * as pinned entries can't be evicted.
                          */
-                        if(entry_ptr->flush_dep_height == curr_flush_dep_height ) {
+                        if(entry_ptr->flush_dep_height == curr_flush_dep_height) {
 #if H5C_DO_SANITY_CHECKS
                             /* update flushed_slist_len & flushed_slist_size 
                              * before the flush.  Note that the entry will 
@@ -7151,7 +7120,6 @@ H5C_flush_invalidate_cache(const H5F_t * f,
 
                             if(H5C__flush_single_entry(f, dxpl_id, entry_ptr, H5C__NO_FLAGS_SET, entry_size_change_ptr) < 0)
                                 HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "dirty pinned entry flush failed.")
-
 #if H5C_DO_SANITY_CHECKS
                             /* entry size may have changed during the flush.
                              * Update flushed_slist_size to account for this.
@@ -7160,10 +7128,8 @@ H5C_flush_invalidate_cache(const H5F_t * f,
 #endif /* H5C_DO_SANITY_CHECKS */
 
                             flushed_during_dep_loop = TRUE;
-
-                            if ( ( cache_ptr->slist_change_in_serialize ) ||
-                                 ( cache_ptr->slist_change_in_pre_serialize ) )
-                            {
+                            if((cache_ptr->slist_change_in_serialize) ||
+                                    (cache_ptr->slist_change_in_pre_serialize)) {
                                 /* The slist has been modified by something
                                  * other than the simple removal of the
                                  * of the flushed entry after the flush.
@@ -7172,18 +7138,17 @@ H5C_flush_invalidate_cache(const H5F_t * f,
                                  * scan through the slist, so restart it.
                                  */
                                 restart_slist_scan = TRUE;
-                                cache_ptr->slist_change_in_pre_serialize 
-                                    = FALSE;
+                                cache_ptr->slist_change_in_pre_serialize = FALSE;
                                 cache_ptr->slist_change_in_serialize = FALSE;
 				H5C__UPDATE_STATS_FOR_SLIST_SCAN_RESTART(cache_ptr);
-                            }
+                            } /* end if */
                         } /* end if */
                         else if(entry_ptr->flush_dep_height < curr_flush_dep_height)
                             /* This shouldn't happen -- if it does, just scream and die.  */
-                            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL,  "dirty entry below current flush dep. height.")
+                            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "dirty entry below current flush dep. height.")
                     } /* end if */
                     else {
-                        if(entry_ptr->flush_dep_height == curr_flush_dep_height ){
+                        if(entry_ptr->flush_dep_height == curr_flush_dep_height) {
 #if H5C_DO_SANITY_CHECKS
                             /* update flushed_slist_len & flushed_slist_size 
                              * before the flush.  Note that the entry will 
@@ -7198,9 +7163,10 @@ H5C_flush_invalidate_cache(const H5F_t * f,
 		            entry_size_change = 0;
 #endif /* H5C_DO_SANITY_CHECKS */
 
-                            if(H5C__flush_single_entry(f, dxpl_id, entry_ptr, (cooked_flags | H5C__FLUSH_INVALIDATE_FLAG | H5C__DEL_FROM_SLIST_ON_DESTROY_FLAG), entry_size_change_ptr) < 0)
+                            if(H5C__flush_single_entry(f, dxpl_id, entry_ptr,
+                                        (cooked_flags | H5C__FLUSH_INVALIDATE_FLAG | H5C__DEL_FROM_SLIST_ON_DESTROY_FLAG), 
+                                        entry_size_change_ptr) < 0)
                                 HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "dirty entry flush destroy failed.")
-
 #if H5C_DO_SANITY_CHECKS
                             /* entry size may have changed during the flush.
                              * Update flushed_slist_size to account for this.
@@ -7210,9 +7176,8 @@ H5C_flush_invalidate_cache(const H5F_t * f,
 
                             flushed_during_dep_loop = TRUE;
 
-                            if ((cache_ptr->slist_change_in_serialize) ||
-                                (cache_ptr->slist_change_in_pre_serialize))
-                            {
+                            if((cache_ptr->slist_change_in_serialize) ||
+                                    (cache_ptr->slist_change_in_pre_serialize)) {
                                 /* The slist has been modified by something
                                  * other than the simple removal of the
                                  * of the flushed entry after the flush.
@@ -7221,15 +7186,14 @@ H5C_flush_invalidate_cache(const H5F_t * f,
                                  * scan through the slist, so restart it.
                                  */
                                 restart_slist_scan = TRUE;
-                                cache_ptr->slist_change_in_pre_serialize
-                                    = FALSE;
+                                cache_ptr->slist_change_in_pre_serialize = FALSE;
                                 cache_ptr->slist_change_in_serialize = FALSE;
 				H5C__UPDATE_STATS_FOR_SLIST_SCAN_RESTART(cache_ptr)
-                            }
+                            } /* end if */
                         } /* end if */
                         else if(entry_ptr->flush_dep_height < curr_flush_dep_height)
                             /* This shouldn't happen -- if it does, just scream and die.  */
-                            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL,  "dirty entry below current flush dep. height.")
+                            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "dirty entry below current flush dep. height.")
                     } /* end else */
                 } /* end if */
             } /* end while loop scanning skip list */
@@ -7244,13 +7208,12 @@ H5C_flush_invalidate_cache(const H5F_t * f,
              * out from under us.
              */
 
-            if ( node_ptr == NULL ) {
-
-                HDassert( (flushed_slist_len + cache_ptr->slist_len) ==
-                          (initial_slist_len + cache_ptr->slist_len_increase) );
-                HDassert( (flushed_slist_size + (int64_t)cache_ptr->slist_size) ==
-                          ((int64_t)initial_slist_size + cache_ptr->slist_size_increase) );
-            }
+            if(node_ptr == NULL) {
+                HDassert((flushed_slist_len + cache_ptr->slist_len) ==
+                        (initial_slist_len + cache_ptr->slist_len_increase));
+                HDassert((flushed_slist_size + (int64_t)cache_ptr->slist_size) ==
+                        ((int64_t)initial_slist_size + cache_ptr->slist_size_increase));
+            } /* end if */
 #endif /* H5C_DO_SANITY_CHECKS */
 
             /* Since we are doing a destroy, we must make a pass through
@@ -7264,42 +7227,36 @@ H5C_flush_invalidate_cache(const H5F_t * f,
              *
              * Writes to disk are possible here.
              */
-            for ( i = 0; i < H5C__HASH_TABLE_LEN; i++ )
-            {
+            for(i = 0; i < H5C__HASH_TABLE_LEN; i++) {
                 next_entry_ptr = cache_ptr->index[i];
 
-                while ( next_entry_ptr != NULL )
-                {
+                while(next_entry_ptr != NULL) {
                     entry_ptr = next_entry_ptr;
-                    HDassert( entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC );
+                    HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
 
                     next_entry_ptr = entry_ptr->ht_next;
-                    HDassert ( ( next_entry_ptr == NULL ) ||
-                               ( next_entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC ) );
+                    HDassert((next_entry_ptr == NULL) ||
+                            (next_entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC));
 
                     if ( ( ! entry_ptr->flush_me_last ) ||
                          ( ( entry_ptr->flush_me_last ) &&
                            ( cache_ptr->num_last_entries >=
                              cache_ptr->slist_len ) ) ) {
 
-                        if ( entry_ptr->is_protected ) {
-
+                        if(entry_ptr->is_protected) {
                             /* we have major problems -- but lets flush and 
                              * destroy everything we can before we flag an 
                              * error.
                              */
                             protected_entries++;
-
-                            if ( ! entry_ptr->in_slist ) {
-
-                                HDassert( !(entry_ptr->is_dirty) );
-                            }
-                        } else if ( ! ( entry_ptr->is_pinned ) ) {
+                            if(!entry_ptr->in_slist)
+                                HDassert(!(entry_ptr->is_dirty));
+                        } else if(!(entry_ptr->is_pinned)) {
 
                             /* Test to see if we are can flush the entry now.
                              * If we can, go ahead and flush.
                              */
-                            if(entry_ptr->flush_dep_height == curr_flush_dep_height ){
+                            if(entry_ptr->flush_dep_height == curr_flush_dep_height) {
 				/* if *entry_ptr is dirty, it is possible 
                                  * that one or more other entries may be 
                                  * either removed from the cache, loaded 
@@ -7330,21 +7287,20 @@ H5C_flush_invalidate_cache(const H5F_t * f,
                                 if(H5C__flush_single_entry(f, dxpl_id, entry_ptr, (cooked_flags | H5C__FLUSH_INVALIDATE_FLAG | H5C__DEL_FROM_SLIST_ON_DESTROY_FLAG), NULL) < 0)
                                     HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Entry flush destroy failed.")
 
-				if ( entry_was_dirty ) {
-
+				if(entry_was_dirty) {
                                     /* update stats for hash bucket scan
                                      * restart here.
                                      *                   -- JRM 
                                      */
                                     next_entry_ptr = cache_ptr->index[i];
 				    H5C__UPDATE_STATS_FOR_HASH_BUCKET_SCAN_RESTART(cache_ptr)
-                                }
+                                } /* end if */
 
                                 flushed_during_dep_loop = TRUE;
                             } /* end if */
                             else if(entry_ptr->flush_dep_height < curr_flush_dep_height)
                                 /* This shouldn't happen -- if it does, just scream and die.  */
-                                HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL,  "dirty entry below current flush dep. height.")
+                                HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "dirty entry below current flush dep. height.")
                         } /* end if */
                     } /* end if */
                     /* We can't do anything if the entry is pinned.  The
@@ -7371,16 +7327,11 @@ H5C_flush_invalidate_cache(const H5F_t * f,
                      *         in case I am wrong.
                      *                                    -- JRM
                      */
-                    if ( ( next_entry_ptr != NULL ) &&
-                         ( next_entry_ptr->magic !=
-                           H5C__H5C_CACHE_ENTRY_T_MAGIC ) ) {
-
+                    if((next_entry_ptr != NULL) && (next_entry_ptr->magic != H5C__H5C_CACHE_ENTRY_T_MAGIC))
                         /* Something horrible has happened to
                          * *next_entry_ptr -- scream and die.
                          */
-                        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                                    "next_entry_ptr->magic is invalid?!?!?.")
-                    }
+                        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "next_entry_ptr->magic is invalid?!?!?.")
                 } /* end while loop scanning hash table bin */
             } /* end for loop scanning hash table */
 
@@ -7407,52 +7358,41 @@ H5C_flush_invalidate_cache(const H5F_t * f,
 	   /* The number of pinned entries is positive, and it is not
 	    * declining.  Scream and die.
 	    */
-
-            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, \
-                        "Pinned entry count not decreasing, cur_pel_len = %d, old_pel_len = %d", (int)cur_pel_len, (int)old_pel_len)
-
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Pinned entry count not decreasing, cur_pel_len = %d, old_pel_len = %d", (int)cur_pel_len, (int)old_pel_len)
         } else if ( ( cur_pel_len == 0 ) && ( old_pel_len == 0 ) ) {
-
 	    /* increment the pass count */
 	    passes++;
 	}
 
-	if ( passes >= H5C__MAX_PASSES_ON_FLUSH ) {
-
+	if(passes >= H5C__MAX_PASSES_ON_FLUSH)
 	    /* we have exceeded the maximum number of passes through the
 	     * cache to flush and destroy all entries.  Scream and die.
 	     */
-
-            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, \
-	                "Maximum passes on flush exceeded.")
-	}
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Maximum passes on flush exceeded.")
     } /* main while loop */
 
     /* Invariants, after destroying all entries in the hash table */
-    HDassert( cache_ptr->index_size == 0 );
-    HDassert( cache_ptr->clean_index_size == 0 );
-    HDassert( cache_ptr->dirty_index_size == 0 );
-    HDassert( cache_ptr->slist_len == 0 );
-    HDassert( cache_ptr->slist_size == 0 );
-    HDassert( cache_ptr->pel_len == 0 );
-    HDassert( cache_ptr->pel_size == 0 );
-    HDassert( cache_ptr->pl_len == 0 );
-    HDassert( cache_ptr->pl_size == 0 );
-    HDassert( cache_ptr->LRU_list_len == 0 );
-    HDassert( cache_ptr->LRU_list_size == 0 );
-
+    HDassert(cache_ptr->index_size == 0);
+    HDassert(cache_ptr->clean_index_size == 0);
+    HDassert(cache_ptr->dirty_index_size == 0);
+    HDassert(cache_ptr->slist_len == 0);
+    HDassert(cache_ptr->slist_size == 0);
+    HDassert(cache_ptr->pel_len == 0);
+    HDassert(cache_ptr->pel_size == 0);
+    HDassert(cache_ptr->pl_len == 0);
+    HDassert(cache_ptr->pl_size == 0);
+    HDassert(cache_ptr->LRU_list_len == 0);
+    HDassert(cache_ptr->LRU_list_size == 0);
 
-    HDassert( protected_entries <= cache_ptr->pl_len );
 
-    if ( protected_entries > 0 ) {
+    HDassert(protected_entries <= cache_ptr->pl_len);
 
-        HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, \
-	            "Cache has protected entries.")
+    if(protected_entries > 0)
+        HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Cache has protected entries.")
 
-    } else if ( cur_pel_len > 0 ) {
+    else if(cur_pel_len > 0) {
 
-        HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, \
-	            "Can't unpin all pinned entries.")
+        HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't unpin all pinned entries.")
 
     }
 
@@ -7630,7 +7570,7 @@ H5C__flush_single_entry(const H5F_t *f, hid_t dxpl_id, H5C_cache_entry_t *entry_
         unsigned coll_meta;         /* Collective metadata write flag */
 
         /* Get the dataset transfer property list */
-        if(NULL == (dxpl = H5I_object(dxpl_id)))
+        if(NULL == (dxpl = (H5P_genplist_t *)H5I_object(dxpl_id)))
             HGOTO_ERROR(H5E_CACHE, H5E_BADTYPE, FAIL, "not a dataset transfer property list")
 
         /* Get the collective metadata write property */
diff --git a/src/H5FScache.c b/src/H5FScache.c
index 25a9c5e..9accfc4 100644
--- a/src/H5FScache.c
+++ b/src/H5FScache.c
@@ -343,7 +343,7 @@ H5FS__cache_hdr_image_len(const void *_thing, size_t *image_len,
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5FS__cache_hdf_pre_serialize
+ * Function:	H5FS__cache_hdr_pre_serialize
  *
  * Purpose:	The free space manager header contains the address, size, and 
  *		allocation size of the free space manager section info.  However,
diff --git a/src/H5Fsuper.c b/src/H5Fsuper.c
index ce3f2ea..2262ccd 100644
--- a/src/H5Fsuper.c
+++ b/src/H5Fsuper.c
@@ -222,7 +222,7 @@ H5F_super_ext_close(H5F_t *f, H5O_loc_t *ext_ptr, hid_t dxpl_id,
 
         /* Decrement refcount on superblock extension's object header in memory */
         if(H5O_dec_rc_by_loc(ext_ptr, dxpl_id) < 0)
-           HDONE_ERROR(H5E_FILE, H5E_CANTDEC, FAIL, "unable to decrement refcount on superblock extension")
+            HGOTO_ERROR(H5E_FILE, H5E_CANTDEC, FAIL, "unable to decrement refcount on superblock extension");
     } /* end if */
 
     /* Twiddle the number of open objects to avoid closing the file. */
diff --git a/src/H5Pdxpl.c b/src/H5Pdxpl.c
index b5bc720..cea94e3 100644
--- a/src/H5Pdxpl.c
+++ b/src/H5Pdxpl.c
@@ -34,7 +34,7 @@
 /* Headers */
 /***********/
 #include "H5private.h"		/* Generic Functions			*/
-#include "H5ACprivate.h"    /* Cache */
+#include "H5ACprivate.h"        /* Cache                                */
 #include "H5Dprivate.h"		/* Datasets				*/
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5Iprivate.h"		/* IDs			  		*/