Brings over most of the HD prefix removal (#3293)

1 files changed, 236 insertions, 236 deletions

diff --git a/src/H5Cpkg.h b/src/H5Cpkg.h
index 7bd7087..095dc8b 100644
--- a/src/H5Cpkg.h
+++ b/src/H5Cpkg.h
@@ -1173,7 +1173,7 @@ if ( ( (cache_ptr)->index_size !=                                           \
     }                                                                        \
     if((entry_ptr)->flush_me_last) {                                         \
         (cache_ptr)->num_last_entries++;                                     \
-        HDassert((cache_ptr)->num_last_entries <= 2);                        \
+        assert((cache_ptr)->num_last_entries <= 2);                        \
     }                                                                        \
     H5C__IL_DLL_APPEND((entry_ptr), (cache_ptr)->il_head,                    \
                        (cache_ptr)->il_tail, (cache_ptr)->il_len,            \
@@ -1211,7 +1211,7 @@ if ( ( (cache_ptr)->index_size !=                                           \
     }                                                                        \
     if((entry_ptr)->flush_me_last) {                                         \
         (cache_ptr)->num_last_entries--;                                     \
-        HDassert((cache_ptr)->num_last_entries <= 1);                        \
+        assert((cache_ptr)->num_last_entries <= 1);                        \
     }                                                                        \
     H5C__IL_DLL_REMOVE((entry_ptr), (cache_ptr)->il_head,                    \
                        (cache_ptr)->il_tail, (cache_ptr)->il_len,            \
@@ -1233,7 +1233,7 @@ if ( ( (cache_ptr)->index_size !=                                           \
             if(entry_ptr != ((cache_ptr)->index)[k]) {                      \
                 if((entry_ptr)->ht_next)                                    \
                     (entry_ptr)->ht_next->ht_prev = (entry_ptr)->ht_prev;   \
-                HDassert((entry_ptr)->ht_prev != NULL);                     \
+                assert((entry_ptr)->ht_prev != NULL);                     \
                 (entry_ptr)->ht_prev->ht_next = (entry_ptr)->ht_next;       \
                 ((cache_ptr)->index)[k]->ht_prev = (entry_ptr);             \
                 (entry_ptr)->ht_next = ((cache_ptr)->index)[k];             \
@@ -1353,21 +1353,21 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #define H5C__INSERT_ENTRY_IN_SLIST(cache_ptr, entry_ptr, fail_val)             \
 {                                                                              \
-    HDassert( (cache_ptr) );                                                   \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                        \
+    assert( (cache_ptr) );                                                   \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                        \
                                                                                \
     if ( (cache_ptr)->slist_enabled ) {                                        \
                                                                                \
-        HDassert( (entry_ptr) );                                               \
-        HDassert( (entry_ptr)->size > 0 );                                     \
-        HDassert( H5F_addr_defined((entry_ptr)->addr) );                       \
-        HDassert( !((entry_ptr)->in_slist) );                                  \
-        HDassert( ! H5C_ENTRY_IN_SLIST((cache_ptr), (entry_ptr)) );                \
-        HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                    \
-        HDassert( (entry_ptr)->ring < H5C_RING_NTYPES );                       \
-        HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=            \
+        assert( (entry_ptr) );                                               \
+        assert( (entry_ptr)->size > 0 );                                     \
+        assert( H5F_addr_defined((entry_ptr)->addr) );                       \
+        assert( !((entry_ptr)->in_slist) );                                  \
+        assert( ! H5C_ENTRY_IN_SLIST((cache_ptr), (entry_ptr)) );                \
+        assert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                    \
+        assert( (entry_ptr)->ring < H5C_RING_NTYPES );                       \
+        assert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=            \
                   (cache_ptr)->slist_len );                                    \
-        HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=           \
+        assert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=           \
                   (cache_ptr)->slist_size );                                   \
                                                                                \
         if ( H5SL_insert((cache_ptr)->slist_ptr, entry_ptr,                    \
@@ -1384,13 +1384,13 @@ if ( ( (cache_ptr)->index_size !=                                           \
         (cache_ptr)->slist_len_increase++;                                     \
         (cache_ptr)->slist_size_increase += (int64_t)((entry_ptr)->size);      \
                                                                                \
-        HDassert( (cache_ptr)->slist_len > 0 );                                \
-        HDassert( (cache_ptr)->slist_size > 0 );                               \
+        assert( (cache_ptr)->slist_len > 0 );                                \
+        assert( (cache_ptr)->slist_size > 0 );                               \
                                                                                \
     } else { /* slist disabled */                                              \
                                                                                \
-        HDassert( (cache_ptr)->slist_len == 0 );                               \
-        HDassert( (cache_ptr)->slist_size == 0 );                              \
+        assert( (cache_ptr)->slist_len == 0 );                               \
+        assert( (cache_ptr)->slist_size == 0 );                              \
     }                                                                          \
 } /* H5C__INSERT_ENTRY_IN_SLIST */
 
@@ -1398,23 +1398,23 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #define H5C__INSERT_ENTRY_IN_SLIST(cache_ptr, entry_ptr, fail_val)             \
 {                                                                              \
-    HDassert( (cache_ptr) );                                                   \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                        \
+    assert( (cache_ptr) );                                                   \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                        \
                                                                                \
     if ( (cache_ptr)->slist_enabled ) {                                        \
                                                                                \
-        HDassert( (entry_ptr) );                                               \
-        HDassert( (entry_ptr)->size > 0 );                                     \
-        HDassert( ! H5C_ENTRY_IN_SLIST((cache_ptr), (entry_ptr)) );                \
-        HDassert( H5F_addr_defined((entry_ptr)->addr) );                       \
-        HDassert( !((entry_ptr)->in_slist) );                                  \
-        HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                    \
-        HDassert( (entry_ptr)->ring < H5C_RING_NTYPES );                       \
-        HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=            \
+        assert( (entry_ptr) );                                               \
+        assert( (entry_ptr)->size > 0 );                                     \
+        assert( ! H5C_ENTRY_IN_SLIST((cache_ptr), (entry_ptr)) );                \
+        assert( H5F_addr_defined((entry_ptr)->addr) );                       \
+        assert( !((entry_ptr)->in_slist) );                                  \
+        assert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                    \
+        assert( (entry_ptr)->ring < H5C_RING_NTYPES );                       \
+        assert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=            \
                   (cache_ptr)->slist_len );                                    \
-        HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=           \
+        assert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=           \
                   (cache_ptr)->slist_size );                                   \
-        HDassert( (cache_ptr)->slist_ptr );                                    \
+        assert( (cache_ptr)->slist_ptr );                                    \
                                                                                \
         if ( H5SL_insert((cache_ptr)->slist_ptr, entry_ptr,                    \
                          &((entry_ptr)->addr)) < 0)                            \
@@ -1428,13 +1428,13 @@ if ( ( (cache_ptr)->index_size !=                                           \
         ((cache_ptr)->slist_ring_len[(entry_ptr)->ring])++;                    \
         ((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) += (entry_ptr)->size;\
                                                                                \
-        HDassert( (cache_ptr)->slist_len > 0 );                                \
-        HDassert( (cache_ptr)->slist_size > 0 );                               \
+        assert( (cache_ptr)->slist_len > 0 );                                \
+        assert( (cache_ptr)->slist_size > 0 );                               \
                                                                                \
     } else { /* slist disabled */                                              \
                                                                                \
-        HDassert( (cache_ptr)->slist_len == 0 );                               \
-        HDassert( (cache_ptr)->slist_size == 0 );                              \
+        assert( (cache_ptr)->slist_len == 0 );                               \
+        assert( (cache_ptr)->slist_size == 0 );                              \
     }                                                                          \
 } /* H5C__INSERT_ENTRY_IN_SLIST */
 
@@ -1459,38 +1459,38 @@ if ( ( (cache_ptr)->index_size !=                                           \
 #ifdef H5C_DO_SANITY_CHECKS
 #define H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, during_flush)       \
 {                                                                              \
-    HDassert( (cache_ptr) );                                                   \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                        \
+    assert( (cache_ptr) );                                                   \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                        \
                                                                                \
     if ( (cache_ptr)->slist_enabled ) {                                        \
                                                                                \
-        HDassert( (entry_ptr) );                                               \
-        HDassert( !((entry_ptr)->is_read_only) );                              \
-        HDassert( ((entry_ptr)->ro_ref_count) == 0 );                          \
-        HDassert( (entry_ptr)->size > 0 );                                     \
-        HDassert( (entry_ptr)->in_slist );                                     \
-        HDassert( (cache_ptr)->slist_ptr );                                    \
-        HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                    \
-        HDassert( (entry_ptr)->ring < H5C_RING_NTYPES );                       \
-        HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=            \
+        assert( (entry_ptr) );                                               \
+        assert( !((entry_ptr)->is_read_only) );                              \
+        assert( ((entry_ptr)->ro_ref_count) == 0 );                          \
+        assert( (entry_ptr)->size > 0 );                                     \
+        assert( (entry_ptr)->in_slist );                                     \
+        assert( (cache_ptr)->slist_ptr );                                    \
+        assert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                    \
+        assert( (entry_ptr)->ring < H5C_RING_NTYPES );                       \
+        assert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=            \
                   (cache_ptr)->slist_len );                                    \
-        HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=           \
+        assert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=           \
                   (cache_ptr)->slist_size );                                   \
-        HDassert( (cache_ptr)->slist_size >= (entry_ptr)->size );              \
+        assert( (cache_ptr)->slist_size >= (entry_ptr)->size );              \
                                                                                \
         if ( H5SL_remove((cache_ptr)->slist_ptr, &(entry_ptr)->addr)           \
                  != (entry_ptr) )                                              \
             HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL,                         \
                         "can't delete entry from skip list")                   \
                                                                                \
-        HDassert( (cache_ptr)->slist_len > 0 );                                \
+        assert( (cache_ptr)->slist_len > 0 );                                \
         if(!(during_flush))                                                    \
             (cache_ptr)->slist_changed = TRUE;                                 \
         (cache_ptr)->slist_len--;                                              \
-        HDassert( (cache_ptr)->slist_size >= (entry_ptr)->size );              \
+        assert( (cache_ptr)->slist_size >= (entry_ptr)->size );              \
         (cache_ptr)->slist_size -= (entry_ptr)->size;                          \
         ((cache_ptr)->slist_ring_len[(entry_ptr)->ring])--;                    \
-        HDassert( (cache_ptr)->slist_ring_size[((entry_ptr)->ring)] >=           \
+        assert( (cache_ptr)->slist_ring_size[((entry_ptr)->ring)] >=           \
                   (entry_ptr)->size );                                         \
         ((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (entry_ptr)->size;\
         (cache_ptr)->slist_len_increase--;                                     \
@@ -1499,8 +1499,8 @@ if ( ( (cache_ptr)->index_size !=                                           \
                                                                                \
     } else { /* slist disabled */                                              \
                                                                                \
-        HDassert( (cache_ptr)->slist_len == 0 );                               \
-        HDassert( (cache_ptr)->slist_size == 0 );                              \
+        assert( (cache_ptr)->slist_len == 0 );                               \
+        assert( (cache_ptr)->slist_size == 0 );                              \
     }                                                                          \
 } /* H5C__REMOVE_ENTRY_FROM_SLIST */
 
@@ -1508,21 +1508,21 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #define H5C__REMOVE_ENTRY_FROM_SLIST(cache_ptr, entry_ptr, during_flush)       \
 {                                                                              \
-    HDassert( (cache_ptr) );                                                   \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                        \
+    assert( (cache_ptr) );                                                   \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                        \
                                                                                \
     if ( (cache_ptr)->slist_enabled ) {                                        \
                                                                                \
-        HDassert( (entry_ptr) );                                               \
-        HDassert( !((entry_ptr)->is_read_only) );                              \
-        HDassert( ((entry_ptr)->ro_ref_count) == 0 );                          \
-        HDassert( (entry_ptr)->in_slist );                                     \
-        HDassert( (cache_ptr)->slist_ptr );                                    \
-        HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                    \
-        HDassert( (entry_ptr)->ring < H5C_RING_NTYPES );                       \
-        HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=            \
+        assert( (entry_ptr) );                                               \
+        assert( !((entry_ptr)->is_read_only) );                              \
+        assert( ((entry_ptr)->ro_ref_count) == 0 );                          \
+        assert( (entry_ptr)->in_slist );                                     \
+        assert( (cache_ptr)->slist_ptr );                                    \
+        assert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                    \
+        assert( (entry_ptr)->ring < H5C_RING_NTYPES );                       \
+        assert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=            \
                   (cache_ptr)->slist_len );                                    \
-        HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=           \
+        assert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=           \
                   (cache_ptr)->slist_size );                                   \
                                                                                \
         if ( H5SL_remove((cache_ptr)->slist_ptr, &(entry_ptr)->addr)           \
@@ -1530,22 +1530,22 @@ if ( ( (cache_ptr)->index_size !=                                           \
             HGOTO_ERROR(H5E_CACHE, H5E_BADVALUE, FAIL,                         \
                         "can't delete entry from skip list")                   \
                                                                                \
-        HDassert( (cache_ptr)->slist_len > 0 );                                \
+        assert( (cache_ptr)->slist_len > 0 );                                \
         if(!(during_flush))                                                    \
             (cache_ptr)->slist_changed = TRUE;                                 \
         (cache_ptr)->slist_len--;                                              \
-        HDassert( (cache_ptr)->slist_size >= (entry_ptr)->size );              \
+        assert( (cache_ptr)->slist_size >= (entry_ptr)->size );              \
         (cache_ptr)->slist_size -= (entry_ptr)->size;                          \
         ((cache_ptr)->slist_ring_len[(entry_ptr)->ring])--;                    \
-        HDassert( (cache_ptr)->slist_ring_size[((entry_ptr)->ring)] >=           \
+        assert( (cache_ptr)->slist_ring_size[((entry_ptr)->ring)] >=           \
                   (entry_ptr)->size );                                         \
         ((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (entry_ptr)->size;\
         (entry_ptr)->in_slist = FALSE;                                         \
                                                                                \
     } else { /* slist disabled */                                              \
                                                                                \
-        HDassert( (cache_ptr)->slist_len == 0 );                               \
-        HDassert( (cache_ptr)->slist_size == 0 );                              \
+        assert( (cache_ptr)->slist_len == 0 );                               \
+        assert( (cache_ptr)->slist_size == 0 );                              \
     }                                                                          \
 } /* H5C__REMOVE_ENTRY_FROM_SLIST */
 
@@ -1570,28 +1570,28 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #define H5C__UPDATE_SLIST_FOR_SIZE_CHANGE(cache_ptr, old_size, new_size)      \
 {                                                                             \
-    HDassert( (cache_ptr) );                                                  \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                       \
+    assert( (cache_ptr) );                                                  \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                       \
                                                                               \
     if ( (cache_ptr)->slist_enabled ) {                                       \
                                                                               \
-        HDassert( (old_size) > 0 );                                           \
-        HDassert( (new_size) > 0 );                                           \
-        HDassert( (old_size) <= (cache_ptr)->slist_size );                    \
-        HDassert( (cache_ptr)->slist_len > 0 );                               \
-        HDassert( ((cache_ptr)->slist_len > 1) ||                             \
+        assert( (old_size) > 0 );                                           \
+        assert( (new_size) > 0 );                                           \
+        assert( (old_size) <= (cache_ptr)->slist_size );                    \
+        assert( (cache_ptr)->slist_len > 0 );                               \
+        assert( ((cache_ptr)->slist_len > 1) ||                             \
                   ( (cache_ptr)->slist_size == (old_size) ) );                \
-        HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                   \
-        HDassert( (entry_ptr)->ring < H5C_RING_NTYPES );                      \
-        HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=           \
+        assert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                   \
+        assert( (entry_ptr)->ring < H5C_RING_NTYPES );                      \
+        assert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=           \
                   (cache_ptr)->slist_len );                                   \
-        HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=          \
+        assert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=          \
                   (cache_ptr)->slist_size );                                  \
                                                                               \
         (cache_ptr)->slist_size -= (old_size);                                \
         (cache_ptr)->slist_size += (new_size);                                \
                                                                               \
-        HDassert( (cache_ptr)->slist_ring_size[((entry_ptr)->ring)]             \
+        assert( (cache_ptr)->slist_ring_size[((entry_ptr)->ring)]             \
                   >= (old_size) );                                            \
                                                                               \
         ((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (old_size);      \
@@ -1600,14 +1600,14 @@ if ( ( (cache_ptr)->index_size !=                                           \
         (cache_ptr)->slist_size_increase -= (int64_t)(old_size);              \
         (cache_ptr)->slist_size_increase += (int64_t)(new_size);              \
                                                                               \
-        HDassert( (new_size) <= (cache_ptr)->slist_size );                    \
-        HDassert( ( (cache_ptr)->slist_len > 1 ) ||                           \
+        assert( (new_size) <= (cache_ptr)->slist_size );                    \
+        assert( ( (cache_ptr)->slist_len > 1 ) ||                           \
                   ( (cache_ptr)->slist_size == (new_size) ) );                \
                                                                               \
     } else { /* slist disabled */                                             \
                                                                               \
-        HDassert( (cache_ptr)->slist_len == 0 );                              \
-        HDassert( (cache_ptr)->slist_size == 0 );                             \
+        assert( (cache_ptr)->slist_len == 0 );                              \
+        assert( (cache_ptr)->slist_size == 0 );                             \
     }                                                                         \
 } /* H5C__UPDATE_SLIST_FOR_SIZE_CHANGE */
 
@@ -1615,40 +1615,40 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #define H5C__UPDATE_SLIST_FOR_SIZE_CHANGE(cache_ptr, old_size, new_size)      \
 {                                                                             \
-    HDassert( (cache_ptr) );                                                  \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                       \
+    assert( (cache_ptr) );                                                  \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                       \
                                                                               \
     if ( (cache_ptr)->slist_enabled ) {                                       \
                                                                               \
-        HDassert( (old_size) > 0 );                                           \
-        HDassert( (new_size) > 0 );                                           \
-        HDassert( (old_size) <= (cache_ptr)->slist_size );                    \
-        HDassert( (cache_ptr)->slist_len > 0 );                               \
-        HDassert( ((cache_ptr)->slist_len > 1) ||                             \
+        assert( (old_size) > 0 );                                           \
+        assert( (new_size) > 0 );                                           \
+        assert( (old_size) <= (cache_ptr)->slist_size );                    \
+        assert( (cache_ptr)->slist_len > 0 );                               \
+        assert( ((cache_ptr)->slist_len > 1) ||                             \
                   ( (cache_ptr)->slist_size == (old_size) ) );                \
-        HDassert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                   \
-        HDassert( (entry_ptr)->ring < H5C_RING_NTYPES );                      \
-        HDassert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=           \
+        assert( (entry_ptr)->ring > H5C_RING_UNDEFINED );                   \
+        assert( (entry_ptr)->ring < H5C_RING_NTYPES );                      \
+        assert( (cache_ptr)->slist_ring_len[(entry_ptr)->ring] <=           \
                   (cache_ptr)->slist_len );                                   \
-        HDassert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=          \
+        assert( (cache_ptr)->slist_ring_size[(entry_ptr)->ring] <=          \
                   (cache_ptr)->slist_size );                                  \
                                                                               \
         (cache_ptr)->slist_size -= (old_size);                                \
         (cache_ptr)->slist_size += (new_size);                                \
                                                                               \
-        HDassert( (cache_ptr)->slist_ring_size[((entry_ptr)->ring)] >=          \
+        assert( (cache_ptr)->slist_ring_size[((entry_ptr)->ring)] >=          \
                   (old_size) );                                               \
         ((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) -= (old_size);      \
         ((cache_ptr)->slist_ring_size[(entry_ptr)->ring]) += (new_size);      \
                                                                               \
-        HDassert( (new_size) <= (cache_ptr)->slist_size );                    \
-        HDassert( ( (cache_ptr)->slist_len > 1 ) ||                           \
+        assert( (new_size) <= (cache_ptr)->slist_size );                    \
+        assert( ( (cache_ptr)->slist_len > 1 ) ||                           \
                   ( (cache_ptr)->slist_size == (new_size) ) );                \
                                                                               \
     } else { /* slist disabled */                                             \
                                                                               \
-        HDassert( (cache_ptr)->slist_len == 0 );                              \
-        HDassert( (cache_ptr)->slist_size == 0 );                             \
+        assert( (cache_ptr)->slist_len == 0 );                              \
+        assert( (cache_ptr)->slist_size == 0 );                             \
     }                                                                         \
 } /* H5C__UPDATE_SLIST_FOR_SIZE_CHANGE */
 
@@ -1684,14 +1684,14 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #define H5C__UPDATE_RP_FOR_EVICTION(cache_ptr, entry_ptr, fail_val)          \
 {                                                                            \
-    HDassert( (cache_ptr) );                                                 \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                      \
-    HDassert( (entry_ptr) );                                                 \
-    HDassert( !((entry_ptr)->is_protected) );                                \
-    HDassert( !((entry_ptr)->is_read_only) );                                \
-    HDassert( ((entry_ptr)->ro_ref_count) == 0 );                            \
-    HDassert( !((entry_ptr)->is_pinned) );                                   \
-    HDassert( (entry_ptr)->size > 0 );                                       \
+    assert( (cache_ptr) );                                                 \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                      \
+    assert( (entry_ptr) );                                                 \
+    assert( !((entry_ptr)->is_protected) );                                \
+    assert( !((entry_ptr)->is_read_only) );                                \
+    assert( ((entry_ptr)->ro_ref_count) == 0 );                            \
+    assert( !((entry_ptr)->is_pinned) );                                   \
+    assert( (entry_ptr)->size > 0 );                                       \
                                                                              \
     /* modified LRU specific code */                                         \
                                                                              \
@@ -1726,14 +1726,14 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #define H5C__UPDATE_RP_FOR_EVICTION(cache_ptr, entry_ptr, fail_val)          \
 {                                                                            \
-    HDassert( (cache_ptr) );                                                 \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                      \
-    HDassert( (entry_ptr) );                                                 \
-    HDassert( !((entry_ptr)->is_protected) );                                \
-    HDassert( !((entry_ptr)->is_read_only) );                                \
-    HDassert( ((entry_ptr)->ro_ref_count) == 0 );                            \
-    HDassert( !((entry_ptr)->is_pinned) );                                   \
-    HDassert( (entry_ptr)->size > 0 );                                       \
+    assert( (cache_ptr) );                                                 \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                      \
+    assert( (entry_ptr) );                                                 \
+    assert( !((entry_ptr)->is_protected) );                                \
+    assert( !((entry_ptr)->is_read_only) );                                \
+    assert( ((entry_ptr)->ro_ref_count) == 0 );                            \
+    assert( !((entry_ptr)->is_pinned) );                                   \
+    assert( (entry_ptr)->size > 0 );                                       \
                                                                              \
     /* modified LRU specific code */                                         \
                                                                              \
@@ -1771,13 +1771,13 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #define H5C__UPDATE_RP_FOR_FLUSH(cache_ptr, entry_ptr, fail_val)            \
 {                                                                           \
-    HDassert( (cache_ptr) );                                                \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                     \
-    HDassert( (entry_ptr) );                                                \
-    HDassert( !((entry_ptr)->is_protected) );                               \
-    HDassert( !((entry_ptr)->is_read_only) );                               \
-    HDassert( ((entry_ptr)->ro_ref_count) == 0 );                           \
-    HDassert( (entry_ptr)->size > 0 );                                      \
+    assert( (cache_ptr) );                                                \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                     \
+    assert( (entry_ptr) );                                                \
+    assert( !((entry_ptr)->is_protected) );                               \
+    assert( !((entry_ptr)->is_read_only) );                               \
+    assert( ((entry_ptr)->ro_ref_count) == 0 );                           \
+    assert( (entry_ptr)->size > 0 );                                      \
                                                                             \
     if ( ! ((entry_ptr)->is_pinned) ) {                                     \
                                                                             \
@@ -1833,13 +1833,13 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #define H5C__UPDATE_RP_FOR_FLUSH(cache_ptr, entry_ptr, fail_val)            \
 {                                                                           \
-    HDassert( (cache_ptr) );                                                \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                     \
-    HDassert( (entry_ptr) );                                                \
-    HDassert( !((entry_ptr)->is_protected) );                               \
-    HDassert( !((entry_ptr)->is_read_only) );                               \
-    HDassert( ((entry_ptr)->ro_ref_count) == 0 );                           \
-    HDassert( (entry_ptr)->size > 0 );                                      \
+    assert( (cache_ptr) );                                                \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                     \
+    assert( (entry_ptr) );                                                \
+    assert( !((entry_ptr)->is_protected) );                               \
+    assert( !((entry_ptr)->is_read_only) );                               \
+    assert( ((entry_ptr)->ro_ref_count) == 0 );                           \
+    assert( (entry_ptr)->size > 0 );                                      \
                                                                             \
     if ( ! ((entry_ptr)->is_pinned) ) {                                     \
                                                                             \
@@ -1897,13 +1897,13 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #define H5C__UPDATE_RP_FOR_INSERT_APPEND(cache_ptr, entry_ptr, fail_val)   \
 {                                                                          \
-    HDassert( (cache_ptr) );                                               \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                    \
-    HDassert( (entry_ptr) );                                               \
-    HDassert( !((entry_ptr)->is_protected) );                              \
-    HDassert( !((entry_ptr)->is_read_only) );                              \
-    HDassert( ((entry_ptr)->ro_ref_count) == 0 );                          \
-    HDassert( (entry_ptr)->size > 0 );                                     \
+    assert( (cache_ptr) );                                               \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                    \
+    assert( (entry_ptr) );                                               \
+    assert( !((entry_ptr)->is_protected) );                              \
+    assert( !((entry_ptr)->is_read_only) );                              \
+    assert( ((entry_ptr)->ro_ref_count) == 0 );                          \
+    assert( (entry_ptr)->size > 0 );                                     \
                                                                            \
     if ( (entry_ptr)->is_pinned ) {                                        \
                                                                            \
@@ -1947,13 +1947,13 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #define H5C__UPDATE_RP_FOR_INSERT_APPEND(cache_ptr, entry_ptr, fail_val)   \
 {                                                                          \
-    HDassert( (cache_ptr) );                                               \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                    \
-    HDassert( (entry_ptr) );                                               \
-    HDassert( !((entry_ptr)->is_protected) );                              \
-    HDassert( !((entry_ptr)->is_read_only) );                              \
-    HDassert( ((entry_ptr)->ro_ref_count) == 0 );                          \
-    HDassert( (entry_ptr)->size > 0 );                                     \
+    assert( (cache_ptr) );                                               \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                    \
+    assert( (entry_ptr) );                                               \
+    assert( !((entry_ptr)->is_protected) );                              \
+    assert( !((entry_ptr)->is_read_only) );                              \
+    assert( ((entry_ptr)->ro_ref_count) == 0 );                          \
+    assert( (entry_ptr)->size > 0 );                                     \
                                                                            \
     if ( (entry_ptr)->is_pinned ) {                                        \
                                                                            \
@@ -2003,13 +2003,13 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #define H5C__UPDATE_RP_FOR_INSERTION(cache_ptr, entry_ptr, fail_val)       \
 {                                                                          \
-    HDassert( (cache_ptr) );                                               \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                    \
-    HDassert( (entry_ptr) );                                               \
-    HDassert( !((entry_ptr)->is_protected) );                              \
-    HDassert( !((entry_ptr)->is_read_only) );                              \
-    HDassert( ((entry_ptr)->ro_ref_count) == 0 );                          \
-    HDassert( (entry_ptr)->size > 0 );                                     \
+    assert( (cache_ptr) );                                               \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                    \
+    assert( (entry_ptr) );                                               \
+    assert( !((entry_ptr)->is_protected) );                              \
+    assert( !((entry_ptr)->is_read_only) );                              \
+    assert( ((entry_ptr)->ro_ref_count) == 0 );                          \
+    assert( (entry_ptr)->size > 0 );                                     \
                                                                            \
     if ( (entry_ptr)->is_pinned ) {                                        \
                                                                            \
@@ -2053,13 +2053,13 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #define H5C__UPDATE_RP_FOR_INSERTION(cache_ptr, entry_ptr, fail_val)       \
 {                                                                          \
-    HDassert( (cache_ptr) );                                               \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                    \
-    HDassert( (entry_ptr) );                                               \
-    HDassert( !((entry_ptr)->is_protected) );                              \
-    HDassert( !((entry_ptr)->is_read_only) );                              \
-    HDassert( ((entry_ptr)->ro_ref_count) == 0 );                          \
-    HDassert( (entry_ptr)->size > 0 );                                     \
+    assert( (cache_ptr) );                                               \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                    \
+    assert( (entry_ptr) );                                               \
+    assert( !((entry_ptr)->is_protected) );                              \
+    assert( !((entry_ptr)->is_read_only) );                              \
+    assert( ((entry_ptr)->ro_ref_count) == 0 );                          \
+    assert( (entry_ptr)->size > 0 );                                     \
                                                                            \
     if ( (entry_ptr)->is_pinned ) {                                        \
                                                                            \
@@ -2113,13 +2113,13 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #define H5C__UPDATE_RP_FOR_PROTECT(cache_ptr, entry_ptr, fail_val)        \
 {                                                                         \
-    HDassert( (cache_ptr) );                                              \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                   \
-    HDassert( (entry_ptr) );                                              \
-    HDassert( !((entry_ptr)->is_protected) );                             \
-    HDassert( !((entry_ptr)->is_read_only) );                             \
-    HDassert( ((entry_ptr)->ro_ref_count) == 0 );                         \
-    HDassert( (entry_ptr)->size > 0 );                                    \
+    assert( (cache_ptr) );                                              \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                   \
+    assert( (entry_ptr) );                                              \
+    assert( !((entry_ptr)->is_protected) );                             \
+    assert( !((entry_ptr)->is_read_only) );                             \
+    assert( ((entry_ptr)->ro_ref_count) == 0 );                         \
+    assert( (entry_ptr)->size > 0 );                                    \
                                                                           \
     if ( (entry_ptr)->is_pinned ) {                                       \
                                                                           \
@@ -2175,13 +2175,13 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #define H5C__UPDATE_RP_FOR_PROTECT(cache_ptr, entry_ptr, fail_val)        \
 {                                                                         \
-    HDassert( (cache_ptr) );                                              \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                   \
-    HDassert( (entry_ptr) );                                              \
-    HDassert( !((entry_ptr)->is_protected) );                             \
-    HDassert( !((entry_ptr)->is_read_only) );                             \
-    HDassert( ((entry_ptr)->ro_ref_count) == 0 );                         \
-    HDassert( (entry_ptr)->size > 0 );                                    \
+    assert( (cache_ptr) );                                              \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                   \
+    assert( (entry_ptr) );                                              \
+    assert( !((entry_ptr)->is_protected) );                             \
+    assert( !((entry_ptr)->is_read_only) );                             \
+    assert( ((entry_ptr)->ro_ref_count) == 0 );                         \
+    assert( (entry_ptr)->size > 0 );                                    \
                                                                           \
     if ( (entry_ptr)->is_pinned ) {                                       \
                                                                           \
@@ -2240,12 +2240,12 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #define H5C__UPDATE_RP_FOR_MOVE(cache_ptr, entry_ptr, was_dirty, fail_val) \
 {                                                                            \
-    HDassert( (cache_ptr) );                                                 \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                      \
-    HDassert( (entry_ptr) );                                                 \
-    HDassert( !((entry_ptr)->is_read_only) );                                \
-    HDassert( ((entry_ptr)->ro_ref_count) == 0 );                            \
-    HDassert( (entry_ptr)->size > 0 );                                       \
+    assert( (cache_ptr) );                                                 \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                      \
+    assert( (entry_ptr) );                                                 \
+    assert( !((entry_ptr)->is_read_only) );                                \
+    assert( ((entry_ptr)->ro_ref_count) == 0 );                            \
+    assert( (entry_ptr)->size > 0 );                                       \
                                                                              \
     if ( ! ( (entry_ptr)->is_pinned ) && ! ( ((entry_ptr)->is_protected ) ) ) {\
                                                                              \
@@ -2317,12 +2317,12 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #define H5C__UPDATE_RP_FOR_MOVE(cache_ptr, entry_ptr, was_dirty, fail_val)   \
 {                                                                            \
-    HDassert( (cache_ptr) );                                                 \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                      \
-    HDassert( (entry_ptr) );                                                 \
-    HDassert( !((entry_ptr)->is_read_only) );                                \
-    HDassert( ((entry_ptr)->ro_ref_count) == 0 );                            \
-    HDassert( (entry_ptr)->size > 0 );                                       \
+    assert( (cache_ptr) );                                                 \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                      \
+    assert( (entry_ptr) );                                                 \
+    assert( !((entry_ptr)->is_read_only) );                                \
+    assert( ((entry_ptr)->ro_ref_count) == 0 );                            \
+    assert( (entry_ptr)->size > 0 );                                       \
                                                                              \
     if ( ! ( (entry_ptr)->is_pinned ) && ! ( ((entry_ptr)->is_protected ) ) ) {\
                                                                              \
@@ -2378,14 +2378,14 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #define H5C__UPDATE_RP_FOR_SIZE_CHANGE(cache_ptr, entry_ptr, new_size, fail_val)    \
 {                                                                         \
-    HDassert( (cache_ptr) );                                              \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                   \
-    HDassert( (entry_ptr) );                                              \
-    HDassert( !((entry_ptr)->is_protected) );                             \
-    HDassert( !((entry_ptr)->is_read_only) );                             \
-    HDassert( ((entry_ptr)->ro_ref_count) == 0 );                         \
-    HDassert( (entry_ptr)->size > 0 );                                    \
-    HDassert( new_size > 0 );                                             \
+    assert( (cache_ptr) );                                              \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                   \
+    assert( (entry_ptr) );                                              \
+    assert( !((entry_ptr)->is_protected) );                             \
+    assert( !((entry_ptr)->is_read_only) );                             \
+    assert( ((entry_ptr)->ro_ref_count) == 0 );                         \
+    assert( (entry_ptr)->size > 0 );                                    \
+    assert( new_size > 0 );                                             \
                                                                           \
     if ( (entry_ptr)->coll_access ) {                                     \
                                                                           \
@@ -2443,14 +2443,14 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #define H5C__UPDATE_RP_FOR_SIZE_CHANGE(cache_ptr, entry_ptr, new_size, fail_val)    \
 {                                                                         \
-    HDassert( (cache_ptr) );                                              \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                   \
-    HDassert( (entry_ptr) );                                              \
-    HDassert( !((entry_ptr)->is_protected) );                             \
-    HDassert( !((entry_ptr)->is_read_only) );                             \
-    HDassert( ((entry_ptr)->ro_ref_count) == 0 );                         \
-    HDassert( (entry_ptr)->size > 0 );                                    \
-    HDassert( new_size > 0 );                                             \
+    assert( (cache_ptr) );                                              \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                   \
+    assert( (entry_ptr) );                                              \
+    assert( !((entry_ptr)->is_protected) );                             \
+    assert( !((entry_ptr)->is_read_only) );                             \
+    assert( ((entry_ptr)->ro_ref_count) == 0 );                         \
+    assert( (entry_ptr)->size > 0 );                                    \
+    assert( new_size > 0 );                                             \
                                         \
     if ( (entry_ptr)->is_pinned ) {                                       \
                                                                           \
@@ -2505,14 +2505,14 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #define H5C__UPDATE_RP_FOR_UNPIN(cache_ptr, entry_ptr, fail_val)       \
 {                                                                      \
-    HDassert( (cache_ptr) );                                           \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                \
-    HDassert( (entry_ptr) );                                           \
-    HDassert( !((entry_ptr)->is_protected) );                          \
-    HDassert( !((entry_ptr)->is_read_only) );                          \
-    HDassert( ((entry_ptr)->ro_ref_count) == 0 );                      \
-    HDassert( (entry_ptr)->is_pinned);                                 \
-    HDassert( (entry_ptr)->size > 0 );                                 \
+    assert( (cache_ptr) );                                           \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                \
+    assert( (entry_ptr) );                                           \
+    assert( !((entry_ptr)->is_protected) );                          \
+    assert( !((entry_ptr)->is_read_only) );                          \
+    assert( ((entry_ptr)->ro_ref_count) == 0 );                      \
+    assert( (entry_ptr)->is_pinned);                                 \
+    assert( (entry_ptr)->size > 0 );                                 \
                                                                        \
     /* Regardless of the replacement policy, remove the entry from the \
      * pinned entry list.                                              \
@@ -2561,14 +2561,14 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #define H5C__UPDATE_RP_FOR_UNPIN(cache_ptr, entry_ptr, fail_val)       \
 {                                                                      \
-    HDassert( (cache_ptr) );                                           \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                \
-    HDassert( (entry_ptr) );                                           \
-    HDassert( !((entry_ptr)->is_protected) );                          \
-    HDassert( !((entry_ptr)->is_read_only) );                          \
-    HDassert( ((entry_ptr)->ro_ref_count) == 0 );                      \
-    HDassert( (entry_ptr)->is_pinned);                                 \
-    HDassert( (entry_ptr)->size > 0 );                                 \
+    assert( (cache_ptr) );                                           \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                \
+    assert( (entry_ptr) );                                           \
+    assert( !((entry_ptr)->is_protected) );                          \
+    assert( !((entry_ptr)->is_read_only) );                          \
+    assert( ((entry_ptr)->ro_ref_count) == 0 );                      \
+    assert( (entry_ptr)->is_pinned);                                 \
+    assert( (entry_ptr)->size > 0 );                                 \
                                                                        \
     /* Regardless of the replacement policy, remove the entry from the \
      * pinned entry list.                                              \
@@ -2620,11 +2620,11 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #define H5C__UPDATE_RP_FOR_UNPROTECT(cache_ptr, entry_ptr, fail_val)       \
 {                                                                          \
-    HDassert( (cache_ptr) );                                               \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                    \
-    HDassert( (entry_ptr) );                                               \
-    HDassert( (entry_ptr)->is_protected);                                  \
-    HDassert( (entry_ptr)->size > 0 );                                     \
+    assert( (cache_ptr) );                                               \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                    \
+    assert( (entry_ptr) );                                               \
+    assert( (entry_ptr)->is_protected);                                  \
+    assert( (entry_ptr)->size > 0 );                                     \
                                                                            \
     /* Regardless of the replacement policy, remove the entry from the     \
      * protected list.                                                     \
@@ -2679,11 +2679,11 @@ if ( ( (cache_ptr)->index_size !=                                           \
 
 #define H5C__UPDATE_RP_FOR_UNPROTECT(cache_ptr, entry_ptr, fail_val)       \
 {                                                                          \
-    HDassert( (cache_ptr) );                                               \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                    \
-    HDassert( (entry_ptr) );                                               \
-    HDassert( (entry_ptr)->is_protected);                                  \
-    HDassert( (entry_ptr)->size > 0 );                                     \
+    assert( (cache_ptr) );                                               \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                    \
+    assert( (entry_ptr) );                                               \
+    assert( (entry_ptr)->is_protected);                                  \
+    assert( (entry_ptr)->size > 0 );                                     \
                                                                            \
     /* Regardless of the replacement policy, remove the entry from the     \
      * protected list.                                                     \
@@ -2873,9 +2873,9 @@ if ( ( (entry_ptr) == NULL ) ||                                                \
 
 #define H5C__INSERT_IN_COLL_LIST(cache_ptr, entry_ptr, fail_val)        \
 {                                                                       \
-    HDassert( (cache_ptr) );                                            \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                 \
-    HDassert( (entry_ptr) );                                            \
+    assert( (cache_ptr) );                                            \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                 \
+    assert( (entry_ptr) );                                            \
                                                                         \
     /* insert the entry at the head of the list. */                     \
                                                                         \
@@ -2903,9 +2903,9 @@ if ( ( (entry_ptr) == NULL ) ||                                                \
 
 #define H5C__REMOVE_FROM_COLL_LIST(cache_ptr, entry_ptr, fail_val)      \
 {                                                                       \
-    HDassert( (cache_ptr) );                                            \
-    HDassert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                 \
-    HDassert( (entry_ptr) );                                            \
+    assert( (cache_ptr) );                                            \
+    assert( (cache_ptr)->magic == H5C__H5C_T_MAGIC );                 \
+    assert( (entry_ptr) );                                            \
                                                                         \
     /* remove the entry from the list. */                               \
                                                                         \
@@ -2933,9 +2933,9 @@ if ( ( (entry_ptr) == NULL ) ||                                                \
 
 #define H5C__MOVE_TO_TOP_IN_COLL_LIST(cache_ptr, entry_ptr, fail_val)   \
 {                                                                       \
-    HDassert((cache_ptr));                                              \
-    HDassert((cache_ptr)->magic == H5C__H5C_T_MAGIC);                   \
-    HDassert((entry_ptr));                                              \
+    assert((cache_ptr));                                              \
+    assert((cache_ptr)->magic == H5C__H5C_T_MAGIC);                   \
+    assert((entry_ptr));                                              \
                                                                         \
     /* Remove entry and insert at the head of the list. */              \
     H5C__COLL_DLL_REMOVE((entry_ptr), (cache_ptr)->coll_head_ptr,       \
@@ -3314,7 +3314,7 @@ typedef struct H5C_tag_info_t {
  *        Note: At this time, the this field will only be applied to
  *              two types of entries: the superblock and the file driver info
  *              message.  The code utilizing these flags is protected with
- *              HDasserts to enforce this.
+ *              asserts to enforce this.
  *
  * The cache must deal with the case in which entries may be dirtied, moved,
  * or have their sizes changed during a flush.  To allow sanity checks in this