Misc. style cleanups from the page_buffering branch.

1 files changed, 218 insertions, 411 deletions

diff --git a/src/H5C.c b/src/H5C.c
index a10978b..ba23b50 100644
--- a/src/H5C.c
+++ b/src/H5C.c
@@ -75,7 +75,7 @@
 /****************/
 
 #include "H5Cmodule.h"          /* This source code file is part of the H5C module */
-#define H5F_FRIEND		/*suppress error about including H5Fpkg	  */
+#define H5F_FRIEND		/* suppress error about including H5Fpkg  */
 
 
 /***********/
@@ -264,10 +264,10 @@ H5C_create(size_t		      max_cache_size,
 	HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
 
     if(NULL == (cache_ptr->slist_ptr = H5SL_create(H5SL_TYPE_HADDR, NULL)))
-        HGOTO_ERROR(H5E_CACHE, H5E_CANTCREATE, NULL, "can't create skip list.")
+        HGOTO_ERROR(H5E_CACHE, H5E_CANTCREATE, NULL, "can't create skip list")
 
     if(NULL == (cache_ptr->tag_list = H5SL_create(H5SL_TYPE_HADDR, NULL)))
-        HGOTO_ERROR(H5E_CACHE, H5E_CANTCREATE, NULL, "can't create skip list for tagged entry addresses.")
+        HGOTO_ERROR(H5E_CACHE, H5E_CANTCREATE, NULL, "can't create skip list for tagged entry addresses")
 
     /* If we get this far, we should succeed.  Go ahead and initialize all
      * the fields.
@@ -461,12 +461,9 @@ H5C_create(size_t		      max_cache_size,
     cache_ptr->rdfsm_settled		= FALSE;
     cache_ptr->mdfsm_settled		= FALSE;
 
-    if ( H5C_reset_cache_hit_rate_stats(cache_ptr) != SUCCEED ) {
-
+    if(H5C_reset_cache_hit_rate_stats(cache_ptr) < 0)
         /* this should be impossible... */
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, NULL, \
-                    "H5C_reset_cache_hit_rate_stats failed.")
-    }
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, NULL, "H5C_reset_cache_hit_rate_stats failed")
 
     H5C_stats__reset(cache_ptr);
 
@@ -931,9 +928,9 @@ H5C_expunge_entry(H5F_t *f, hid_t dxpl_id, const H5C_class_t *type,
 
     /* Check for entry being pinned or protected */
     if(entry_ptr->is_protected)
-        HGOTO_ERROR(H5E_CACHE, H5E_CANTEXPUNGE, FAIL, "Target entry is protected.")
+        HGOTO_ERROR(H5E_CACHE, H5E_CANTEXPUNGE, FAIL, "Target entry is protected")
     if(entry_ptr->is_pinned)
-        HGOTO_ERROR(H5E_CACHE, H5E_CANTEXPUNGE, FAIL, "Target entry is pinned.")
+        HGOTO_ERROR(H5E_CACHE, H5E_CANTEXPUNGE, FAIL, "Target entry is pinned")
 #ifdef H5_HAVE_PARALLEL
     if(entry_ptr->coll_access) {
         entry_ptr->coll_access = FALSE;
@@ -1081,7 +1078,7 @@ H5C_flush_cache(H5F_t *f, hid_t dxpl_id, unsigned flags)
 
     if(destroy) {
         if(H5C_flush_invalidate_cache(f, dxpl_id, flags) < 0)
-            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "flush invalidate failed.")
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "flush invalidate failed")
     } /* end if */
     else {
 	/* flush each ring, starting from the outermost ring and 
@@ -1139,7 +1136,7 @@ H5C_flush_cache(H5F_t *f, hid_t dxpl_id, unsigned flags)
             } /* end if */
 
 	    if(H5C_flush_ring(f, dxpl_id, ring, flags) < 0)
-                HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "flush ring failed.")
+                HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "flush ring failed")
             ring++;
         } /* end while */
     } /* end else */
@@ -1180,7 +1177,6 @@ H5C_flush_to_min_clean(H5F_t * f,
 		       hid_t    dxpl_id)
 {
     H5C_t *             cache_ptr;
-    herr_t      	result;
     hbool_t		write_permitted;
 #if 0 /* modified code -- commented out for now */ /* JRM */
     int			i;
@@ -1202,25 +1198,16 @@ H5C_flush_to_min_clean(H5F_t * f,
     HDassert( cache_ptr );
     HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
 
-    if ( cache_ptr->check_write_permitted != NULL ) {
-
-        result = (cache_ptr->check_write_permitted)(f, &write_permitted);
-
-        if ( result < 0 ) {
-
-            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                        "Can't get write_permitted")
-        }
-    } else {
-
+    if(cache_ptr->check_write_permitted != NULL) {
+        if((cache_ptr->check_write_permitted)(f, &write_permitted) < 0)
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "can't get write_permitted")
+    } /* end if */
+    else
         write_permitted = cache_ptr->write_permitted;
-    }
 
-    if ( ! write_permitted ) {
+    if(!write_permitted)
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "cache write is not permitted!?!")
 
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                    "cache write is not permitted!?!\n");
-    }
 #if 1 /* original code */
     if(H5C__make_space_in_cache(f, dxpl_id, (size_t)0, write_permitted) < 0)
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5C__make_space_in_cache failed")
@@ -1261,12 +1248,8 @@ H5C_flush_to_min_clean(H5F_t * f,
          */
         flushed_entries_list = (haddr_t *)H5MM_malloc(sizeof(haddr_t) *
                                               (size_t)(cache_ptr->slist_len));
-
-        if ( flushed_entries_list == NULL ) {
-
-            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, \
-                        "memory allocation failed for flushed entries list")
-        }
+        if(flushed_entries_list == NULL)
+            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed for flushed entries list")
 
         /* Scan the dirty LRU list from tail forward and mark sufficient
          * entries to free up the necessary space.  Keep a list of the
@@ -1296,13 +1279,8 @@ H5C_flush_to_min_clean(H5F_t * f,
 
 
         /* Flush the marked entries */
-	result = H5C_flush_cache(f, primary_dxpl_id, secondary_dxpl_id,
-                                 H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_IGNORE_PROTECTED_FLAG);
-
-        if ( result < 0 ) {
-
-            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5C_flush_cache failed.")
-        }
+        if(H5C_flush_cache(f, primary_dxpl_id, secondary_dxpl_id, H5C__FLUSH_MARKED_ENTRIES_FLAG | H5C__FLUSH_IGNORE_PROTECTED_FLAG) < 0)
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5C_flush_cache failed")
 
         /* Now touch up the LRU list so as to place the flushed entries in
          * the order they they would be in if we had flushed them in the
@@ -1428,9 +1406,9 @@ H5C_insert_entry(H5F_t *             f,
 
     if(test_entry_ptr != NULL) {
         if(test_entry_ptr == entry_ptr)
-            HGOTO_ERROR(H5E_CACHE, H5E_CANTINS, FAIL, "entry already in cache.")
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTINS, FAIL, "entry already in cache")
         else
-            HGOTO_ERROR(H5E_CACHE, H5E_CANTINS, FAIL, "duplicate entry in cache.")
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTINS, FAIL, "duplicate entry in cache")
     } /* end if */
 
     entry_ptr->magic = H5C__H5C_CACHE_ENTRY_T_MAGIC;
@@ -1523,7 +1501,7 @@ H5C_insert_entry(H5F_t *             f,
     if(cache_ptr->flash_size_increase_possible &&
             (entry_ptr->size > cache_ptr->flash_size_increase_threshold))
         if(H5C__flash_increase_cache_size(cache_ptr, 0, entry_ptr->size) < 0)
-            HGOTO_ERROR(H5E_CACHE, H5E_CANTINS, FAIL, "H5C__flash_increase_cache_size failed.")
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTINS, FAIL, "H5C__flash_increase_cache_size failed")
 
     if(cache_ptr->index_size >= cache_ptr->max_cache_size)
         empty_space = 0;
@@ -1577,7 +1555,7 @@ H5C_insert_entry(H5F_t *             f,
          */
 
         if(H5C__make_space_in_cache(f, dxpl_id, space_needed, write_permitted) < 0)
-            HGOTO_ERROR(H5E_CACHE, H5E_CANTINS, FAIL, "H5C__make_space_in_cache failed.")
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTINS, FAIL, "H5C__make_space_in_cache failed")
     }
 
     H5C__INSERT_IN_INDEX(cache_ptr, entry_ptr, FAIL)
@@ -2120,7 +2098,7 @@ H5C_resize_entry(void *thing, size_t new_size)
 
     /* Check for usage errors */
     if(new_size <= 0)
-        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "New size is non-positive.")
+        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "New size is non-positive")
     if(!(entry_ptr->is_pinned || entry_ptr->is_protected))
         HGOTO_ERROR(H5E_CACHE, H5E_BADTYPE, FAIL, "Entry isn't pinned or protected??")
 
@@ -2454,9 +2432,9 @@ H5C_protect(H5F_t *		f,
     /* first check to see if the target is in cache */
     H5C__SEARCH_INDEX(cache_ptr, addr, entry_ptr, NULL)
 
-    if ( entry_ptr != NULL ) {
+    if(entry_ptr != NULL) {
         if(entry_ptr->ring != ring)
-            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, NULL, "ring type mismatch occured for cache entry\n")
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, NULL, "ring type mismatch occured for cache entry")
 
         HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
 
@@ -2466,7 +2444,7 @@ H5C_protect(H5F_t *		f,
              * image of the prefetched entry.
              */
             if(H5C__deserialize_prefetched_entry(f, dxpl_id, cache_ptr, &entry_ptr, type, addr, udata) < 0)
-                HGOTO_ERROR(H5E_CACHE, H5E_CANTLOAD, NULL, "can't deserialize prefetched entry.")
+                HGOTO_ERROR(H5E_CACHE, H5E_CANTLOAD, NULL, "can't deserialize prefetched entry")
 
             HDassert(entry_ptr->magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
             HDassert(!entry_ptr->prefetched);
@@ -2581,7 +2559,7 @@ H5C_protect(H5F_t *		f,
              ( entry_ptr->size > cache_ptr->flash_size_increase_threshold ) ) {
 
             if(H5C__flash_increase_cache_size(cache_ptr, 0, entry_ptr->size) < 0)
-                HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, NULL, "H5C__flash_increase_cache_size failed.")
+                HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, NULL, "H5C__flash_increase_cache_size failed")
         }
 
         if(cache_ptr->index_size >= cache_ptr->max_cache_size)
@@ -2653,7 +2631,7 @@ H5C_protect(H5F_t *		f,
              */
 
             if(H5C__make_space_in_cache(f, dxpl_id, space_needed, write_permitted) < 0 )
-                HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, NULL, "H5C__make_space_in_cache failed 1.")
+                HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, NULL, "H5C__make_space_in_cache failed")
         }
 
         /* Insert the entry in the hash table.  It can't be dirty yet, so
@@ -2697,36 +2675,29 @@ H5C_protect(H5F_t *		f,
         was_loaded = TRUE;
     }
 
-    HDassert( entry_ptr->addr == addr );
-    HDassert( entry_ptr->type == type );
-
-    if ( entry_ptr->is_protected ) {
-
-	if ( ( read_only ) && ( entry_ptr->is_read_only ) ) {
-
-	    HDassert( entry_ptr->ro_ref_count > 0 );
+    HDassert(entry_ptr->addr == addr);
+    HDassert(entry_ptr->type == type);
 
+    if(entry_ptr->is_protected) {
+	if(read_only && entry_ptr->is_read_only) {
+	    HDassert(entry_ptr->ro_ref_count > 0);
 	    (entry_ptr->ro_ref_count)++;
-
-	} else {
-
-            HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, NULL, \
-                        "Target already protected & not read only?!?.")
-	}
-    } else {
-
+	} /* end if */
+        else 
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, NULL, "Target already protected & not read only?!?")
+    } /* end if */
+    else {
     	H5C__UPDATE_RP_FOR_PROTECT(cache_ptr, entry_ptr, NULL)
 
     	entry_ptr->is_protected = TRUE;
 
 	if ( read_only ) {
-
 	    entry_ptr->is_read_only = TRUE;
 	    entry_ptr->ro_ref_count = 1;
-	}
+	} /* end if */
 
     	entry_ptr->dirtied = FALSE;
-    }
+    } /* end else */
 
     H5C__UPDATE_CACHE_HIT_RATE_STATS(cache_ptr, hit)
 
@@ -2744,7 +2715,7 @@ H5C_protect(H5F_t *		f,
 
             if ( cache_ptr->check_write_permitted != NULL ) {
                 if((cache_ptr->check_write_permitted)(f, &write_permitted) < 0)
-                    HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, NULL, "Can't get write_permitted 2")
+                    HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, NULL, "Can't get write_permitted")
                 else
                     have_write_permitted = TRUE;
             } else {
@@ -2756,16 +2727,14 @@ H5C_protect(H5F_t *		f,
             }
         }
 
-        if ( ( cache_ptr->resize_enabled ) &&
-             ( cache_ptr->cache_accesses >=
-               (cache_ptr->resize_ctl).epoch_length ) ) {
+        if(cache_ptr->resize_enabled &&
+             (cache_ptr->cache_accesses >= (cache_ptr->resize_ctl).epoch_length)) {
 
             if(H5C__auto_adjust_cache_size(f, dxpl_id, write_permitted) < 0)
-                HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, NULL, "Cache auto-resize failed.")
-        }
-
-        if ( cache_ptr->size_decreased  ) {
+                HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, NULL, "Cache auto-resize failed")
+        } /* end if */
 
+        if(cache_ptr->size_decreased) {
             cache_ptr->size_decreased = FALSE;
 
             /* check to see if the cache is now oversized due to the cache
@@ -2791,9 +2760,9 @@ H5C_protect(H5F_t *		f,
                     cache_ptr->cache_full = TRUE;
 
                 if(H5C__make_space_in_cache(f, dxpl_id, (size_t)0, write_permitted) < 0 )
-                    HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, NULL, "H5C__make_space_in_cache failed 2.")
+                    HGOTO_ERROR(H5E_CACHE, H5E_CANTPROTECT, NULL, "H5C__make_space_in_cache failed")
             }
-        }
+        } /* end if */
     }
 
     /* If we loaded the entry and the entry's type has a 'notify' callback, send
@@ -2860,7 +2829,7 @@ H5C_reset_cache_hit_rate_stats(H5C_t * cache_ptr)
     FUNC_ENTER_NOAPI(FAIL)
 
     if((cache_ptr == NULL) || (cache_ptr->magic != H5C__H5C_T_MAGIC))
-        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "bad cache_ptr on entry.")
+        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "bad cache_ptr on entry")
 
     cache_ptr->cache_hits		= 0;
     cache_ptr->cache_accesses		= 0;
@@ -2900,27 +2869,27 @@ H5C_set_cache_auto_resize_config(H5C_t *cache_ptr,
     FUNC_ENTER_NOAPI(FAIL)
 
     if((cache_ptr == NULL) || (cache_ptr->magic != H5C__H5C_T_MAGIC))
-        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "bad cache_ptr on entry.")
+        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "bad cache_ptr on entry")
     if(config_ptr == NULL)
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "NULL config_ptr on entry.")
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "NULL config_ptr on entry")
     if(config_ptr->version != H5C__CURR_AUTO_SIZE_CTL_VER)
-        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "unknown config version.")
+        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "unknown config version")
 
     /* check general configuration section of the config: */
     if(H5C_validate_resize_config(config_ptr, H5C_RESIZE_CFG__VALIDATE_GENERAL) < 0)
-        HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "error in general configuration fields of new config.")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "error in general configuration fields of new config")
 
     /* check size increase control fields of the config: */
     if(H5C_validate_resize_config(config_ptr, H5C_RESIZE_CFG__VALIDATE_INCREMENT) < 0)
-        HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "error in the size increase control fields of new config.")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "error in the size increase control fields of new config")
 
     /* check size decrease control fields of the config: */
     if(H5C_validate_resize_config(config_ptr, H5C_RESIZE_CFG__VALIDATE_DECREMENT) < 0)
-        HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "error in the size decrease control fields of new config.")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "error in the size decrease control fields of new config")
 
     /* check for conflicts between size increase and size decrease controls: */
     if(H5C_validate_resize_config(config_ptr, H5C_RESIZE_CFG__VALIDATE_INTERACTIONS) < 0)
-        HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "conflicting threshold fields in new config.")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, FAIL, "conflicting threshold fields in new config")
 
     /* will set the increase possible fields to FALSE later if needed */
     cache_ptr->size_increase_possible       = TRUE;
@@ -2940,7 +2909,7 @@ H5C_set_cache_auto_resize_config(H5C_t *cache_ptr,
             break;
 
         default: /* should be unreachable */
-            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Unknown incr_mode?!?!?.")
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Unknown incr_mode?!?!?")
     } /* end switch */
 
     /* logically, this is were configuration for flash cache size increases
@@ -2974,7 +2943,7 @@ H5C_set_cache_auto_resize_config(H5C_t *cache_ptr,
             break;
 
         default: /* should be unreachable */
-            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Unknown decr_mode?!?!?.")
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Unknown decr_mode?!?!?")
     } /* end switch */
 
     if(config_ptr->max_size == config_ptr->min_size) {
@@ -3030,18 +2999,18 @@ H5C_set_cache_auto_resize_config(H5C_t *cache_ptr,
 
     if(H5C_reset_cache_hit_rate_stats(cache_ptr) < 0)
         /* this should be impossible... */
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5C_reset_cache_hit_rate_stats failed.")
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5C_reset_cache_hit_rate_stats failed")
 
     /* remove excess epoch markers if any */
     if((config_ptr->decr_mode == H5C_decr__age_out_with_threshold) ||
             (config_ptr->decr_mode == H5C_decr__age_out)) {
         if(cache_ptr->epoch_markers_active > cache_ptr->resize_ctl.epochs_before_eviction)
             if(H5C__autoadjust__ageout__remove_excess_markers(cache_ptr) < 0)
-                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "can't remove excess epoch markers.")
+                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "can't remove excess epoch markers")
     } /* end if */
     else if(cache_ptr->epoch_markers_active > 0) {
         if(H5C__autoadjust__ageout__remove_all_markers(cache_ptr) < 0)
-            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "error removing all epoch markers.")
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "error removing all epoch markers")
     }
 
     /* configure flash size increase facility.  We wait until the
@@ -3065,7 +3034,7 @@ H5C_set_cache_auto_resize_config(H5C_t *cache_ptr,
                 break;
 
             default: /* should be unreachable */
-                 HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Unknown flash_incr_mode?!?!?.")
+                 HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Unknown flash_incr_mode?!?!?")
                  break;
         } /* end switch */
     } /* end if */
@@ -3096,7 +3065,7 @@ H5C_set_evictions_enabled(H5C_t *cache_ptr, hbool_t evictions_enabled)
     FUNC_ENTER_NOAPI(FAIL)
 
     if((cache_ptr == NULL) || (cache_ptr->magic != H5C__H5C_T_MAGIC))
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Bad cache_ptr on entry.")
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Bad cache_ptr on entry")
 
     /* There is no fundamental reason why we should not permit
      * evictions to be disabled while automatic resize is enabled.
@@ -3107,7 +3076,7 @@ H5C_set_evictions_enabled(H5C_t *cache_ptr, hbool_t evictions_enabled)
     if((evictions_enabled != TRUE) &&
          ((cache_ptr->resize_ctl.incr_mode != H5C_incr__off) ||
 	   (cache_ptr->resize_ctl.decr_mode != H5C_decr__off)))
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Can't disable evictions when auto resize enabled.")
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Can't disable evictions when auto resize enabled")
 
     cache_ptr->evictions_enabled = evictions_enabled;
 
@@ -3468,9 +3437,9 @@ H5C_unprotect(H5F_t *		  f,
             /* verify that the target entry is in the cache. */
             H5C__SEARCH_INDEX(cache_ptr, addr, test_entry_ptr, FAIL)
             if(test_entry_ptr == NULL)
-                HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, "entry not in hash table?!?.")
+                HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, "entry not in hash table?!?")
             else if(test_entry_ptr != entry_ptr)
-                HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, "hash table contains multiple entries for addr?!?.")
+                HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, "hash table contains multiple entries for addr?!?")
 
             /* Set the 'free file space' flag for the flush, if needed */
             if(free_file_space)
@@ -3493,9 +3462,9 @@ H5C_unprotect(H5F_t *		  f,
             /* verify that the target entry is in the cache. */
             H5C__SEARCH_INDEX(cache_ptr, addr, test_entry_ptr, FAIL)
             if(test_entry_ptr == NULL)
-                HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, "entry not in hash table?!?.")
+                HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, "entry not in hash table?!?")
             else if(test_entry_ptr != entry_ptr)
-                HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, "hash table contains multiple entries for addr?!?.")
+                HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, "hash table contains multiple entries for addr?!?")
 
             if(H5C__flush_single_entry(f, dxpl_id, 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")
@@ -3617,18 +3586,13 @@ H5C_validate_resize_config(H5C_auto_size_ctl_t * config_ptr,
 
     FUNC_ENTER_NOAPI(FAIL)
 
-    if ( config_ptr == NULL ) {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "NULL config_ptr on entry.")
-    }
-
-    if ( config_ptr->version != H5C__CURR_AUTO_SIZE_CTL_VER ) {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Unknown config version.")
-    }
+    if(config_ptr == NULL)
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "NULL config_ptr on entry")
 
+    if(config_ptr->version != H5C__CURR_AUTO_SIZE_CTL_VER)
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Unknown config version")
 
-    if ( (tests & H5C_RESIZE_CFG__VALIDATE_GENERAL) != 0 ) {
+    if((tests & H5C_RESIZE_CFG__VALIDATE_GENERAL) != 0) {
 
         if(config_ptr->max_size > H5C__MAX_MAX_CACHE_SIZE)
             HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "max_size too big")
@@ -3639,43 +3603,29 @@ H5C_validate_resize_config(H5C_auto_size_ctl_t * config_ptr,
         if(config_ptr->min_size > config_ptr->max_size)
             HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "min_size > max_size")
 
-        if ( ( config_ptr->set_initial_size ) &&
-             ( ( config_ptr->initial_size < config_ptr->min_size ) ||
-               ( config_ptr->initial_size > config_ptr->max_size ) ) ) {
-
-            HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, \
-                  "initial_size must be in the interval [min_size, max_size]");
-        }
+        if(config_ptr->set_initial_size &&
+                ((config_ptr->initial_size < config_ptr->min_size) ||
+                    (config_ptr->initial_size > config_ptr->max_size)))
+            HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "initial_size must be in the interval [min_size, max_size]")
 
-        if ( ( config_ptr->min_clean_fraction < (double)0.0f ) ||
-             ( config_ptr->min_clean_fraction > (double)1.0f ) ) {
-
-            HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, \
-                  "min_clean_fraction must be in the interval [0.0, 1.0]");
-        }
-
-        if ( config_ptr->epoch_length < H5C__MIN_AR_EPOCH_LENGTH ) {
+        if((config_ptr->min_clean_fraction < (double)0.0f) ||
+                (config_ptr->min_clean_fraction > (double)1.0f))
+            HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "min_clean_fraction must be in the interval [0.0, 1.0]")
 
+        if(config_ptr->epoch_length < H5C__MIN_AR_EPOCH_LENGTH)
             HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "epoch_length too small")
-        }
-
-        if ( config_ptr->epoch_length > H5C__MAX_AR_EPOCH_LENGTH ) {
 
+        if(config_ptr->epoch_length > H5C__MAX_AR_EPOCH_LENGTH)
             HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "epoch_length too big")
-        }
     } /* H5C_RESIZE_CFG__VALIDATE_GENERAL */
 
 
-    if ( (tests & H5C_RESIZE_CFG__VALIDATE_INCREMENT) != 0 ) {
-
-        if ( ( config_ptr->incr_mode != H5C_incr__off ) &&
-             ( config_ptr->incr_mode != H5C_incr__threshold ) ) {
-
+    if((tests & H5C_RESIZE_CFG__VALIDATE_INCREMENT) != 0) {
+        if((config_ptr->incr_mode != H5C_incr__off) &&
+                (config_ptr->incr_mode != H5C_incr__threshold))
             HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "Invalid incr_mode")
-        }
-
-        if ( config_ptr->incr_mode == H5C_incr__threshold ) {
 
+        if(config_ptr->incr_mode == H5C_incr__threshold) {
             if((config_ptr->lower_hr_threshold < (double)0.0f) ||
                     (config_ptr->lower_hr_threshold > (double)1.0f))
                 HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "lower_hr_threshold must be in the range [0.0, 1.0]")
@@ -3688,33 +3638,24 @@ H5C_validate_resize_config(H5C_auto_size_ctl_t * config_ptr,
              */
         } /* H5C_incr__threshold */
 
-        switch ( config_ptr->flash_incr_mode )
-        {
+        switch(config_ptr->flash_incr_mode) {
             case H5C_flash_incr__off:
                 /* nothing to do here */
                 break;
 
             case H5C_flash_incr__add_space:
-                if ( ( config_ptr->flash_multiple < (double)0.1f ) ||
-                     ( config_ptr->flash_multiple > (double)10.0f ) ) {
-
-                    HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, \
-                        "flash_multiple must be in the range [0.1, 10.0]");
-                }
-
-                if ( ( config_ptr->flash_threshold < (double)0.1f ) ||
-                     ( config_ptr->flash_threshold > (double)1.0f ) ) {
-
-                    HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, \
-                           "flash_threshold must be in the range [0.1, 1.0]");
-                }
+                if((config_ptr->flash_multiple < (double)0.1f) ||
+                        (config_ptr->flash_multiple > (double)10.0f))
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "flash_multiple must be in the range [0.1, 10.0]")
+                if((config_ptr->flash_threshold < (double)0.1f) ||
+                        (config_ptr->flash_threshold > (double)1.0f))
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "flash_threshold must be in the range [0.1, 1.0]")
                 break;
 
             default:
-                HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, \
-                            "Invalid flash_incr_mode");
+                HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "Invalid flash_incr_mode")
                 break;
-        }
+        } /* end switch */
     } /* H5C_RESIZE_CFG__VALIDATE_INCREMENT */
 
 
@@ -3730,35 +3671,23 @@ H5C_validate_resize_config(H5C_auto_size_ctl_t * config_ptr,
         }
 
         if ( config_ptr->decr_mode == H5C_decr__threshold ) {
+            if(config_ptr->upper_hr_threshold > (double)1.0f)
+                HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "upper_hr_threshold must be <= 1.0")
 
-            if ( config_ptr->upper_hr_threshold > (double)1.0f ) {
-
-                HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, \
-                            "upper_hr_threshold must be <= 1.0");
-            }
-
-            if ( ( config_ptr->decrement > (double)1.0f ) ||
-                 ( config_ptr->decrement < (double)0.0f ) ) {
-
-                HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, \
-                            "decrement must be in the interval [0.0, 1.0]");
-            }
+            if((config_ptr->decrement > (double)1.0f) ||
+                    (config_ptr->decrement < (double)0.0f))
+                HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "decrement must be in the interval [0.0, 1.0]")
 
             /* no need to check max_decrement as it is a size_t
              * and thus must be non-negative.
              */
         } /* H5C_decr__threshold */
 
-        if ( ( config_ptr->decr_mode == H5C_decr__age_out ) ||
-             ( config_ptr->decr_mode == H5C_decr__age_out_with_threshold )
-           ) {
-
-            if ( config_ptr->epochs_before_eviction < 1 ) {
-
-                HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, \
-                            "epochs_before_eviction must be positive");
-            }
+        if((config_ptr->decr_mode == H5C_decr__age_out) ||
+                (config_ptr->decr_mode == H5C_decr__age_out_with_threshold)) {
 
+            if(config_ptr->epochs_before_eviction < 1)
+                HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "epochs_before_eviction must be positive")
             if(config_ptr->epochs_before_eviction > H5C__MAX_EPOCH_MARKERS)
                 HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "epochs_before_eviction too big")
 
@@ -3772,43 +3701,24 @@ H5C_validate_resize_config(H5C_auto_size_ctl_t * config_ptr,
              */
         } /* H5C_decr__age_out || H5C_decr__age_out_with_threshold */
 
-        if ( config_ptr->decr_mode == H5C_decr__age_out_with_threshold ) {
-
-            if ( ( config_ptr->upper_hr_threshold > (double)1.0f ) ||
-                 ( config_ptr->upper_hr_threshold < (double)0.0f ) ) {
-
-                HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, \
-                       "upper_hr_threshold must be in the interval [0.0, 1.0]");
-            }
+        if(config_ptr->decr_mode == H5C_decr__age_out_with_threshold) {
+            if((config_ptr->upper_hr_threshold > (double)1.0f) ||
+                    (config_ptr->upper_hr_threshold < (double)0.0f))
+                HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "upper_hr_threshold must be in the interval [0.0, 1.0]")
         } /* H5C_decr__age_out_with_threshold */
-
     } /* H5C_RESIZE_CFG__VALIDATE_DECREMENT */
 
 
     if ( (tests & H5C_RESIZE_CFG__VALIDATE_INTERACTIONS) != 0 ) {
-
-        if ( ( config_ptr->incr_mode == H5C_incr__threshold )
-             &&
-             ( ( config_ptr->decr_mode == H5C_decr__threshold )
-               ||
-               ( config_ptr->decr_mode == H5C_decr__age_out_with_threshold )
-             )
-             &&
-             ( config_ptr->lower_hr_threshold
-               >=
-               config_ptr->upper_hr_threshold
-             )
-           ) {
-
-            HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, \
-                        "conflicting threshold fields in config.")
-        }
+        if((config_ptr->incr_mode == H5C_incr__threshold)
+                && ((config_ptr->decr_mode == H5C_decr__threshold) ||
+                       (config_ptr->decr_mode == H5C_decr__age_out_with_threshold))
+                && (config_ptr->lower_hr_threshold >= config_ptr->upper_hr_threshold))
+            HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "conflicting threshold fields in config")
     } /* H5C_RESIZE_CFG__VALIDATE_INTERACTIONS */
 
 done:
-
     FUNC_LEAVE_NOAPI(ret_value)
-
 } /* H5C_validate_resize_config() */
 
 
@@ -4112,7 +4022,6 @@ H5C__auto_adjust_cache_size(H5F_t * f,
                             hbool_t write_permitted)
 {
     H5C_t *			cache_ptr = f->shared->cache;
-    herr_t			result;
     hbool_t			reentrant_call = FALSE;
     hbool_t			inserted_epoch_marker = FALSE;
     size_t			new_max_cache_size = 0;
@@ -4140,34 +4049,26 @@ H5C__auto_adjust_cache_size(H5F_t * f,
      */
     if(cache_ptr->resize_in_progress) {
         reentrant_call = TRUE;
-        HGOTO_DONE(SUCCEED);
+        HGOTO_DONE(SUCCEED)
     } /* end if */
 
     cache_ptr->resize_in_progress = TRUE;
 
-    if ( !cache_ptr->resize_enabled ) {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Auto cache resize disabled.")
-    }
-
-    HDassert( ( (cache_ptr->resize_ctl).incr_mode != H5C_incr__off ) || \
-              ( (cache_ptr->resize_ctl).decr_mode != H5C_decr__off ) );
+    if(!cache_ptr->resize_enabled)
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Auto cache resize disabled")
 
-    if ( H5C_get_cache_hit_rate(cache_ptr, &hit_rate) != SUCCEED ) {
+    HDassert(((cache_ptr->resize_ctl).incr_mode != H5C_incr__off) || \
+              ((cache_ptr->resize_ctl).decr_mode != H5C_decr__off));
 
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Can't get hit rate.")
-    }
+    if(H5C_get_cache_hit_rate(cache_ptr, &hit_rate) != SUCCEED)
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Can't get hit rate")
 
     HDassert( ( (double)0.0f <= hit_rate ) && ( hit_rate <= (double)1.0f ) );
 
-    switch ( (cache_ptr->resize_ctl).incr_mode )
-    {
+    switch((cache_ptr->resize_ctl).incr_mode) {
         case H5C_incr__off:
-            if ( cache_ptr->size_increase_possible ) {
-
-                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                           "size_increase_possible but H5C_incr__off?!?!?")
-            }
+            if(cache_ptr->size_increase_possible)
+                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "size_increase_possible but H5C_incr__off?!?!?")
             break;
 
         case H5C_incr__threshold:
@@ -4217,7 +4118,7 @@ H5C__auto_adjust_cache_size(H5F_t * f,
             break;
 
         default:
-            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "unknown incr_mode.")
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "unknown incr_mode")
     }
 
     /* If the decr_mode is either age out or age out with threshold, we
@@ -4244,17 +4145,10 @@ H5C__auto_adjust_cache_size(H5F_t * f,
          )
        ) {
 
-        result = H5C__autoadjust__ageout__insert_new_marker(cache_ptr);
+        if(H5C__autoadjust__ageout__insert_new_marker(cache_ptr) < 0)
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "can't insert new epoch marker")
 
-        if ( result != SUCCEED ) {
-
-            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                        "can't insert new epoch marker.")
-
-        } else {
-
-            inserted_epoch_marker = TRUE;
-        }
+        inserted_epoch_marker = TRUE;
     }
 
     /* don't run the cache size decrease code unless the cache size
@@ -4314,32 +4208,18 @@ H5C__auto_adjust_cache_size(H5F_t * f,
 
             case H5C_decr__age_out_with_threshold:
             case H5C_decr__age_out:
-                if ( ! inserted_epoch_marker ) {
-
-                    if ( ! cache_ptr->size_decrease_possible ) {
-
+                if(!inserted_epoch_marker) {
+                    if(!cache_ptr->size_decrease_possible)
                         status = decrease_disabled;
-
-                    } else {
-
-                        result = H5C__autoadjust__ageout(f,
-                                                         dxpl_id,
-                                                         hit_rate,
-                                                         &status,
-                                                         &new_max_cache_size,
-                                                         write_permitted);
-
-                        if ( result != SUCCEED ) {
-
-                            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                                        "ageout code failed.")
-                        }
-                    }
-                }
+                    else {
+                        if(H5C__autoadjust__ageout(f, dxpl_id, hit_rate, &status, &new_max_cache_size, write_permitted) < 0)
+                            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "ageout code failed")
+                    } /* end else */
+                } /* end if */
                 break;
 
             default:
-                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "unknown incr_mode.")
+                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "unknown incr_mode")
         }
     }
 
@@ -4355,13 +4235,8 @@ H5C__auto_adjust_cache_size(H5F_t * f,
        ) {
 
         /* move last epoch marker to the head of the LRU list */
-        result = H5C__autoadjust__ageout__cycle_epoch_marker(cache_ptr);
-
-        if ( result != SUCCEED ) {
-
-            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                        "error cycling epoch marker.")
-        }
+        if(H5C__autoadjust__ageout__cycle_epoch_marker(cache_ptr) < 0)
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "error cycling epoch marker")
     }
 
     if ( ( status == increase ) || ( status == decrease ) ) {
@@ -4402,9 +4277,7 @@ H5C__auto_adjust_cache_size(H5F_t * f,
             switch ( (cache_ptr->resize_ctl).flash_incr_mode )
             {
                 case H5C_flash_incr__off:
-
-                    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                     "flash_size_increase_possible but H5C_flash_incr__off?!")
+                    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "flash_size_increase_possible but H5C_flash_incr__off?!")
                     break;
 
                 case H5C_flash_incr__add_space:
@@ -4415,15 +4288,13 @@ H5C__auto_adjust_cache_size(H5F_t * f,
                      break;
 
                 default: /* should be unreachable */
-                    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                                "Unknown flash_incr_mode?!?!?.")
+                    HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Unknown flash_incr_mode?!?!?")
                     break;
             }
         }
     }
 
     if ( (cache_ptr->resize_ctl).rpt_fcn != NULL ) {
-
         (*((cache_ptr->resize_ctl).rpt_fcn))
             (cache_ptr,
              H5C__CURR_AUTO_RESIZE_RPT_FCN_VER,
@@ -4435,12 +4306,9 @@ H5C__auto_adjust_cache_size(H5F_t * f,
              new_min_clean_size);
     }
 
-    if ( H5C_reset_cache_hit_rate_stats(cache_ptr) != SUCCEED ) {
-
+    if(H5C_reset_cache_hit_rate_stats(cache_ptr) < 0)
         /* this should be impossible... */
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                    "H5C_reset_cache_hit_rate_stats failed.")
-    }
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5C_reset_cache_hit_rate_stats failed")
 
 done:
     /* Sanity checks */
@@ -4481,7 +4349,6 @@ H5C__autoadjust__ageout(H5F_t * f,
                         hbool_t write_permitted)
 {
     H5C_t *     cache_ptr = f->shared->cache;
-    herr_t	result;
     size_t	test_size;
     herr_t	ret_value = SUCCEED;      /* Return value */
 
@@ -4494,17 +4361,9 @@ H5C__autoadjust__ageout(H5F_t * f,
     HDassert( ( new_max_cache_size_ptr ) && ( *new_max_cache_size_ptr == 0 ) );
 
     /* remove excess epoch markers if any */
-    if ( cache_ptr->epoch_markers_active >
-         (cache_ptr->resize_ctl).epochs_before_eviction ) {
-
-        result = H5C__autoadjust__ageout__remove_excess_markers(cache_ptr);
-
-        if ( result != SUCCEED ) {
-
-            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                        "can't remove excess epoch markers.")
-        }
-    }
+    if(cache_ptr->epoch_markers_active > (cache_ptr->resize_ctl).epochs_before_eviction)
+        if(H5C__autoadjust__ageout__remove_excess_markers(cache_ptr) < 0)
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "can't remove excess epoch markers")
 
     if ( ( (cache_ptr->resize_ctl).decr_mode == H5C_decr__age_out )
          ||
@@ -4520,7 +4379,7 @@ H5C__autoadjust__ageout(H5F_t * f,
 
             /* evict aged out cache entries if appropriate... */
             if(H5C__autoadjust__ageout__evict_aged_out_entries(f, dxpl_id, write_permitted) < 0)
-                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "error flushing aged out entries.")
+                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "error flushing aged out entries")
 
             /* ... and then reduce cache size if appropriate */
             if ( cache_ptr->index_size < cache_ptr->max_cache_size ) {
@@ -4602,11 +4461,8 @@ H5C__autoadjust__ageout__cycle_epoch_marker(H5C_t * cache_ptr)
     HDassert( cache_ptr );
     HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
 
-    if ( cache_ptr->epoch_markers_active <= 0 ) {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                    "No active epoch markers on entry?!?!?.")
-    }
+    if(cache_ptr->epoch_markers_active <= 0)
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "No active epoch markers on entry?!?!?")
 
     /* remove the last marker from both the ring buffer and the LRU list */
 
@@ -4618,15 +4474,10 @@ H5C__autoadjust__ageout__cycle_epoch_marker(H5C_t * cache_ptr)
 
     cache_ptr->epoch_marker_ringbuf_size -= 1;
 
-    if ( cache_ptr->epoch_marker_ringbuf_size < 0 ) {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "ring buffer underflow.")
-    }
-
-    if ( (cache_ptr->epoch_marker_active)[i] != TRUE ) {
-
+    if(cache_ptr->epoch_marker_ringbuf_size < 0)
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "ring buffer underflow")
+    if((cache_ptr->epoch_marker_active)[i] != TRUE)
         HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "unused marker in LRU?!?")
-    }
 
     H5C__DLL_REMOVE((&((cache_ptr->epoch_markers)[i])), \
                     (cache_ptr)->LRU_head_ptr, \
@@ -4639,9 +4490,9 @@ H5C__autoadjust__ageout__cycle_epoch_marker(H5C_t * cache_ptr)
      * the ring buffer.
      */
 
-    HDassert( ((cache_ptr->epoch_markers)[i]).addr == (haddr_t)i );
-    HDassert( ((cache_ptr->epoch_markers)[i]).next == NULL );
-    HDassert( ((cache_ptr->epoch_markers)[i]).prev == NULL );
+    HDassert(((cache_ptr->epoch_markers)[i]).addr == (haddr_t)i);
+    HDassert(((cache_ptr->epoch_markers)[i]).next == NULL);
+    HDassert(((cache_ptr->epoch_markers)[i]).prev == NULL);
 
     cache_ptr->epoch_marker_ringbuf_last =
         (cache_ptr->epoch_marker_ringbuf_last + 1) %
@@ -4651,10 +4502,8 @@ H5C__autoadjust__ageout__cycle_epoch_marker(H5C_t * cache_ptr)
 
     cache_ptr->epoch_marker_ringbuf_size += 1;
 
-    if ( cache_ptr->epoch_marker_ringbuf_size > H5C__MAX_EPOCH_MARKERS ) {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "ring buffer overflow.")
-    }
+    if(cache_ptr->epoch_marker_ringbuf_size > H5C__MAX_EPOCH_MARKERS)
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "ring buffer overflow")
 
     H5C__DLL_PREPEND((&((cache_ptr->epoch_markers)[i])), \
                      (cache_ptr)->LRU_head_ptr, \
@@ -4870,9 +4719,9 @@ H5C__autoadjust__ageout__evict_aged_out_entries(H5F_t * f,
          * entry).
          */
 
-    } else /* ! write_permitted */  {
-
-        /* since we are not allowed to write, all we can do is evict
+    } /* end if */
+    else /* ! write_permitted */  {
+        /* Since we are not allowed to write, all we can do is evict
          * any clean entries that we may encounter before we either
          * hit the eviction size limit, or encounter the epoch marker.
          *
@@ -4885,23 +4734,19 @@ H5C__autoadjust__ageout__evict_aged_out_entries(H5F_t * f,
          * performance implications, but it shouldn't cause any net
          * slowdown.
          */
-
-        HDassert( H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS );
-
+        HDassert(H5C_MAINTAIN_CLEAN_AND_DIRTY_LRU_LISTS);
         entry_ptr = cache_ptr->LRU_tail_ptr;
-
-        while ( ( entry_ptr != NULL ) &&
-                ( (entry_ptr->type)->id != H5AC_EPOCH_MARKER_ID ) &&
-                ( bytes_evicted < eviction_size_limit ) )
-        {
-            HDassert( ! (entry_ptr->is_protected) );
+        while(entry_ptr != NULL &&
+                ((entry_ptr->type)->id != H5AC_EPOCH_MARKER_ID) &&
+                (bytes_evicted < eviction_size_limit)) {
+            HDassert(!(entry_ptr->is_protected));
 
             prev_ptr = entry_ptr->prev;
 
-            if ( ! (entry_ptr->is_dirty) ) {
+            if(!(entry_ptr->is_dirty)) {
                 if(H5C__flush_single_entry(f, dxpl_id, entry_ptr, H5C__FLUSH_INVALIDATE_FLAG | H5C__DEL_FROM_SLIST_ON_DESTROY_FLAG) < 0)
                     HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "unable to flush clean entry")
-            }
+            } /* end if */
             /* just skip the entry if it is dirty, as we can't do
              * anything with it now since we can't write.
 	     *
@@ -4909,21 +4754,15 @@ H5C__autoadjust__ageout__evict_aged_out_entries(H5F_t * f,
 	     * and thus we needn't test to see if the LRU has been changed
 	     * out from under us.
              */
-
             entry_ptr = prev_ptr;
-
         } /* end while */
-    }
-
-    if ( cache_ptr->index_size < cache_ptr->max_cache_size ) {
+    } /* end else */
 
+    if(cache_ptr->index_size < cache_ptr->max_cache_size)
         cache_ptr->cache_full = FALSE;
-    }
 
 done:
-
     FUNC_LEAVE_NOAPI(ret_value)
-
 } /* H5C__autoadjust__ageout__evict_aged_out_entries() */
 
 
@@ -4952,23 +4791,16 @@ H5C__autoadjust__ageout__insert_new_marker(H5C_t * cache_ptr)
     HDassert( cache_ptr );
     HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
 
-    if ( cache_ptr->epoch_markers_active >=
-         (cache_ptr->resize_ctl).epochs_before_eviction ) {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                    "Already have a full complement of markers.")
-    }
+    if(cache_ptr->epoch_markers_active >= (cache_ptr->resize_ctl).epochs_before_eviction)
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Already have a full complement of markers")
 
     /* find an unused marker */
     i = 0;
-    while ( ( (cache_ptr->epoch_marker_active)[i] ) &&
-            ( i < H5C__MAX_EPOCH_MARKERS ) )
-    {
+    while((cache_ptr->epoch_marker_active)[i] && i < H5C__MAX_EPOCH_MARKERS)
         i++;
-    }
 
     if(i >= H5C__MAX_EPOCH_MARKERS)
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Can't find unused marker.")
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Can't find unused marker")
 
     HDassert( ((cache_ptr->epoch_markers)[i]).addr == (haddr_t)i );
     HDassert( ((cache_ptr->epoch_markers)[i]).next == NULL );
@@ -4986,7 +4818,7 @@ H5C__autoadjust__ageout__insert_new_marker(H5C_t * cache_ptr)
 
     if ( cache_ptr->epoch_marker_ringbuf_size > H5C__MAX_EPOCH_MARKERS ) {
 
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "ring buffer overflow.")
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "ring buffer overflow")
     }
 
     H5C__DLL_PREPEND((&((cache_ptr->epoch_markers)[i])), \
@@ -5045,15 +4877,11 @@ H5C__autoadjust__ageout__remove_all_markers(H5C_t * cache_ptr)
 
         cache_ptr->epoch_marker_ringbuf_size -= 1;
 
-        if ( cache_ptr->epoch_marker_ringbuf_size < 0 ) {
-
-            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "ring buffer underflow.")
-        }
-
-        if ( (cache_ptr->epoch_marker_active)[i] != TRUE ) {
+        if(cache_ptr->epoch_marker_ringbuf_size < 0)
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "ring buffer underflow")
 
+        if((cache_ptr->epoch_marker_active)[i] != TRUE)
             HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "unused marker in LRU?!?")
-        }
 
         /* remove the epoch marker from the LRU list */
         H5C__DLL_REMOVE((&((cache_ptr->epoch_markers)[i])), \
@@ -5111,15 +4939,10 @@ H5C__autoadjust__ageout__remove_excess_markers(H5C_t * cache_ptr)
     HDassert( cache_ptr );
     HDassert( cache_ptr->magic == H5C__H5C_T_MAGIC );
 
-    if ( cache_ptr->epoch_markers_active <=
-         (cache_ptr->resize_ctl).epochs_before_eviction ) {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "no excess markers on entry.")
-    }
+    if(cache_ptr->epoch_markers_active <= (cache_ptr->resize_ctl).epochs_before_eviction)
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "no excess markers on entry")
 
-    while ( cache_ptr->epoch_markers_active >
-            (cache_ptr->resize_ctl).epochs_before_eviction )
-    {
+    while(cache_ptr->epoch_markers_active > (cache_ptr->resize_ctl).epochs_before_eviction) {
         /* get the index of the last epoch marker in the LRU list
          * and remove it from the ring buffer.
          */
@@ -5133,15 +4956,10 @@ H5C__autoadjust__ageout__remove_excess_markers(H5C_t * cache_ptr)
 
         cache_ptr->epoch_marker_ringbuf_size -= 1;
 
-        if ( cache_ptr->epoch_marker_ringbuf_size < 0 ) {
-
-            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "ring buffer underflow.")
-        }
-
-        if ( (cache_ptr->epoch_marker_active)[i] != TRUE ) {
-
+        if(cache_ptr->epoch_marker_ringbuf_size < 0)
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "ring buffer underflow")
+        if((cache_ptr->epoch_marker_active)[i] != TRUE)
             HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "unused marker in LRU?!?")
-        }
 
         /* remove the epoch marker from the LRU list */
         H5C__DLL_REMOVE((&((cache_ptr->epoch_markers)[i])), \
@@ -5210,11 +5028,8 @@ H5C__flash_increase_cache_size(H5C_t * cache_ptr,
     HDassert( new_entry_size > cache_ptr->flash_size_increase_threshold );
     HDassert( old_entry_size < new_entry_size );
 
-    if ( old_entry_size >= new_entry_size ) {
-
-        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                    "old_entry_size >= new_entry_size")
-    }
+    if(old_entry_size >= new_entry_size)
+        HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "old_entry_size >= new_entry_size")
 
     space_needed = new_entry_size - old_entry_size;
 
@@ -5227,8 +5042,7 @@ H5C__flash_increase_cache_size(H5C_t * cache_ptr,
         switch ( (cache_ptr->resize_ctl).flash_incr_mode )
         {
             case H5C_flash_incr__off:
-                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                   "flash_size_increase_possible but H5C_flash_incr__off?!")
+                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "flash_size_increase_possible but H5C_flash_incr__off?!")
                 break;
 
             case H5C_flash_incr__add_space:
@@ -5248,8 +5062,7 @@ H5C__flash_increase_cache_size(H5C_t * cache_ptr,
                 break;
 
             default: /* should be unreachable */
-                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                            "Unknown flash_incr_mode?!?!?.")
+                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Unknown flash_incr_mode?!?!?")
                 break;
         }
 
@@ -5278,8 +5091,7 @@ H5C__flash_increase_cache_size(H5C_t * cache_ptr,
         switch ( (cache_ptr->resize_ctl).flash_incr_mode )
         {
             case H5C_flash_incr__off:
-                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                    "flash_size_increase_possible but H5C_flash_incr__off?!")
+                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "flash_size_increase_possible but H5C_flash_incr__off?!")
                 break;
 
             case H5C_flash_incr__add_space:
@@ -5290,8 +5102,7 @@ H5C__flash_increase_cache_size(H5C_t * cache_ptr,
                 break;
 
             default: /* should be unreachable */
-                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                            "Unknown flash_incr_mode?!?!?.")
+                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Unknown flash_incr_mode?!?!?")
                 break;
         }
 
@@ -5305,10 +5116,8 @@ H5C__flash_increase_cache_size(H5C_t * cache_ptr,
             /* get the hit rate for the reporting function.  Should still
              * be good as we havent reset the hit rate statistics.
              */
-            if ( H5C_get_cache_hit_rate(cache_ptr, &hit_rate) != SUCCEED ) {
-
-                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Can't get hit rate.")
-            }
+            if(H5C_get_cache_hit_rate(cache_ptr, &hit_rate) != SUCCEED)
+                HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "Can't get hit rate")
 
             (*((cache_ptr->resize_ctl).rpt_fcn))
                 (cache_ptr,
@@ -5321,12 +5130,9 @@ H5C__flash_increase_cache_size(H5C_t * cache_ptr,
                  new_min_clean_size);
         }
 
-        if ( H5C_reset_cache_hit_rate_stats(cache_ptr) != SUCCEED ) {
-
+        if(H5C_reset_cache_hit_rate_stats(cache_ptr) < 0)
             /* this should be impossible... */
-            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, \
-                        "H5C_reset_cache_hit_rate_stats failed.")
-        }
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "H5C_reset_cache_hit_rate_stats failed")
     }
 
 done:
@@ -5428,7 +5234,7 @@ H5C_flush_invalidate_cache(H5F_t *f, hid_t dxpl_id, unsigned flags)
     /* remove ageout markers if present */
     if(cache_ptr->epoch_markers_active > 0)
         if(H5C__autoadjust__ageout__remove_all_markers(cache_ptr) < 0)
-            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "error removing all epoch markers.")
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "error removing all epoch markers")
 
     /* flush invalidate each ring, starting from the outermost ring and
      * working inward.
@@ -5436,7 +5242,7 @@ H5C_flush_invalidate_cache(H5F_t *f, hid_t dxpl_id, unsigned flags)
     ring = H5C_RING_USER;
     while(ring < H5C_RING_NTYPES) {
         if(H5C_flush_invalidate_ring(f, dxpl_id, ring, flags) < 0)
-            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "flush invalidate ring failed.")
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "flush invalidate ring failed")
         ring++;
     } /* end while */
 
@@ -5719,9 +5525,10 @@ H5C_flush_invalidate_ring(H5F_t * f, hid_t dxpl_id, H5C_ring_t ring,
                      * everything we can before we flag an error.
                      */
                     protected_entries++;
-                } else if(entry_ptr->is_pinned) {
+                } /* end if */
+                else if(entry_ptr->is_pinned) {
                     if(H5C__flush_single_entry(f, dxpl_id, entry_ptr, H5C__DURING_FLUSH_FLAG) < 0)
-                        HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "dirty pinned entry flush failed.")
+                        HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "dirty pinned entry flush failed")
 
                     if(cache_ptr->slist_changed) {
                         /* The slist has been modified by something
@@ -5735,10 +5542,10 @@ H5C_flush_invalidate_ring(H5F_t * f, hid_t dxpl_id, H5C_ring_t ring,
                         cache_ptr->slist_changed = FALSE;
                         H5C__UPDATE_STATS_FOR_SLIST_SCAN_RESTART(cache_ptr);
                     } /* end if */
-                } /* end if */
+                } /* end else-if */
                 else {
                     if(H5C__flush_single_entry(f, dxpl_id, entry_ptr, (cooked_flags | H5C__DURING_FLUSH_FLAG | H5C__FLUSH_INVALIDATE_FLAG | H5C__DEL_FROM_SLIST_ON_DESTROY_FLAG)) < 0)
-                        HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "dirty entry flush destroy failed.")
+                        HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "dirty entry flush destroy failed")
 
                     if(cache_ptr->slist_changed) {
                         /* The slist has been modified by something
@@ -5842,7 +5649,7 @@ H5C_flush_invalidate_ring(H5F_t * f, hid_t dxpl_id, H5C_ring_t ring,
                     cache_ptr->entry_watched_for_removal = next_entry_ptr;
 
                     if(H5C__flush_single_entry(f, dxpl_id, entry_ptr, (cooked_flags | H5C__DURING_FLUSH_FLAG | H5C__FLUSH_INVALIDATE_FLAG | H5C__DEL_FROM_SLIST_ON_DESTROY_FLAG)) < 0)
-                        HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Entry flush destroy failed.")
+                        HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Entry flush destroy failed")
 
                     /* Restart the index list scan if necessary.  Must
                      * do this if the next entry is evicted, and also if 
@@ -5923,9 +5730,9 @@ H5C_flush_invalidate_ring(H5F_t * f, hid_t dxpl_id, H5C_ring_t ring,
     HDassert(protected_entries <= cache_ptr->pl_len);
 
     if(protected_entries > 0)
-        HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Cache has protected entries.")
+        HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Cache has protected entries")
     else if(cur_ring_pel_len > 0)
-        HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't unpin all pinned entries in ring.")
+        HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't unpin all pinned entries in ring")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -6153,7 +5960,7 @@ H5C_flush_ring(H5F_t *f, hid_t dxpl_id, H5C_ring_t ring,  unsigned flags)
                 } /* end if */
                 else {
                     if(H5C__flush_single_entry(f, dxpl_id, entry_ptr, (flags | H5C__DURING_FLUSH_FLAG)) < 0)
-                        HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't flush entry.")
+                        HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't flush entry")
 
                     if(cache_ptr->slist_changed) {
                         /* The slist has been modified by something
@@ -6318,21 +6125,22 @@ H5C__flush_single_entry(H5F_t *f, hid_t dxpl_id, H5C_cache_entry_t *entry_ptr,
         HDassert(entry_ptr->is_dirty);
 
         if((entry_ptr->flush_marker) && (!entry_ptr->is_dirty))
-            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "entry in slist failed sanity checks.")
-    } else {
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "entry in slist failed sanity checks")
+    } /* end if */
+    else {
         HDassert(!entry_ptr->is_dirty);
         HDassert(!entry_ptr->flush_marker);
 
         if((entry_ptr->is_dirty) || (entry_ptr->flush_marker))
-            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "entry failed sanity checks.")
-    }
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "entry failed sanity checks")
+    } /* end else */
 #endif /* H5C_DO_SANITY_CHECKS */
 
     if(entry_ptr->is_protected) {
         HDassert(!entry_ptr->is_protected);
 
         /* Attempt to flush a protected entry -- scream and die. */
-        HGOTO_ERROR(H5E_CACHE, H5E_PROTECT, FAIL, "Attempt to flush a protected entry.")
+        HGOTO_ERROR(H5E_CACHE, H5E_PROTECT, FAIL, "Attempt to flush a protected entry")
     } /* end if */
 
     /* Set entry_ptr->flush_in_progress = TRUE and set
@@ -6413,7 +6221,7 @@ H5C__flush_single_entry(H5F_t *f, hid_t dxpl_id, H5C_cache_entry_t *entry_ptr,
                 mem_type = entry_ptr->type->mem_type;
 
             if(H5F_block_write(f, mem_type, entry_ptr->addr, entry_ptr->size, dxpl_id, entry_ptr->image_ptr) < 0)
-                HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't write image to file.")
+                HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "Can't write image to file")
         } /* end if */
 
         /* if the entry has a notify callback, notify it that we have 
@@ -6663,7 +6471,7 @@ H5C__flush_single_entry(H5F_t *f, hid_t dxpl_id, H5C_cache_entry_t *entry_ptr,
             HDassert(entry_ptr->image_ptr == NULL);
 
             if(entry_ptr->type->free_icr((void *)entry_ptr) < 0)
-                HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "free_icr callback failed.")
+                HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "free_icr callback failed")
         }  /* end if */
         else {
             HDassert(take_ownership);
@@ -6678,12 +6486,11 @@ H5C__flush_single_entry(H5F_t *f, hid_t dxpl_id, H5C_cache_entry_t *entry_ptr,
 
     if(cache_ptr->log_flush)
         if((cache_ptr->log_flush)(cache_ptr, entry_addr, was_dirty, flags) < 0)
-            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "log_flush callback failed.")
+            HGOTO_ERROR(H5E_CACHE, H5E_CANTFLUSH, FAIL, "log_flush callback failed")
 
 done:
     HDassert( ( ret_value != SUCCEED ) || ( destroy_entry ) || 
               ( ! entry_ptr->flush_in_progress ) );
-
     HDassert( ( ret_value != SUCCEED ) || ( destroy_entry ) || 
               ( take_ownership ) || ( ! entry_ptr->is_dirty ) );
 
@@ -6741,14 +6548,14 @@ H5C__verify_len_eoa(H5F_t *f, const H5C_class_t *type, haddr_t addr,
     /* Check if the amount of data to read will be past the EOA */
     if(H5F_addr_gt((addr + *len), eoa)) {
 	if(actual)
-	    HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "actual len exceeds EOA.")
+	    HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "actual len exceeds EOA")
 	else
 	    /* Trim down the length of the metadata */
 	    *len = (size_t)(eoa - addr);
     } /* end if */
 
     if(*len <= 0)
-	HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "len not positive after adjustment for EOA.")
+	HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL, "len not positive after adjustment for EOA")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -6828,7 +6635,7 @@ H5C_load_entry(H5F_t *              f,
 
     /* Allocate the buffer for reading the on-disk entry image */
     if(NULL == (image = (uint8_t *)H5MM_malloc(len + H5C_IMAGE_EXTRA_SPACE)))
-        HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, NULL, "memory allocation failed for on disk image buffer.")
+        HGOTO_ERROR(H5E_CACHE, H5E_CANTALLOC, NULL, "memory allocation failed for on disk image buffer")
 #if H5C_DO_MEMORY_SANITY_CHECKS
     HDmemcpy(image + len, H5C_IMAGE_SANITY_VALUE, H5C_IMAGE_EXTRA_SPACE);
 #endif /* H5C_DO_MEMORY_SANITY_CHECKS */
@@ -6905,7 +6712,7 @@ H5C_load_entry(H5F_t *              f,
                 if(actual_len != len) {
                     /* Verify that the length isn't past the EOA for the file */
                     if(H5C__verify_len_eoa(f, type, addr, &actual_len, TRUE) < 0)
-                        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, NULL, "actual_len exceeds EOA.")
+                        HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, NULL, "actual_len exceeds EOA")
 
                     /* Expand buffer to new size */
                     if(NULL == (new_image = H5MM_realloc(image, actual_len + H5C_IMAGE_EXTRA_SPACE)))
@@ -8343,7 +8150,7 @@ H5C__generate_image(H5F_t *f, H5C_t *cache_ptr, H5C_cache_entry_t *entry_ptr,
          *     tests will be necessary.
          */
         if(cache_ptr->aux_ptr != NULL)
-            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "resize/move in serialize occured in parallel case.")
+            HGOTO_ERROR(H5E_CACHE, H5E_SYSTEM, FAIL, "resize/move in serialize occured in parallel case")
 #endif
 
         /* If required, resize the buffer and update the entry and the cache