Convert hbool_t --> bool in src (#3496)

* hbool_t --> bool in src

* Does not remove TRUE/FALSE
* Public header files are unchanged
* Public API calls are unchanged

* TRUE/FALSE --> true/false in src

* Add deprecation notice for hbool_t

1 files changed, 77 insertions, 77 deletions

diff --git a/src/H5HFcache.c b/src/H5HFcache.c
index c34a374..9f2fa0a 100644
--- a/src/H5HFcache.c
+++ b/src/H5HFcache.c
@@ -68,7 +68,7 @@ static herr_t H5HF__cache_hdr_get_initial_load_size(void *udata, size_t *image_l
 static herr_t H5HF__cache_hdr_get_final_load_size(const void *image_ptr, size_t image_len, void *udata,
                                                   size_t *actual_len);
 static htri_t H5HF__cache_hdr_verify_chksum(const void *image_ptr, size_t len, void *udata_ptr);
-static void  *H5HF__cache_hdr_deserialize(const void *image, size_t len, void *udata, hbool_t *dirty);
+static void  *H5HF__cache_hdr_deserialize(const void *image, size_t len, void *udata, bool *dirty);
 static herr_t H5HF__cache_hdr_image_len(const void *thing, size_t *image_len);
 static herr_t H5HF__cache_hdr_pre_serialize(H5F_t *f, void *thing, haddr_t addr, size_t len,
                                             haddr_t *new_addr, size_t *new_len, unsigned *flags);
@@ -77,7 +77,7 @@ static herr_t H5HF__cache_hdr_free_icr(void *thing);
 
 static herr_t H5HF__cache_iblock_get_initial_load_size(void *udata, size_t *image_len);
 static htri_t H5HF__cache_iblock_verify_chksum(const void *image_ptr, size_t len, void *udata_ptr);
-static void  *H5HF__cache_iblock_deserialize(const void *image, size_t len, void *udata, hbool_t *dirty);
+static void  *H5HF__cache_iblock_deserialize(const void *image, size_t len, void *udata, bool *dirty);
 static herr_t H5HF__cache_iblock_image_len(const void *thing, size_t *image_len);
 static herr_t H5HF__cache_iblock_pre_serialize(H5F_t *f, void *thing, haddr_t addr, size_t len,
                                                haddr_t *new_addr, size_t *new_len, unsigned *flags);
@@ -87,7 +87,7 @@ static herr_t H5HF__cache_iblock_free_icr(void *thing);
 
 static herr_t H5HF__cache_dblock_get_initial_load_size(void *udata, size_t *image_len);
 static htri_t H5HF__cache_dblock_verify_chksum(const void *image_ptr, size_t len, void *udata_ptr);
-static void  *H5HF__cache_dblock_deserialize(const void *image, size_t len, void *udata, hbool_t *dirty);
+static void  *H5HF__cache_dblock_deserialize(const void *image, size_t len, void *udata, bool *dirty);
 static herr_t H5HF__cache_dblock_image_len(const void *thing, size_t *image_len);
 static herr_t H5HF__cache_dblock_pre_serialize(H5F_t *f, void *thing, haddr_t addr, size_t len,
                                                haddr_t *new_addr, size_t *new_len, unsigned *flags);
@@ -98,17 +98,17 @@ static herr_t H5HF__cache_dblock_fsf_size(const void *_thing, hsize_t *fsf_size)
 
 /* Debugging Function Prototypes */
 #ifndef NDEBUG
-static herr_t H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr, hbool_t *fd_clean,
-                                                       hbool_t *clean);
+static herr_t H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr, bool *fd_clean,
+                                                       bool *clean);
 static herr_t H5HF__cache_verify_iblock_descendants_clean(H5F_t *f, haddr_t fd_parent_addr,
                                                           H5HF_indirect_t *iblock, unsigned *iblock_status,
-                                                          hbool_t *fd_clean, hbool_t *clean);
+                                                          bool *fd_clean, bool *clean);
 static herr_t H5HF__cache_verify_iblocks_dblocks_clean(H5F_t *f, haddr_t fd_parent_addr,
-                                                       H5HF_indirect_t *iblock, hbool_t *fd_clean,
-                                                       hbool_t *clean, hbool_t *has_dblocks);
+                                                       H5HF_indirect_t *iblock, bool *fd_clean, bool *clean,
+                                                       bool *has_dblocks);
 static herr_t H5HF__cache_verify_descendant_iblocks_clean(H5F_t *f, haddr_t fd_parent_addr,
-                                                          H5HF_indirect_t *iblock, hbool_t *fd_clean,
-                                                          hbool_t *clean, hbool_t *has_iblocks);
+                                                          H5HF_indirect_t *iblock, bool *fd_clean,
+                                                          bool *clean, bool *has_iblocks);
 #endif /* NDEBUG */
 
 /*********************/
@@ -400,7 +400,7 @@ done:
  * Purpose:     Verify the computed checksum of the data structure is the
  *              same as the stored chksum.
  *
- * Return:      Success:        TRUE/FALSE
+ * Return:      Success:        true/false
  *              Failure:        Negative
  *
  *-------------------------------------------------------------------------
@@ -411,7 +411,7 @@ H5HF__cache_hdr_verify_chksum(const void *_image, size_t len, void H5_ATTR_UNUSE
     const uint8_t *image = (const uint8_t *)_image; /* Pointer into raw data buffer */
     uint32_t       stored_chksum;                   /* Stored metadata checksum value */
     uint32_t       computed_chksum;                 /* Computed metadata checksum value */
-    htri_t         ret_value = TRUE;                /* Return value */
+    htri_t         ret_value = true;                /* Return value */
 
     FUNC_ENTER_PACKAGE_NOERR
 
@@ -422,7 +422,7 @@ H5HF__cache_hdr_verify_chksum(const void *_image, size_t len, void H5_ATTR_UNUSE
     H5F_get_checksums(image, len, &stored_chksum, &computed_chksum);
 
     if (stored_chksum != computed_chksum)
-        ret_value = FALSE;
+        ret_value = false;
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5HF__cache_hdr_verify_chksum() */
@@ -441,7 +441,7 @@ H5HF__cache_hdr_verify_chksum(const void *_image, size_t len, void H5_ATTR_UNUSE
  *-------------------------------------------------------------------------
  */
 static void *
-H5HF__cache_hdr_deserialize(const void *_image, size_t len, void *_udata, hbool_t H5_ATTR_UNUSED *dirty)
+H5HF__cache_hdr_deserialize(const void *_image, size_t len, void *_udata, bool H5_ATTR_UNUSED *dirty)
 {
     H5HF_hdr_t          *hdr   = NULL;                          /* Fractal heap info */
     H5HF_hdr_cache_ud_t *udata = (H5HF_hdr_cache_ud_t *)_udata; /* User data for callback */
@@ -628,8 +628,8 @@ H5HF__cache_hdr_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t len,
 
 #ifndef NDEBUG
     {
-        hbool_t descendants_clean = TRUE;
-        hbool_t fd_children_clean = TRUE;
+        bool descendants_clean = true;
+        bool fd_children_clean = true;
 
         /* Verify that flush dependencies are working correctly.  Do this
          * by verifying that either:
@@ -764,7 +764,7 @@ H5HF__cache_hdr_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_NDEBUG_UN
         UINT32ENCODE(image, hdr->pline_root_direct_filter_mask);
 
         /* Encode I/O filter information */
-        if (H5O_msg_encode(hdr->f, H5O_PLINE_ID, FALSE, image, &(hdr->pline)) < 0)
+        if (H5O_msg_encode(hdr->f, H5O_PLINE_ID, false, image, &(hdr->pline)) < 0)
             HGOTO_ERROR(H5E_HEAP, H5E_CANTENCODE, FAIL, "can't encode I/O pipeline filters");
         image += hdr->filter_len;
     } /* end if */
@@ -855,7 +855,7 @@ H5HF__cache_iblock_get_initial_load_size(void *_udata, size_t *image_len)
  * Purpose:     Verify the computed checksum of the data structure is the
  *              same as the stored checksum.
  *
- * Return:      Success:        TRUE/FALSE
+ * Return:      Success:        true/false
  *              Failure:        Negative
  *
  *-------------------------------------------------------------------------
@@ -866,7 +866,7 @@ H5HF__cache_iblock_verify_chksum(const void *_image, size_t len, void H5_ATTR_UN
     const uint8_t *image = (const uint8_t *)_image; /* Pointer into raw data buffer */
     uint32_t       stored_chksum;                   /* Stored metadata checksum value */
     uint32_t       computed_chksum;                 /* Computed metadata checksum value */
-    htri_t         ret_value = TRUE;                /* Return value */
+    htri_t         ret_value = true;                /* Return value */
 
     FUNC_ENTER_PACKAGE_NOERR
 
@@ -877,7 +877,7 @@ H5HF__cache_iblock_verify_chksum(const void *_image, size_t len, void H5_ATTR_UN
     H5F_get_checksums(image, len, &stored_chksum, &computed_chksum);
 
     if (stored_chksum != computed_chksum)
-        ret_value = FALSE;
+        ret_value = false;
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5HF__cache_iblock_verify_chksum() */
@@ -901,7 +901,7 @@ H5HF__cache_iblock_verify_chksum(const void *_image, size_t len, void H5_ATTR_UN
  */
 static void *
 H5HF__cache_iblock_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED len, void *_udata,
-                               hbool_t H5_ATTR_UNUSED *dirty)
+                               bool H5_ATTR_UNUSED *dirty)
 {
     H5HF_hdr_t             *hdr;                                       /* Shared fractal heap information */
     H5HF_iblock_cache_ud_t *udata  = (H5HF_iblock_cache_ud_t *)_udata; /* User data for callback */
@@ -1145,8 +1145,8 @@ H5HF__cache_iblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t H5
 
 #ifndef NDEBUG
     {
-        hbool_t  descendants_clean = TRUE;
-        hbool_t  fd_children_clean = TRUE;
+        bool     descendants_clean = true;
+        bool     fd_children_clean = true;
         unsigned iblock_status     = 0;
 
         /* verify that flush dependencies are working correctly.  Do this
@@ -1521,7 +1521,7 @@ H5HF__cache_dblock_get_initial_load_size(void *_udata, size_t *image_len)
  * Purpose:     Verify the computed checksum of the data structure is the
  *              same as the stored chksum.
  *
- * Return:      Success:        TRUE/FALSE
+ * Return:      Success:        true/false
  *              Failure:        Negative
  *
  *-------------------------------------------------------------------------
@@ -1538,7 +1538,7 @@ H5HF__cache_dblock_verify_chksum(const void *_image, size_t len, void *_udata)
     uint32_t                computed_chksum;  /* Computed metadata checksum value */
     size_t                  chk_size;         /* The size for validating checksum */
     uint8_t                *chk_p;            /* Pointer to the area for validating checksum */
-    htri_t                  ret_value = TRUE; /* Return value */
+    htri_t                  ret_value = true; /* Return value */
 
     FUNC_ENTER_PACKAGE
 
@@ -1552,7 +1552,7 @@ H5HF__cache_dblock_verify_chksum(const void *_image, size_t len, void *_udata)
 
     /* Get out if data block is not checksummed */
     if (!(hdr->checksum_dblocks))
-        HGOTO_DONE(TRUE);
+        HGOTO_DONE(true);
 
     if (hdr->filter_len > 0) {
         size_t   nbytes;      /* Number of bytes used in buffer, after applying reverse filters */
@@ -1581,7 +1581,7 @@ H5HF__cache_dblock_verify_chksum(const void *_image, size_t len, void *_udata)
             HGOTO_ERROR(H5E_HEAP, H5E_CANTFILTER, FAIL, "output pipeline failed");
 
         /* Update info about direct block */
-        udata->decompressed = TRUE;
+        udata->decompressed = true;
         len                 = nbytes;
     }
     else {
@@ -1613,7 +1613,7 @@ H5HF__cache_dblock_verify_chksum(const void *_image, size_t len, void *_udata)
 
     /* Verify checksum */
     if (stored_chksum != computed_chksum)
-        HGOTO_DONE(FALSE);
+        HGOTO_DONE(false);
 
     /* Save the decompressed data to be used later in deserialize callback */
     if (hdr->filter_len > 0) {
@@ -1655,7 +1655,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static void *
-H5HF__cache_dblock_deserialize(const void *_image, size_t len, void *_udata, hbool_t H5_ATTR_UNUSED *dirty)
+H5HF__cache_dblock_deserialize(const void *_image, size_t len, void *_udata, bool H5_ATTR_UNUSED *dirty)
 {
     H5HF_hdr_t             *hdr;                                      /* Shared fractal heap information */
     H5HF_dblock_cache_ud_t *udata = (H5HF_dblock_cache_ud_t *)_udata; /* User data for callback */
@@ -1963,8 +1963,8 @@ static herr_t
 H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t len, haddr_t *new_addr,
                                  size_t *new_len, unsigned *flags)
 {
-    hbool_t at_tmp_addr; /* Flag to indicate direct block is */
-                         /* at temporary address */
+    bool at_tmp_addr; /* Flag to indicate direct block is */
+                      /* at temporary address */
     haddr_t          dblock_addr;
     H5HF_hdr_t      *hdr;                              /* Shared fractal heap information */
     H5HF_direct_t   *dblock = (H5HF_direct_t *)_thing; /* Direct block info */
@@ -2108,7 +2108,7 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t le
 
         /* Check for root direct block */
         if (dblock->parent == NULL) {
-            hbool_t hdr_changed = FALSE; /* Whether the header info changed */
+            bool hdr_changed = false; /* Whether the header info changed */
 
             /* Sanity check */
             assert(H5_addr_eq(hdr->man_dtable.table_addr, addr));
@@ -2117,7 +2117,7 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t le
             /* Check if the filter mask changed */
             if (hdr->pline_root_direct_filter_mask != filter_mask) {
                 hdr->pline_root_direct_filter_mask = filter_mask;
-                hdr_changed                        = TRUE;
+                hdr_changed                        = true;
             } /* end if */
 
             /* verify that the cache's last record of the compressed
@@ -2153,16 +2153,16 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t le
                 hdr->pline_root_direct_size = write_size;
 
                 /* Note that heap header was modified */
-                hdr_changed = TRUE;
+                hdr_changed = true;
             } /* end if */
 
             /* Check if heap header was modified */
             if (hdr_changed)
                 if (H5HF__hdr_dirty(hdr) < 0)
                     HGOTO_ERROR(H5E_HEAP, H5E_CANTDIRTY, FAIL, "can't mark heap header as dirty");
-        }                                /* end if */
-        else {                           /* the direct block's parent is an indirect block */
-            hbool_t par_changed = FALSE; /* Whether the parent's infochanged */
+        }                             /* end if */
+        else {                        /* the direct block's parent is an indirect block */
+            bool par_changed = false; /* Whether the parent's infochanged */
 
             /* Sanity check */
             assert(par_iblock);
@@ -2171,7 +2171,7 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t le
             /* Check if the filter mask changed */
             if (par_iblock->filt_ents[par_entry].filter_mask != filter_mask) {
                 par_iblock->filt_ents[par_entry].filter_mask = filter_mask;
-                par_changed                                  = TRUE;
+                par_changed                                  = true;
             } /* end if */
 
             /* verify that the cache's last record of the compressed
@@ -2208,7 +2208,7 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t le
                 par_iblock->filt_ents[par_entry].size = write_size;
 
                 /* Note that parent was modified */
-                par_changed = TRUE;
+                par_changed = true;
             } /* end if */
 
             /* Check if parent was modified */
@@ -2493,7 +2493,7 @@ H5HF__cache_dblock_fsf_size(const void *_thing, hsize_t *fsf_size)
  * Purpose:	Sanity checking routine that verifies that all indirect
  *		and direct blocks that are descendants of the supplied
  *		instance of H5HF_hdr_t are clean.  Set *clean to
- *		TRUE if this is the case, and to FALSE otherwise.
+ *		true if this is the case, and to false otherwise.
  *
  *		Update -- 8/24/15
  *
@@ -2549,9 +2549,9 @@ H5HF__cache_dblock_fsf_size(const void *_thing, hsize_t *fsf_size)
  */
 #ifndef NDEBUG
 static herr_t
-H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr, hbool_t *fd_clean, hbool_t *clean)
+H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr, bool *fd_clean, bool *clean)
 {
-    hbool_t  fd_exists = FALSE;    /* whether flush dependency exists. */
+    bool     fd_exists = false;    /* whether flush dependency exists. */
     haddr_t  hdr_addr;             /* Address of header */
     unsigned hdr_status = 0;       /* Header cache entry status */
     herr_t   ret_value  = SUCCEED; /* Return value */
@@ -2606,7 +2606,7 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr, hbool_t *fd_
         H5HF_indirect_t *root_iblock = hdr->root_iblock;
         haddr_t          root_iblock_addr;
         unsigned         root_iblock_status = 0;
-        hbool_t          root_iblock_in_cache;
+        bool             root_iblock_in_cache;
 
         /* make note of the on disk address of the root iblock */
         if (root_iblock == NULL)
@@ -2627,13 +2627,13 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr, hbool_t *fd_
         assert(root_iblock_in_cache || (root_iblock == NULL));
 
         if (!root_iblock_in_cache) { /* we are done */
-            *clean    = TRUE;
-            *fd_clean = TRUE;
+            *clean    = true;
+            *fd_clean = true;
         } /* end if */
         else if ((root_iblock_status & H5AC_ES__IS_DIRTY) &&
                  (((root_iblock_status & H5AC_ES__IMAGE_IS_UP_TO_DATE) == 0) ||
                   (!H5AC_get_serialization_in_progress(f)))) {
-            *clean = FALSE;
+            *clean = false;
 
             /* verify that a flush dependency exists between the header and
              * the root inode.
@@ -2642,10 +2642,10 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr, hbool_t *fd_
                 HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't check flush dependency");
             assert(fd_exists);
 
-            *fd_clean = FALSE;
+            *fd_clean = false;
         }      /* end else-if */
         else { /* must examine children */
-            hbool_t unprotect_root_iblock = FALSE;
+            bool unprotect_root_iblock = false;
 
             /* At this point, the root iblock may be pinned, protected,
              * both, or neither, and we may or may not have a pointer
@@ -2683,7 +2683,7 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr, hbool_t *fd_
 
                     H5_END_TAG
 
-                    unprotect_root_iblock = TRUE;
+                    unprotect_root_iblock = true;
                 } /* end if */
                 else {
                     /* the root iblock is protected, and we have no
@@ -2758,7 +2758,7 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr, hbool_t *fd_
 
                     H5_END_TAG
 
-                    unprotect_root_iblock = TRUE;
+                    unprotect_root_iblock = true;
                     assert(iblock == root_iblock);
                 } /* end if */
             }     /* end else */
@@ -2785,8 +2785,8 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr, hbool_t *fd_
     else if ((hdr->man_dtable.curr_root_rows == 0) && (HADDR_UNDEF != hdr->man_dtable.table_addr)) {
         haddr_t  root_dblock_addr;
         unsigned root_dblock_status = 0;
-        hbool_t  in_cache;
-        hbool_t  type_ok;
+        bool     in_cache;
+        bool     type_ok;
 
         /* this is scenario 2 -- we have a root dblock */
         root_dblock_addr = hdr->man_dtable.table_addr;
@@ -2824,16 +2824,16 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr, hbool_t *fd_
             *fd_clean = *clean;
         }      /* end if */
         else { /* root dblock not in cache */
-            *fd_clean = TRUE;
-            *clean    = TRUE;
+            *fd_clean = true;
+            *clean    = true;
         } /* end else */
     }     /* end else-if */
     else {
         /* this is scenario 3 -- the fractal heap is empty, and we
          * have nothing to do.
          */
-        *fd_clean = TRUE;
-        *clean    = TRUE;
+        *fd_clean = true;
+        *clean    = true;
     } /* end else */
 
 done:
@@ -2847,7 +2847,7 @@ done:
  * Purpose:	Sanity checking routine that verifies that all indirect
  *		and direct blocks that are descendants of the supplied
  *		instance of H5HF_indirect_t are clean.  Set *clean
- *		to TRUE if this is the case, and to FALSE otherwise.
+ *		to true if this is the case, and to false otherwise.
  *
  *		In passing, the function also does a cursory check to
  *		spot any obvious errors in the flush dependency setup.
@@ -2909,11 +2909,11 @@ done:
 #ifndef NDEBUG
 static herr_t
 H5HF__cache_verify_iblock_descendants_clean(H5F_t *f, haddr_t fd_parent_addr, H5HF_indirect_t *iblock,
-                                            unsigned *iblock_status, hbool_t *fd_clean, hbool_t *clean)
+                                            unsigned *iblock_status, bool *fd_clean, bool *clean)
 {
-    hbool_t has_dblocks = FALSE;
-    hbool_t has_iblocks = FALSE;
-    herr_t  ret_value   = SUCCEED; /* Return value */
+    bool   has_dblocks = false;
+    bool   has_iblocks = false;
+    herr_t ret_value   = SUCCEED; /* Return value */
 
     FUNC_ENTER_PACKAGE
 
@@ -2925,7 +2925,7 @@ H5HF__cache_verify_iblock_descendants_clean(H5F_t *f, haddr_t fd_parent_addr, H5
     assert(iblock_status);
     assert(fd_clean);
     assert(*fd_clean);
-    assert(clean); /* note that *clean need not be TRUE */
+    assert(clean); /* note that *clean need not be true */
 
     if ((*fd_clean) && H5HF__cache_verify_iblocks_dblocks_clean(f, fd_parent_addr, iblock, fd_clean, clean,
                                                                 &has_dblocks) < 0)
@@ -3022,7 +3022,7 @@ done:
 #ifndef NDEBUG
 static herr_t
 H5HF__cache_verify_iblocks_dblocks_clean(H5F_t *f, haddr_t fd_parent_addr, H5HF_indirect_t *iblock,
-                                         hbool_t *fd_clean, hbool_t *clean, hbool_t *has_dblocks)
+                                         bool *fd_clean, bool *clean, bool *has_dblocks)
 {
     unsigned num_direct_rows;
     unsigned max_dblock_index;
@@ -3054,14 +3054,14 @@ H5HF__cache_verify_iblocks_dblocks_clean(H5F_t *f, haddr_t fd_parent_addr, H5HF_
 
         dblock_addr = iblock->ents[i].addr;
         if (H5_addr_defined(dblock_addr)) {
-            hbool_t in_cache;
-            hbool_t type_ok;
+            bool in_cache;
+            bool type_ok;
 
             if (H5AC_verify_entry_type(f, dblock_addr, &H5AC_FHEAP_DBLOCK[0], &in_cache, &type_ok) < 0)
                 HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't check dblock type");
 
             if (in_cache) { /* dblock is in cache */
-                hbool_t  fd_exists;
+                bool     fd_exists;
                 unsigned dblock_status = 0;
 
                 if (!type_ok)
@@ -3072,18 +3072,18 @@ H5HF__cache_verify_iblocks_dblocks_clean(H5F_t *f, haddr_t fd_parent_addr, H5HF_
 
                 assert(dblock_status & H5AC_ES__IN_CACHE);
 
-                *has_dblocks = TRUE;
+                *has_dblocks = true;
 
                 if ((dblock_status & H5AC_ES__IS_DIRTY) &&
                     (((dblock_status & H5AC_ES__IMAGE_IS_UP_TO_DATE) == 0) ||
                      (!H5AC_get_serialization_in_progress(f)))) {
-                    *clean = FALSE;
+                    *clean = false;
 
                     if (H5AC_flush_dependency_exists(f, fd_parent_addr, dblock_addr, &fd_exists) < 0)
                         HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't check flush dependency");
 
                     if (fd_exists)
-                        *fd_clean = FALSE;
+                        *fd_clean = false;
                 } /* end if */
 
                 /* If a child dblock is in cache, it must have a flush
@@ -3182,7 +3182,7 @@ done:
 #ifndef NDEBUG
 static herr_t
 H5HF__cache_verify_descendant_iblocks_clean(H5F_t *f, haddr_t fd_parent_addr, H5HF_indirect_t *iblock,
-                                            hbool_t *fd_clean, hbool_t *clean, hbool_t *has_iblocks)
+                                            bool *fd_clean, bool *clean, bool *has_iblocks)
 {
     unsigned first_iblock_index;
     unsigned last_iblock_index;
@@ -3220,24 +3220,24 @@ H5HF__cache_verify_descendant_iblocks_clean(H5F_t *f, haddr_t fd_parent_addr, H5
                 HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't get iblock status");
 
             if (child_iblock_status & H5AC_ES__IN_CACHE) {
-                hbool_t fd_exists;
+                bool fd_exists;
 
-                *has_iblocks = TRUE;
+                *has_iblocks = true;
 
                 if ((child_iblock_status & H5AC_ES__IS_DIRTY) &&
                     (((child_iblock_status & H5AC_ES__IMAGE_IS_UP_TO_DATE) == 0) ||
                      (!H5AC_get_serialization_in_progress(f)))) {
 
-                    *clean = FALSE;
+                    *clean = false;
 
                     if (H5AC_flush_dependency_exists(f, fd_parent_addr, child_iblock_addr, &fd_exists) < 0)
                         HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't check flush dependency");
 
                     if (fd_exists)
-                        *fd_clean = FALSE;
+                        *fd_clean = false;
                 } /* end if */
 
-                /* if the child iblock is in cache and *fd_clean is TRUE,
+                /* if the child iblock is in cache and *fd_clean is true,
                  * we must continue to explore down the fractal heap tree
                  * structure to verify that all descendant blocks that are
                  * flush dependency children of the entry at parent_addr are
@@ -3291,7 +3291,7 @@ H5HF__cache_verify_descendant_iblocks_clean(H5F_t *f, haddr_t fd_parent_addr, H5
                  */
                 if (*fd_clean) {
                     H5HF_indirect_t *child_iblock           = NULL;
-                    hbool_t          unprotect_child_iblock = FALSE;
+                    bool             unprotect_child_iblock = false;
 
                     if (0 == (child_iblock_status & H5AC_ES__IS_PINNED)) {
                         /* child iblock is not pinned */
@@ -3323,7 +3323,7 @@ H5HF__cache_verify_descendant_iblocks_clean(H5F_t *f, haddr_t fd_parent_addr, H5
 
                             H5_END_TAG
 
-                            unprotect_child_iblock = TRUE;
+                            unprotect_child_iblock = true;
                         } /* end if */
                         else {
                             /* child iblock is protected -- use             */