Made HGOTO_ERROR a do-while loop (#3308)

* Made HGOTO_ERROR a do-while loop

1 files changed, 90 insertions, 89 deletions

diff --git a/src/H5HFcache.c b/src/H5HFcache.c
index d1146d7..c34a374 100644
--- a/src/H5HFcache.c
+++ b/src/H5HFcache.c
@@ -204,12 +204,12 @@ H5HF__hdr_prefix_decode(H5HF_hdr_t *hdr, const uint8_t **image_ref)
 
     /* Magic number */
     if (memcmp(image, H5HF_HDR_MAGIC, (size_t)H5_SIZEOF_MAGIC) != 0)
-        HGOTO_ERROR(H5E_HEAP, H5E_BADVALUE, FAIL, "wrong fractal heap header signature")
+        HGOTO_ERROR(H5E_HEAP, H5E_BADVALUE, FAIL, "wrong fractal heap header signature");
     image += H5_SIZEOF_MAGIC;
 
     /* Version */
     if (*image++ != H5HF_HDR_VERSION)
-        HGOTO_ERROR(H5E_HEAP, H5E_VERSION, FAIL, "wrong fractal heap header version")
+        HGOTO_ERROR(H5E_HEAP, H5E_VERSION, FAIL, "wrong fractal heap header version");
 
     /* General heap information */
     UINT16DECODE(image, hdr->id_len);     /* Heap ID length */
@@ -381,7 +381,7 @@ H5HF__cache_hdr_get_final_load_size(const void *_image, size_t H5_ATTR_NDEBUG_UN
 
     /* Deserialize the fractal heap header's prefix */
     if (H5HF__hdr_prefix_decode(&hdr, &image) < 0)
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTDECODE, FAIL, "can't decode fractal heap header prefix")
+        HGOTO_ERROR(H5E_HEAP, H5E_CANTDECODE, FAIL, "can't decode fractal heap header prefix");
 
     /* Check for I/O filter info on this heap */
     if (hdr.filter_len > 0)
@@ -460,11 +460,11 @@ H5HF__cache_hdr_deserialize(const void *_image, size_t len, void *_udata, hbool_
 
     /* Allocate space for the fractal heap data structure */
     if (NULL == (hdr = H5HF__hdr_alloc(udata->f)))
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
 
     /* Deserialize the fractal heap header's prefix */
     if (H5HF__hdr_prefix_decode(hdr, &image) < 0)
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTDECODE, NULL, "can't decode fractal heap header prefix")
+        HGOTO_ERROR(H5E_HEAP, H5E_CANTDECODE, NULL, "can't decode fractal heap header prefix");
 
     /* Heap status flags */
     /* (bit 0: "huge" object IDs have wrapped) */
@@ -495,7 +495,7 @@ H5HF__cache_hdr_deserialize(const void *_image, size_t len, void *_udata, hbool_
 
     /* Managed objects' doubling-table info */
     if (H5HF__dtable_decode(hdr->f, &image, &(hdr->man_dtable)) < 0)
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTENCODE, NULL, "unable to encode managed obj. doubling table info")
+        HGOTO_ERROR(H5E_HEAP, H5E_CANTENCODE, NULL, "unable to encode managed obj. doubling table info");
 
     /* Set the fractal heap header's 'base' size */
     hdr->heap_size = (size_t)H5HF_HEADER_SIZE(hdr);
@@ -524,14 +524,14 @@ H5HF__cache_hdr_deserialize(const void *_image, size_t len, void *_udata, hbool_
 
         /* Decode I/O filter information */
         if (NULL == (pline = (H5O_pline_t *)H5O_msg_decode(hdr->f, NULL, H5O_PLINE_ID, len, image)))
-            HGOTO_ERROR(H5E_HEAP, H5E_CANTDECODE, NULL, "can't decode I/O pipeline filters")
+            HGOTO_ERROR(H5E_HEAP, H5E_CANTDECODE, NULL, "can't decode I/O pipeline filters");
 
         /* Advance past filter info to checksum */
         image += hdr->filter_len;
 
         /* Copy the information into the header's I/O pipeline structure */
         if (NULL == H5O_msg_copy(H5O_PLINE_ID, pline, &(hdr->pline)))
-            HGOTO_ERROR(H5E_HEAP, H5E_CANTCOPY, NULL, "can't copy I/O filter pipeline")
+            HGOTO_ERROR(H5E_HEAP, H5E_CANTCOPY, NULL, "can't copy I/O filter pipeline");
 
         /* Release the space allocated for the I/O pipeline filters */
         H5O_msg_free(H5O_PLINE_ID, pline);
@@ -545,7 +545,7 @@ H5HF__cache_hdr_deserialize(const void *_image, size_t len, void *_udata, hbool_
 
     /* Finish initialization of heap header */
     if (H5HF__hdr_finish_init(hdr) < 0)
-        HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, NULL, "can't finish initializing shared fractal heap header")
+        HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, NULL, "can't finish initializing shared fractal heap header");
 
     /* Set return value */
     ret_value = (void *)hdr;
@@ -659,7 +659,7 @@ H5HF__cache_hdr_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t len,
          */
         if (H5HF__cache_verify_hdr_descendants_clean((H5F_t *)f, hdr, &fd_children_clean,
                                                      &descendants_clean) < 0)
-            HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "can't verify hdr descendants clean.")
+            HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "can't verify hdr descendants clean.");
         assert(fd_children_clean);
     }
 #endif /* NDEBUG */
@@ -753,7 +753,7 @@ H5HF__cache_hdr_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_NDEBUG_UN
 
     /* Managed objects' doubling-table info */
     if (H5HF__dtable_encode(hdr->f, &image, &(hdr->man_dtable)) < 0)
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTENCODE, FAIL, "unable to encode managed obj. doubling table info")
+        HGOTO_ERROR(H5E_HEAP, H5E_CANTENCODE, FAIL, "unable to encode managed obj. doubling table info");
 
     /* Check for I/O filter information to encode */
     if (hdr->filter_len > 0) {
@@ -765,7 +765,7 @@ H5HF__cache_hdr_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_NDEBUG_UN
 
         /* Encode I/O filter information */
         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")
+            HGOTO_ERROR(H5E_HEAP, H5E_CANTENCODE, FAIL, "can't encode I/O pipeline filters");
         image += hdr->filter_len;
     } /* end if */
 
@@ -813,7 +813,7 @@ H5HF__cache_hdr_free_icr(void *_thing)
     assert(hdr->rc == 0);
 
     if (H5HF__hdr_free(hdr) < 0)
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL, "unable to release fractal heap header")
+        HGOTO_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL, "unable to release fractal heap header");
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -926,12 +926,12 @@ H5HF__cache_iblock_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED
 
     /* Allocate space for the fractal heap indirect block */
     if (NULL == (iblock = H5FL_CALLOC(H5HF_indirect_t)))
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
 
     /* Share common heap information */
     iblock->hdr = hdr;
     if (H5HF__hdr_incr(hdr) < 0)
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTINC, NULL, "can't increment reference count on shared heap header")
+        HGOTO_ERROR(H5E_HEAP, H5E_CANTINC, NULL, "can't increment reference count on shared heap header");
 
     /* Set block's internal information */
     iblock->rc        = 0;
@@ -946,17 +946,17 @@ H5HF__cache_iblock_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED
 
     /* Magic number */
     if (memcmp(image, H5HF_IBLOCK_MAGIC, (size_t)H5_SIZEOF_MAGIC) != 0)
-        HGOTO_ERROR(H5E_HEAP, H5E_BADVALUE, NULL, "wrong fractal heap indirect block signature")
+        HGOTO_ERROR(H5E_HEAP, H5E_BADVALUE, NULL, "wrong fractal heap indirect block signature");
     image += H5_SIZEOF_MAGIC;
 
     /* Version */
     if (*image++ != H5HF_IBLOCK_VERSION)
-        HGOTO_ERROR(H5E_HEAP, H5E_VERSION, NULL, "wrong fractal heap direct block version")
+        HGOTO_ERROR(H5E_HEAP, H5E_VERSION, NULL, "wrong fractal heap direct block version");
 
     /* Address of heap that owns this block */
     H5F_addr_decode(udata->f, &image, &heap_addr);
     if (H5_addr_ne(heap_addr, hdr->heap_addr))
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, NULL, "incorrect heap header address for direct block")
+        HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, NULL, "incorrect heap header address for direct block");
 
     /* Address of parent block */
     iblock->parent = udata->par_info->iblock;
@@ -972,7 +972,7 @@ H5HF__cache_iblock_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED
         /* Share parent block */
         if (H5HF__iblock_incr(iblock->parent) < 0)
             HGOTO_ERROR(H5E_HEAP, H5E_CANTINC, NULL,
-                        "can't increment reference count on shared indirect block")
+                        "can't increment reference count on shared indirect block");
 
         /* Set max. # of rows in this block */
         iblock->max_rows = iblock->nrows;
@@ -989,7 +989,7 @@ H5HF__cache_iblock_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED
     assert(iblock->nrows > 0);
     if (NULL == (iblock->ents = H5FL_SEQ_MALLOC(H5HF_indirect_ent_t,
                                                 (size_t)(iblock->nrows * hdr->man_dtable.cparam.width))))
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for direct entries")
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for direct entries");
 
     if (hdr->filter_len > 0) {
         unsigned dir_rows; /* Number of direct rows in this indirect block */
@@ -1000,7 +1000,7 @@ H5HF__cache_iblock_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED
         /* Allocate indirect block filtered entry array */
         if (NULL == (iblock->filt_ents = H5FL_SEQ_MALLOC(H5HF_indirect_filt_ent_t,
                                                          (size_t)(dir_rows * hdr->man_dtable.cparam.width))))
-            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for block entries")
+            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for block entries");
     } /* end if */
     else
         iblock->filt_ents = NULL;
@@ -1059,7 +1059,7 @@ H5HF__cache_iblock_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED
         /* Allocate & initialize child indirect block pointer array */
         if (NULL == (iblock->child_iblocks = H5FL_SEQ_CALLOC(
                          H5HF_indirect_ptr_t, (size_t)(indir_rows * hdr->man_dtable.cparam.width))))
-            HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, NULL, "memory allocation failed for block entries")
+            HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, NULL, "memory allocation failed for block entries");
     } /* end if */
     else
         iblock->child_iblocks = NULL;
@@ -1154,7 +1154,7 @@ H5HF__cache_iblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t H5
          * iblock are clean.
          */
         if (H5AC_get_entry_status(f, iblock->addr, &iblock_status) < 0)
-            HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't get iblock status")
+            HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't get iblock status");
 
         /* since the current iblock is the guest of honor in a flush, we know
          * that it is locked into the cache for the duration of the call.  Hence
@@ -1163,7 +1163,7 @@ H5HF__cache_iblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t H5
          */
         if (H5HF__cache_verify_iblock_descendants_clean((H5F_t *)f, iblock->addr, iblock, &iblock_status,
                                                         &fd_children_clean, &descendants_clean) < 0)
-            HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "can't verify descendants clean.")
+            HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "can't verify descendants clean.");
         assert(fd_children_clean);
     }
 #endif /* NDEBUG */
@@ -1177,14 +1177,15 @@ H5HF__cache_iblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t H5
         /* Allocate 'normal' space for the new indirect block on disk */
         if (HADDR_UNDEF ==
             (iblock_addr = H5MF_alloc((H5F_t *)f, H5FD_MEM_FHEAP_IBLOCK, (hsize_t)iblock->size)))
-            HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL, "file allocation failed for fractal heap indirect block")
+            HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL,
+                        "file allocation failed for fractal heap indirect block");
 
         /* Sanity check */
         assert(!H5_addr_eq(iblock->addr, iblock_addr));
 
         /* Let the metadata cache know the block moved */
         if (H5AC_move_entry((H5F_t *)f, H5AC_FHEAP_IBLOCK, iblock->addr, iblock_addr) < 0)
-            HGOTO_ERROR(H5E_HEAP, H5E_CANTMOVE, FAIL, "unable to move indirect block")
+            HGOTO_ERROR(H5E_HEAP, H5E_CANTMOVE, FAIL, "unable to move indirect block");
 
         /* Update the internal address for the block */
         iblock->addr = iblock_addr;
@@ -1196,7 +1197,7 @@ H5HF__cache_iblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t H5
 
             /* Mark that heap header was modified */
             if (H5HF__hdr_dirty(hdr) < 0)
-                HGOTO_ERROR(H5E_HEAP, H5E_CANTDIRTY, FAIL, "can't mark heap header as dirty")
+                HGOTO_ERROR(H5E_HEAP, H5E_CANTDIRTY, FAIL, "can't mark heap header as dirty");
         } /* end if */
         else {
             H5HF_indirect_t *par_iblock; /* Parent indirect block */
@@ -1211,7 +1212,7 @@ H5HF__cache_iblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t H5
 
             /* Mark that parent was modified */
             if (H5HF__iblock_dirty(par_iblock) < 0)
-                HGOTO_ERROR(H5E_HEAP, H5E_CANTDIRTY, FAIL, "can't mark heap header as dirty")
+                HGOTO_ERROR(H5E_HEAP, H5E_CANTDIRTY, FAIL, "can't mark heap header as dirty");
         } /* end if */
 
         *new_addr = iblock_addr;
@@ -1404,7 +1405,7 @@ H5HF__cache_iblock_notify(H5AC_notify_action_t action, void *_thing)
             /* Create flush dependency with parent, if there is one */
             if (iblock->fd_parent)
                 if (H5AC_create_flush_dependency(iblock->fd_parent, iblock) < 0)
-                    HGOTO_ERROR(H5E_HEAP, H5E_CANTDEPEND, FAIL, "unable to create flush dependency")
+                    HGOTO_ERROR(H5E_HEAP, H5E_CANTDEPEND, FAIL, "unable to create flush dependency");
             break;
 
         case H5AC_NOTIFY_ACTION_AFTER_FLUSH:
@@ -1421,13 +1422,13 @@ H5HF__cache_iblock_notify(H5AC_notify_action_t action, void *_thing)
             if (iblock->fd_parent) {
                 /* Destroy flush dependency with parent */
                 if (H5AC_destroy_flush_dependency(iblock->fd_parent, iblock) < 0)
-                    HGOTO_ERROR(H5E_HEAP, H5E_CANTUNDEPEND, FAIL, "unable to destroy flush dependency")
+                    HGOTO_ERROR(H5E_HEAP, H5E_CANTUNDEPEND, FAIL, "unable to destroy flush dependency");
                 iblock->fd_parent = NULL;
             } /* end if */
             break;
 
         default:
-            HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "unknown action from metadata cache")
+            HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "unknown action from metadata cache");
             break;
     } /* end switch */
 
@@ -1462,7 +1463,7 @@ H5HF__cache_iblock_free_icr(void *thing)
 
     /* Destroy fractal heap indirect block */
     if (H5HF__man_iblock_dest(iblock) < 0)
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to destroy fractal heap indirect block")
+        HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to destroy fractal heap indirect block");
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -1567,7 +1568,7 @@ H5HF__cache_dblock_verify_chksum(const void *_image, size_t len, void *_udata)
          * provided to it.
          */
         if (NULL == (read_buf = H5MM_malloc(len)))
-            HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL, "memory allocation failed for pipeline buffer")
+            HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL, "memory allocation failed for pipeline buffer");
 
         /* Set up parameters for filter pipeline */
         nbytes      = len;
@@ -1577,7 +1578,7 @@ H5HF__cache_dblock_verify_chksum(const void *_image, size_t len, void *_udata)
         /* Push direct block data through I/O filter pipeline */
         if (H5Z_pipeline(&(hdr->pline), H5Z_FLAG_REVERSE, &filter_mask, H5Z_ENABLE_EDC, filter_cb, &nbytes,
                          &len, &read_buf) < 0)
-            HGOTO_ERROR(H5E_HEAP, H5E_CANTFILTER, FAIL, "output pipeline failed")
+            HGOTO_ERROR(H5E_HEAP, H5E_CANTFILTER, FAIL, "output pipeline failed");
 
         /* Update info about direct block */
         udata->decompressed = TRUE;
@@ -1622,7 +1623,7 @@ H5HF__cache_dblock_verify_chksum(const void *_image, size_t len, void *_udata)
 
         /* Allocate block buffer */
         if (NULL == (udata->dblk = H5FL_BLK_MALLOC(direct_block, (size_t)len)))
-            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
+            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed");
 
         /* Copy un-filtered data into block's buffer */
         H5MM_memcpy(udata->dblk, read_buf, len);
@@ -1679,7 +1680,7 @@ H5HF__cache_dblock_deserialize(const void *_image, size_t len, void *_udata, hbo
 
     /* Allocate space for the fractal heap direct block */
     if (NULL == (dblock = H5FL_CALLOC(H5HF_direct_t)))
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
     memset(&dblock->cache_info, 0, sizeof(H5AC_info_t));
 
     /* Set the shared heap header's file context for this operation */
@@ -1688,7 +1689,7 @@ H5HF__cache_dblock_deserialize(const void *_image, size_t len, void *_udata, hbo
     /* Share common heap information */
     dblock->hdr = hdr;
     if (H5HF__hdr_incr(hdr) < 0)
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTINC, NULL, "can't increment reference count on shared heap header")
+        HGOTO_ERROR(H5E_HEAP, H5E_CANTINC, NULL, "can't increment reference count on shared heap header");
 
     /* Set block's internal information */
     dblock->size = udata->dblock_size;
@@ -1721,7 +1722,7 @@ H5HF__cache_dblock_deserialize(const void *_image, size_t len, void *_udata, hbo
              * provided to it.
              */
             if (NULL == (read_buf = H5MM_malloc(len)))
-                HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, NULL, "memory allocation failed for pipeline buffer")
+                HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, NULL, "memory allocation failed for pipeline buffer");
 
             /* Copy compressed image into buffer */
             H5MM_memcpy(read_buf, image, len);
@@ -1731,7 +1732,7 @@ H5HF__cache_dblock_deserialize(const void *_image, size_t len, void *_udata, hbo
             filter_mask = udata->filter_mask;
             if (H5Z_pipeline(&(hdr->pline), H5Z_FLAG_REVERSE, &filter_mask, H5Z_ENABLE_EDC, filter_cb,
                              &nbytes, &len, &read_buf) < 0)
-                HGOTO_ERROR(H5E_HEAP, H5E_CANTFILTER, NULL, "output pipeline failed")
+                HGOTO_ERROR(H5E_HEAP, H5E_CANTFILTER, NULL, "output pipeline failed");
 
             /* Sanity check */
             assert(nbytes == dblock->size);
@@ -1748,7 +1749,7 @@ H5HF__cache_dblock_deserialize(const void *_image, size_t len, void *_udata, hbo
         /* Allocate block buffer */
         /* XXX: Change to using free-list factories */
         if (NULL == (dblock->blk = H5FL_BLK_MALLOC(direct_block, (size_t)dblock->size)))
-            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
+            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
 
         /* Copy image to dblock->blk */
         assert(dblock->size == len);
@@ -1760,17 +1761,17 @@ H5HF__cache_dblock_deserialize(const void *_image, size_t len, void *_udata, hbo
 
     /* Magic number */
     if (memcmp(image, H5HF_DBLOCK_MAGIC, (size_t)H5_SIZEOF_MAGIC) != 0)
-        HGOTO_ERROR(H5E_HEAP, H5E_BADVALUE, NULL, "wrong fractal heap direct block signature")
+        HGOTO_ERROR(H5E_HEAP, H5E_BADVALUE, NULL, "wrong fractal heap direct block signature");
     image += H5_SIZEOF_MAGIC;
 
     /* Version */
     if (*image++ != H5HF_DBLOCK_VERSION)
-        HGOTO_ERROR(H5E_HEAP, H5E_VERSION, NULL, "wrong fractal heap direct block version")
+        HGOTO_ERROR(H5E_HEAP, H5E_VERSION, NULL, "wrong fractal heap direct block version");
 
     /* Address of heap that owns this block (just for file integrity checks) */
     H5F_addr_decode(udata->f, &image, &heap_addr);
     if (H5_addr_ne(heap_addr, hdr->heap_addr))
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, NULL, "incorrect heap header address for direct block")
+        HGOTO_ERROR(H5E_HEAP, H5E_CANTLOAD, NULL, "incorrect heap header address for direct block");
 
     /* Address of parent block */
     dblock->parent = par_info->iblock;
@@ -1783,7 +1784,7 @@ H5HF__cache_dblock_deserialize(const void *_image, size_t len, void *_udata, hbo
         /* Share parent block */
         if (H5HF__iblock_incr(dblock->parent) < 0)
             HGOTO_ERROR(H5E_HEAP, H5E_CANTINC, NULL,
-                        "can't increment reference count on shared indirect block")
+                        "can't increment reference count on shared indirect block");
     } /* end if */
 
     /* Offset of heap within the heap's address space */
@@ -2083,7 +2084,7 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t le
         /* Allocate buffer to perform I/O filtering on */
         write_size = dblock->size;
         if (NULL == (write_buf = H5MM_malloc(write_size)))
-            HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL, "memory allocation failed for pipeline buffer")
+            HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL, "memory allocation failed for pipeline buffer");
 
         /* Copy the direct block's image into the buffer to compress */
         H5MM_memcpy(write_buf, dblock->blk, write_size);
@@ -2092,7 +2093,7 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t le
         nbytes = write_size;
         if (H5Z_pipeline(&(hdr->pline), 0, &filter_mask, H5Z_ENABLE_EDC, filter_cb, &nbytes, &write_size,
                          &write_buf) < 0)
-            HGOTO_ERROR(H5E_HEAP, H5E_WRITEERROR, FAIL, "output pipeline failed")
+            HGOTO_ERROR(H5E_HEAP, H5E_WRITEERROR, FAIL, "output pipeline failed");
 
         /* Use the compressed number of bytes as the size to write */
         write_size = nbytes;
@@ -2135,13 +2136,13 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t le
                 if (!at_tmp_addr)
                     /* Release direct block's current disk space */
                     if (H5MF_xfree(f, H5FD_MEM_FHEAP_DBLOCK, addr, (hsize_t)hdr->pline_root_direct_size) < 0)
-                        HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to free fractal heap direct block")
+                        HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to free fractal heap direct block");
 
                 /* Allocate space for the compressed direct block */
                 if (HADDR_UNDEF ==
                     (dblock_addr = H5MF_alloc((H5F_t *)f, H5FD_MEM_FHEAP_DBLOCK, (hsize_t)write_size)))
                     HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL,
-                                "file allocation failed for fractal heap direct block")
+                                "file allocation failed for fractal heap direct block");
 
                 /* Update information about compressed direct block's
                  * location & size
@@ -2158,7 +2159,7 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t le
             /* 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")
+                    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 */
@@ -2190,13 +2191,13 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t le
                     /* Release direct block's current disk space */
                     if (H5MF_xfree(f, H5FD_MEM_FHEAP_DBLOCK, addr,
                                    (hsize_t)par_iblock->filt_ents[par_entry].size) < 0)
-                        HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to free fractal heap direct block")
+                        HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to free fractal heap direct block");
 
                 /* Allocate space for the compressed direct block */
                 if (HADDR_UNDEF ==
                     (dblock_addr = H5MF_alloc((H5F_t *)f, H5FD_MEM_FHEAP_DBLOCK, (hsize_t)write_size)))
                     HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL,
-                                "file allocation failed for fractal heap direct block")
+                                "file allocation failed for fractal heap direct block");
 
                 /* Update information about compressed direct block's
                  * location & size
@@ -2213,7 +2214,7 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t le
             /* Check if parent was modified */
             if (par_changed)
                 if (H5HF__iblock_dirty(par_iblock) < 0)
-                    HGOTO_ERROR(H5E_HEAP, H5E_CANTDIRTY, FAIL, "can't mark heap header as dirty")
+                    HGOTO_ERROR(H5E_HEAP, H5E_CANTDIRTY, FAIL, "can't mark heap header as dirty");
         } /* end else */
     }     /* end if */
     else {
@@ -2238,7 +2239,7 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t le
             if (HADDR_UNDEF ==
                 (dblock_addr = H5MF_alloc((H5F_t *)f, H5FD_MEM_FHEAP_DBLOCK, (hsize_t)write_size)))
                 HGOTO_ERROR(H5E_HEAP, H5E_NOSPACE, FAIL,
-                            "file allocation failed for fractal heap direct block")
+                            "file allocation failed for fractal heap direct block");
 
             /* Check for root direct block */
             if (NULL == dblock->parent) {
@@ -2251,7 +2252,7 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t le
 
                 /* Mark that heap header was modified */
                 if (H5HF__hdr_dirty(hdr) < 0)
-                    HGOTO_ERROR(H5E_HEAP, H5E_CANTDIRTY, FAIL, "can't mark heap header as dirty")
+                    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 */
                 /* Sanity checks */
@@ -2265,7 +2266,7 @@ H5HF__cache_dblock_pre_serialize(H5F_t *f, void *_thing, haddr_t addr, size_t le
 
                 /* Mark that parent was modified */
                 if (H5HF__iblock_dirty(par_iblock) < 0)
-                    HGOTO_ERROR(H5E_HEAP, H5E_CANTDIRTY, FAIL, "can't mark heap header as dirty")
+                    HGOTO_ERROR(H5E_HEAP, H5E_CANTDIRTY, FAIL, "can't mark heap header as dirty");
             } /* end else */
         }     /* end if */
     }         /* end else */
@@ -2393,7 +2394,7 @@ H5HF__cache_dblock_notify(H5AC_notify_action_t action, void *_thing)
             /* Create flush dependency with parent, if there is one */
             if (dblock->fd_parent)
                 if (H5AC_create_flush_dependency(dblock->fd_parent, dblock) < 0)
-                    HGOTO_ERROR(H5E_HEAP, H5E_CANTDEPEND, FAIL, "unable to create flush dependency")
+                    HGOTO_ERROR(H5E_HEAP, H5E_CANTDEPEND, FAIL, "unable to create flush dependency");
             break;
 
         case H5AC_NOTIFY_ACTION_AFTER_FLUSH:
@@ -2410,13 +2411,13 @@ H5HF__cache_dblock_notify(H5AC_notify_action_t action, void *_thing)
             if (dblock->fd_parent) {
                 /* Destroy flush dependency with parent */
                 if (H5AC_destroy_flush_dependency(dblock->fd_parent, dblock) < 0)
-                    HGOTO_ERROR(H5E_HEAP, H5E_CANTUNDEPEND, FAIL, "unable to destroy flush dependency")
+                    HGOTO_ERROR(H5E_HEAP, H5E_CANTUNDEPEND, FAIL, "unable to destroy flush dependency");
                 dblock->fd_parent = NULL;
             } /* end if */
             break;
 
         default:
-            HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "unknown action from metadata cache")
+            HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "unknown action from metadata cache");
             break;
     } /* end switch */
 
@@ -2449,7 +2450,7 @@ H5HF__cache_dblock_free_icr(void *_thing)
 
     /* Destroy fractal heap direct block */
     if (H5HF__man_dblock_dest(dblock) < 0)
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to destroy fractal heap direct block")
+        HGOTO_ERROR(H5E_HEAP, H5E_CANTFREE, FAIL, "unable to destroy fractal heap direct block");
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -2567,7 +2568,7 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr, hbool_t *fd_
     assert(hdr_addr == hdr->heap_addr);
 
     if (H5AC_get_entry_status(f, hdr_addr, &hdr_status) < 0)
-        HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't get hdr status")
+        HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't get hdr status");
     assert(hdr_status & H5AC_ES__IN_CACHE);
 
     /* We have three basic scenarios we have to deal with:
@@ -2620,7 +2621,7 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr, hbool_t *fd_
         /* get the status of the root iblock */
         assert(root_iblock_addr != HADDR_UNDEF);
         if (H5AC_get_entry_status(f, root_iblock_addr, &root_iblock_status) < 0)
-            HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't get root iblock status")
+            HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't get root iblock status");
 
         root_iblock_in_cache = ((root_iblock_status & H5AC_ES__IN_CACHE) != 0);
         assert(root_iblock_in_cache || (root_iblock == NULL));
@@ -2638,7 +2639,7 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr, hbool_t *fd_
              * the root inode.
              */
             if (H5AC_flush_dependency_exists(f, hdr->heap_addr, root_iblock_addr, &fd_exists) < 0)
-                HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't check flush dependency")
+                HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't check flush dependency");
             assert(fd_exists);
 
             *fd_clean = FALSE;
@@ -2721,7 +2722,7 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr, hbool_t *fd_
                      *  or we think of a better way.
                      */
                     if (H5AC_get_entry_ptr_from_addr(f, root_iblock_addr, (void **)(&root_iblock)) < 0)
-                        HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "H5AC_get_entry_ptr_from_addr() failed.")
+                        HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "H5AC_get_entry_ptr_from_addr() failed.");
                     assert(root_iblock);
                 }  /* end else */
             }      /* end if */
@@ -2770,14 +2771,14 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr, hbool_t *fd_
 
             if (H5HF__cache_verify_iblock_descendants_clean(f, hdr->heap_addr, root_iblock,
                                                             &root_iblock_status, fd_clean, clean) < 0)
-                HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "can't verify root iblock & descendants clean.")
+                HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "can't verify root iblock & descendants clean.");
 
             /* Unprotect the root indirect block if required */
             if (unprotect_root_iblock) {
                 assert(root_iblock);
                 if (H5AC_unprotect(f, H5AC_FHEAP_IBLOCK, root_iblock_addr, root_iblock, H5AC__NO_FLAGS_SET) <
                     0)
-                    HGOTO_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "H5AC_unprotect() failed.")
+                    HGOTO_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "H5AC_unprotect() failed.");
             } /* end if */
         }     /* end else */
     }         /* end if */
@@ -2790,14 +2791,14 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr, hbool_t *fd_
         /* this is scenario 2 -- we have a root dblock */
         root_dblock_addr = hdr->man_dtable.table_addr;
         if (H5AC_get_entry_status(f, root_dblock_addr, &root_dblock_status) < 0)
-            HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't get root dblock status")
+            HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't get root dblock status");
 
         if (root_dblock_status & H5AC_ES__IN_CACHE) {
             if (H5AC_verify_entry_type(f, root_dblock_addr, &H5AC_FHEAP_DBLOCK[0], &in_cache, &type_ok) < 0)
-                HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't check dblock type")
+                HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't check dblock type");
             assert(in_cache);
             if (!type_ok)
-                HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "root dblock addr doesn't refer to a dblock?!?")
+                HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "root dblock addr doesn't refer to a dblock?!?");
 
             /* If a root dblock is in cache, it must have a flush
              * dependency relationship with the header, and it
@@ -2809,12 +2810,12 @@ H5HF__cache_verify_hdr_descendants_clean(H5F_t *f, H5HF_hdr_t *hdr, hbool_t *fd_
              * relationship with the header.
              */
             if (H5AC_flush_dependency_exists(f, hdr->heap_addr, root_dblock_addr, &fd_exists) < 0)
-                HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't check flush dependency")
+                HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't check flush dependency");
             if (!fd_exists)
-                HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "root dblock is not a flush dep parent of header.")
+                HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "root dblock is not a flush dep parent of header.");
 
             if (0 != (root_dblock_status & H5AC_ES__IS_FLUSH_DEP_PARENT))
-                HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "root dblock in cache and is a flush dep parent.")
+                HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "root dblock in cache and is a flush dep parent.");
 
             *clean = !((root_dblock_status & H5AC_ES__IS_DIRTY) &&
                        (((root_dblock_status & H5AC_ES__IMAGE_IS_UP_TO_DATE) == 0) ||
@@ -2928,19 +2929,19 @@ H5HF__cache_verify_iblock_descendants_clean(H5F_t *f, haddr_t fd_parent_addr, H5
 
     if ((*fd_clean) && H5HF__cache_verify_iblocks_dblocks_clean(f, fd_parent_addr, iblock, fd_clean, clean,
                                                                 &has_dblocks) < 0)
-        HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "can't verify dblocks clean.")
+        HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "can't verify dblocks clean.");
 
     if ((*fd_clean) && H5HF__cache_verify_descendant_iblocks_clean(f, fd_parent_addr, iblock, fd_clean, clean,
                                                                    &has_iblocks) < 0)
-        HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "can't verify iblocks clean.")
+        HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "can't verify iblocks clean.");
 
     /* verify that flush dependency setup is plausible */
     if (0 == (*iblock_status & H5AC_ES__IS_FLUSH_DEP_CHILD))
-        HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "iblock is not a flush dep child.")
+        HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "iblock is not a flush dep child.");
     if (((has_dblocks || has_iblocks)) && (0 == (*iblock_status & H5AC_ES__IS_FLUSH_DEP_PARENT)))
-        HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "iblock has children and is not a flush dep parent.")
+        HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "iblock has children and is not a flush dep parent.");
     if (((has_dblocks || has_iblocks)) && (0 == (*iblock_status & H5AC_ES__IS_PINNED)))
-        HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "iblock has children and is not pinned.")
+        HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "iblock has children and is not pinned.");
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -3057,17 +3058,17 @@ H5HF__cache_verify_iblocks_dblocks_clean(H5F_t *f, haddr_t fd_parent_addr, H5HF_
             hbool_t 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")
+                HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't check dblock type");
 
             if (in_cache) { /* dblock is in cache */
                 hbool_t  fd_exists;
                 unsigned dblock_status = 0;
 
                 if (!type_ok)
-                    HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "dblock addr doesn't refer to a dblock?!?")
+                    HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "dblock addr doesn't refer to a dblock?!?");
 
                 if (H5AC_get_entry_status(f, dblock_addr, &dblock_status) < 0)
-                    HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't get dblock status")
+                    HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't get dblock status");
 
                 assert(dblock_status & H5AC_ES__IN_CACHE);
 
@@ -3079,7 +3080,7 @@ H5HF__cache_verify_iblocks_dblocks_clean(H5F_t *f, haddr_t fd_parent_addr, H5HF_
                     *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")
+                        HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't check flush dependency");
 
                     if (fd_exists)
                         *fd_clean = FALSE;
@@ -3090,11 +3091,11 @@ H5HF__cache_verify_iblocks_dblocks_clean(H5F_t *f, haddr_t fd_parent_addr, H5HF_
                  * here.
                  */
                 if (H5AC_flush_dependency_exists(f, iblock_addr, dblock_addr, &fd_exists) < 0)
-                    HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't check flush dependency")
+                    HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't check flush dependency");
 
                 if (!fd_exists)
                     HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL,
-                                "dblock in cache and not a flush dep child of iblock.")
+                                "dblock in cache and not a flush dep child of iblock.");
             } /* end if */
         }     /* end if */
 
@@ -3216,7 +3217,7 @@ H5HF__cache_verify_descendant_iblocks_clean(H5F_t *f, haddr_t fd_parent_addr, H5
             unsigned child_iblock_status = 0;
 
             if (H5AC_get_entry_status(f, child_iblock_addr, &child_iblock_status) < 0)
-                HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't get iblock status")
+                HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't get iblock status");
 
             if (child_iblock_status & H5AC_ES__IN_CACHE) {
                 hbool_t fd_exists;
@@ -3230,7 +3231,7 @@ H5HF__cache_verify_descendant_iblocks_clean(H5F_t *f, haddr_t fd_parent_addr, H5
                     *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")
+                        HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't check flush dependency");
 
                     if (fd_exists)
                         *fd_clean = FALSE;
@@ -3332,7 +3333,7 @@ H5HF__cache_verify_descendant_iblocks_clean(H5F_t *f, haddr_t fd_parent_addr, H5
                             if (H5AC_get_entry_ptr_from_addr(f, child_iblock_addr, (void **)(&child_iblock)) <
                                 0)
                                 HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL,
-                                            "H5AC_get_entry_ptr_from_addr() failed.")
+                                            "H5AC_get_entry_ptr_from_addr() failed.");
                             assert(child_iblock);
                         } /* end else */
                     }     /* end if */
@@ -3354,7 +3355,7 @@ H5HF__cache_verify_descendant_iblocks_clean(H5F_t *f, haddr_t fd_parent_addr, H5
                     /* now make the recursive call */
                     if (H5HF__cache_verify_iblock_descendants_clean(
                             f, fd_parent_addr, child_iblock, &child_iblock_status, fd_clean, clean) < 0)
-                        HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "can't verify child iblock clean.")
+                        HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL, "can't verify child iblock clean.");
 
                     /* if iblock_addr != fd_parent_addr, verify that a flush
                      * dependency relationship exists between iblock and
@@ -3362,18 +3363,18 @@ H5HF__cache_verify_descendant_iblocks_clean(H5F_t *f, haddr_t fd_parent_addr, H5
                      */
                     if (fd_parent_addr != iblock_addr) {
                         if (H5AC_flush_dependency_exists(f, iblock_addr, child_iblock_addr, &fd_exists) < 0)
-                            HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't check flush dependency")
+                            HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't check flush dependency");
 
                         if (!fd_exists)
                             HGOTO_ERROR(H5E_HEAP, H5E_SYSTEM, FAIL,
-                                        "iblock is not a flush dep parent of child_iblock.")
+                                        "iblock is not a flush dep parent of child_iblock.");
                     } /* end if */
 
                     /* if we protected the child iblock, unprotect it now */
                     if (unprotect_child_iblock) {
                         if (H5AC_unprotect(f, H5AC_FHEAP_IBLOCK, child_iblock_addr, child_iblock,
                                            H5AC__NO_FLAGS_SET) < 0)
-                            HGOTO_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "H5AC_unprotect() failed.")
+                            HGOTO_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "H5AC_unprotect() failed.");
                     } /* end if */
                 }     /* end if */
             }         /* end if */