Removes alternative function enter/leave macro scheme (#678)

* Committing clang-format changes

* Converted BEGIN_FUNC, etc. macros to FUNC_ENTER

* Rips out the BEGIN_FUNC, etc. macros

* Removes 'end if', etc. comments from H5HL package

* Committing clang-format changes

* Fixes an H5EA iterate issue

* Fixes an issue in the H5FA iterator code

* Further cleanup in bin/trace after macro removal

* Iterator changes in H5EA and H5FA

Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>

1 files changed, 228 insertions, 170 deletions

diff --git a/src/H5FAcache.c b/src/H5FAcache.c
index 1b127c7..367b4b0 100644
--- a/src/H5FAcache.c
+++ b/src/H5FAcache.c
@@ -167,12 +167,13 @@ const H5AC_class_t H5AC_FARRAY_DBLK_PAGE[1] = {{
  *
  *-------------------------------------------------------------------------
  */
-BEGIN_FUNC(STATIC, NOERR, herr_t, SUCCEED, -,
-           H5FA__cache_hdr_get_initial_load_size(void *_udata, size_t *image_len))
-
-    /* Local variables */
+static herr_t
+H5FA__cache_hdr_get_initial_load_size(void *_udata, size_t *image_len)
+{
     H5FA_hdr_cache_ud_t *udata = (H5FA_hdr_cache_ud_t *)_udata; /* User data for callback */
 
+    FUNC_ENTER_STATIC_NOERR
+
     /* Check arguments */
     HDassert(udata);
     HDassert(udata->f);
@@ -181,7 +182,8 @@ BEGIN_FUNC(STATIC, NOERR, herr_t, SUCCEED, -,
     /* Set the image length size */
     *image_len = (size_t)H5FA_HEADER_SIZE_FILE(udata->f);
 
-END_FUNC(STATIC) /* end H5FA__cache_hdr_get_initial_load_size() */
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* end H5FA__cache_hdr_get_initial_load_size() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5FA__cache_hdr_verify_chksum
@@ -196,13 +198,15 @@ END_FUNC(STATIC) /* end H5FA__cache_hdr_get_initial_load_size() */
  *
  *-------------------------------------------------------------------------
  */
-BEGIN_FUNC(STATIC, NOERR, htri_t, TRUE, -,
-           H5FA__cache_hdr_verify_chksum(const void *_image, size_t len, void H5_ATTR_UNUSED *_udata))
-
-    /* Local variables */
+static htri_t
+H5FA__cache_hdr_verify_chksum(const void *_image, size_t len, void H5_ATTR_UNUSED *_udata)
+{
     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;
+
+    FUNC_ENTER_STATIC_NOERR
 
     /* Check arguments */
     HDassert(image);
@@ -213,7 +217,8 @@ BEGIN_FUNC(STATIC, NOERR, htri_t, TRUE, -,
     if (stored_chksum != computed_chksum)
         ret_value = FALSE;
 
-END_FUNC(STATIC) /* end H5FA__cache_hdr_verify_chksum() */
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5FA__cache_hdr_verify_chksum() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5FA__cache_hdr_deserialize
@@ -228,16 +233,18 @@ END_FUNC(STATIC) /* end H5FA__cache_hdr_verify_chksum() */
  *
  *-------------------------------------------------------------------------
  */
-BEGIN_FUNC(STATIC, ERR, void *, NULL, NULL,
-           H5FA__cache_hdr_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED len, void *_udata,
-                                       hbool_t H5_ATTR_UNUSED *dirty))
-
-    /* Local variables */
+static void *
+H5FA__cache_hdr_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED len, void *_udata,
+                            hbool_t H5_ATTR_UNUSED *dirty)
+{
     H5FA_cls_id_t        id;           /* ID of fixed array class, as found in file */
     H5FA_hdr_t *         hdr   = NULL; /* Fixed array info */
     H5FA_hdr_cache_ud_t *udata = (H5FA_hdr_cache_ud_t *)_udata;
     const uint8_t *      image = (const uint8_t *)_image; /* Pointer into raw data buffer */
     uint32_t             stored_chksum;                   /* Stored metadata checksum value */
+    void *               ret_value = NULL;
+
+    FUNC_ENTER_STATIC
 
     /* Check arguments */
     HDassert(udata);
@@ -246,24 +253,24 @@ BEGIN_FUNC(STATIC, ERR, void *, NULL, NULL,
 
     /* Allocate space for the fixed array data structure */
     if (NULL == (hdr = H5FA__hdr_alloc(udata->f)))
-        H5E_THROW(H5E_CANTALLOC, "memory allocation failed for fixed array shared header")
+        HGOTO_ERROR(H5E_FARRAY, H5E_CANTALLOC, NULL, "memory allocation failed for fixed array shared header")
 
     /* Set the fixed array header's address */
     hdr->addr = udata->addr;
 
     /* Magic number */
     if (HDmemcmp(image, H5FA_HDR_MAGIC, (size_t)H5_SIZEOF_MAGIC) != 0)
-        H5E_THROW(H5E_BADVALUE, "wrong fixed array header signature")
+        HGOTO_ERROR(H5E_FARRAY, H5E_BADVALUE, NULL, "wrong fixed array header signature")
     image += H5_SIZEOF_MAGIC;
 
     /* Version */
     if (*image++ != H5FA_HDR_VERSION)
-        H5E_THROW(H5E_VERSION, "wrong fixed array header version")
+        HGOTO_ERROR(H5E_FARRAY, H5E_VERSION, NULL, "wrong fixed array header version")
 
     /* Fixed array class */
     id = (H5FA_cls_id_t)*image++;
     if (id >= H5FA_NUM_CLS_ID)
-        H5E_THROW(H5E_BADTYPE, "incorrect fixed array class")
+        HGOTO_ERROR(H5E_FARRAY, H5E_BADTYPE, NULL, "incorrect fixed array class")
     hdr->cparam.cls = H5FA_client_class_g[id];
 
     /* General array creation/configuration information */
@@ -311,20 +318,20 @@ BEGIN_FUNC(STATIC, ERR, void *, NULL, NULL,
 
     /* Finish initializing fixed array header */
     if (H5FA__hdr_init(hdr, udata->ctx_udata) < 0)
-        H5E_THROW(H5E_CANTINIT, "initialization failed for fixed array header")
+        HGOTO_ERROR(H5E_FARRAY, H5E_CANTINIT, NULL, "initialization failed for fixed array header")
     HDassert(hdr->size == len);
 
     /* Set return value */
     ret_value = hdr;
 
-    CATCH
-
+done:
     /* Release resources */
     if (!ret_value)
         if (hdr && H5FA__hdr_dest(hdr) < 0)
-            H5E_THROW(H5E_CANTFREE, "unable to destroy fixed array header")
+            HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, NULL, "unable to destroy fixed array header")
 
-END_FUNC(STATIC) /* end H5FA__cache_hdr_deserialize() */
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5FA__cache_hdr_deserialize() */
 
 /*-------------------------------------------------------------------------
  * Function:    H5FA__cache_hdr_image_len
@@ -338,12 +345,13 @@ END_FUNC(STATIC) /* end H5FA__cache_hdr_deserialize() */
  *
  *-------------------------------------------------------------------------
  */
-BEGIN_FUNC(STATIC, NOERR, herr_t, SUCCEED, -,
-           H5FA__cache_hdr_image_len(const void *_thing, size_t *image_len))
-
-    /* Local variables */
+static herr_t
+H5FA__cache_hdr_image_len(const void *_thing, size_t *image_len)
+{
     const H5FA_hdr_t *hdr = (const H5FA_hdr_t *)_thing; /* Pointer to the object */
 
+    FUNC_ENTER_STATIC_NOERR
+
     /* Check arguments */
     HDassert(hdr);
     HDassert(image_len);
@@ -351,7 +359,8 @@ BEGIN_FUNC(STATIC, NOERR, herr_t, SUCCEED, -,
     /* Set the image length size */
     *image_len = hdr->size;
 
-END_FUNC(STATIC) /* end H5FA__cache_hdr_image_len() */
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* end H5FA__cache_hdr_image_len() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5FA__cache_hdr_serialize
@@ -365,15 +374,16 @@ END_FUNC(STATIC) /* end H5FA__cache_hdr_image_len() */
  *
  *-------------------------------------------------------------------------
  */
-BEGIN_FUNC(STATIC, NOERR, herr_t, SUCCEED, -,
-           H5FA__cache_hdr_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_UNUSED len, void *_thing))
-
-    /* Local variables */
+static herr_t
+H5FA__cache_hdr_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_UNUSED len, void *_thing)
+{
     H5FA_hdr_t *hdr   = (H5FA_hdr_t *)_thing; /* Pointer to the fixed array header */
     uint8_t *   image = (uint8_t *)_image;    /* Pointer into raw data buffer */
     uint32_t    metadata_chksum;              /* Computed metadata checksum value */
 
-    /* check arguments */
+    FUNC_ENTER_STATIC_NOERR
+
+    /* Check arguments */
     HDassert(f);
     HDassert(image);
     HDassert(hdr);
@@ -410,7 +420,8 @@ BEGIN_FUNC(STATIC, NOERR, herr_t, SUCCEED, -,
     /* Sanity check */
     HDassert((size_t)(image - (uint8_t *)_image) == len);
 
-END_FUNC(STATIC) /* end H5FA__cache_hdr_serialize() */
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* end H5FA__cache_hdr_serialize() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5FA__cache_hdr_notify
@@ -424,11 +435,13 @@ END_FUNC(STATIC) /* end H5FA__cache_hdr_serialize() */
  *
  *-------------------------------------------------------------------------
  */
-BEGIN_FUNC(STATIC, ERR, herr_t, SUCCEED, FAIL,
-           H5FA__cache_hdr_notify(H5AC_notify_action_t action, void *_thing))
+static herr_t
+H5FA__cache_hdr_notify(H5AC_notify_action_t action, void *_thing)
+{
+    H5FA_hdr_t *hdr       = (H5FA_hdr_t *)_thing; /* Pointer to the object */
+    herr_t      ret_value = SUCCEED;
 
-    /* Local variables */
-    H5FA_hdr_t *hdr = (H5FA_hdr_t *)_thing; /* Pointer to the object */
+    FUNC_ENTER_STATIC
 
     /* Sanity check */
     HDassert(hdr);
@@ -460,16 +473,16 @@ BEGIN_FUNC(STATIC, ERR, herr_t, SUCCEED, FAIL,
                     /* Destroy flush dependency on object header proxy */
                     if (H5AC_proxy_entry_remove_child((H5AC_proxy_entry_t *)hdr->parent,
                                                       (void *)hdr->top_proxy) < 0)
-                        H5E_THROW(H5E_CANTUNDEPEND,
-                                  "unable to destroy flush dependency between fixed array and proxy")
+                        HGOTO_ERROR(H5E_FARRAY, H5E_CANTUNDEPEND, FAIL,
+                                    "unable to destroy flush dependency between fixed array and proxy")
                     hdr->parent = NULL;
                 } /* end if */
 
                 /* Detach from 'top' proxy for fixed array */
                 if (hdr->top_proxy) {
                     if (H5AC_proxy_entry_remove_child(hdr->top_proxy, hdr) < 0)
-                        H5E_THROW(
-                            H5E_CANTUNDEPEND,
+                        HGOTO_ERROR(
+                            H5E_FARRAY, H5E_CANTUNDEPEND, FAIL,
                             "unable to destroy flush dependency between header and fixed array 'top' proxy")
                     /* Don't reset hdr->top_proxy here, it's destroyed when the header is freed -QAK */
                 } /* end if */
@@ -477,7 +490,7 @@ BEGIN_FUNC(STATIC, ERR, herr_t, SUCCEED, FAIL,
 
             default:
 #ifdef NDEBUG
-                H5E_THROW(H5E_BADVALUE, "unknown action from metadata cache")
+                HGOTO_ERROR(H5E_FARRAY, H5E_BADVALUE, FAIL, "unknown action from metadata cache")
 #else     /* NDEBUG */
                 HDassert(0 && "Unknown action?!?");
 #endif    /* NDEBUG */
@@ -486,9 +499,10 @@ BEGIN_FUNC(STATIC, ERR, herr_t, SUCCEED, FAIL,
     else
         HDassert(NULL == hdr->parent);
 
-    CATCH
+done:
 
-END_FUNC(STATIC) /* end H5FA__cache_hdr_notify() */
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5FA__cache_hdr_notify() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5FA__cache_hdr_free_icr
@@ -503,18 +517,23 @@ END_FUNC(STATIC) /* end H5FA__cache_hdr_notify() */
  *
  *-------------------------------------------------------------------------
  */
-BEGIN_FUNC(STATIC, ERR, herr_t, SUCCEED, FAIL, H5FA__cache_hdr_free_icr(void *thing))
+static herr_t
+H5FA__cache_hdr_free_icr(void *thing)
+{
+    herr_t ret_value = SUCCEED;
+
+    FUNC_ENTER_STATIC
 
     /* Check arguments */
     HDassert(thing);
 
     /* Release the extensible array header */
     if (H5FA__hdr_dest((H5FA_hdr_t *)thing) < 0)
-        H5E_THROW(H5E_CANTFREE, "can't free fixed array header")
-
-    CATCH
+        HGOTO_ERROR(H5E_FARRAY, H5E_CANTFREE, FAIL, "can't free fixed array header")
 
-END_FUNC(STATIC) /* end H5FA__cache_hdr_free_icr() */
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5FA__cache_hdr_free_icr() */
 
 /*-------------------------------------------------------------------------
  * Function:    H5FA__cache_dblock_get_initial_load_size
@@ -528,14 +547,15 @@ END_FUNC(STATIC) /* end H5FA__cache_hdr_free_icr() */
  *
  *-------------------------------------------------------------------------
  */
-BEGIN_FUNC(STATIC, NOERR, herr_t, SUCCEED, -,
-           H5FA__cache_dblock_get_initial_load_size(void *_udata, size_t *image_len))
-
-    /* Local variables */
+static herr_t
+H5FA__cache_dblock_get_initial_load_size(void *_udata, size_t *image_len)
+{
     H5FA_dblock_cache_ud_t *udata = (H5FA_dblock_cache_ud_t *)_udata; /* User data */
     H5FA_dblock_t           dblock;                                   /* Fake data block for computing size */
     size_t                  dblk_page_nelmts;                         /* # of elements per data block page */
 
+    FUNC_ENTER_STATIC_NOERR
+
     /* Check arguments */
     HDassert(udata);
     HDassert(udata->hdr);
@@ -564,7 +584,8 @@ BEGIN_FUNC(STATIC, NOERR, herr_t, SUCCEED, -,
     else
         *image_len = (size_t)H5FA_DBLOCK_PREFIX_SIZE(&dblock);
 
-END_FUNC(STATIC) /* end H5FA__cache_dblock_get_initial_load_size() */
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* end H5FA__cache_dblock_get_initial_load_size() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5FA__cache_dblock_verify_chksum
@@ -579,13 +600,15 @@ END_FUNC(STATIC) /* end H5FA__cache_dblock_get_initial_load_size() */
  *
  *-------------------------------------------------------------------------
  */
-BEGIN_FUNC(STATIC, NOERR, htri_t, TRUE, -,
-           H5FA__cache_dblock_verify_chksum(const void *_image, size_t len, void H5_ATTR_UNUSED *_udata))
-
-    /* Local variables */
+static htri_t
+H5FA__cache_dblock_verify_chksum(const void *_image, size_t len, void H5_ATTR_UNUSED *_udata)
+{
     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;
+
+    FUNC_ENTER_STATIC_NOERR
 
     /* Check arguments */
     HDassert(image);
@@ -596,7 +619,8 @@ BEGIN_FUNC(STATIC, NOERR, htri_t, TRUE, -,
     if (stored_chksum != computed_chksum)
         ret_value = FALSE;
 
-END_FUNC(STATIC) /* end H5FA__cache_dblock_verify_chksum() */
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5FA__cache_dblock_verify_chksum() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5FA__cache_dblock_deserialize
@@ -611,16 +635,18 @@ END_FUNC(STATIC) /* end H5FA__cache_dblock_verify_chksum() */
  *
  *-------------------------------------------------------------------------
  */
-BEGIN_FUNC(STATIC, ERR, void *, NULL, NULL,
-           H5FA__cache_dblock_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED len, void *_udata,
-                                          hbool_t H5_ATTR_UNUSED *dirty))
-
-    /* Local variables */
+static void *
+H5FA__cache_dblock_deserialize(const void *_image, size_t H5_ATTR_NDEBUG_UNUSED len, void *_udata,
+                               hbool_t H5_ATTR_UNUSED *dirty)
+{
     H5FA_dblock_t *         dblock = NULL;                             /* Data block info */
     H5FA_dblock_cache_ud_t *udata  = (H5FA_dblock_cache_ud_t *)_udata; /* User data for loading data block */
     const uint8_t *         image  = (const uint8_t *)_image;          /* Pointer into raw data buffer */
     uint32_t                stored_chksum;                             /* Stored metadata checksum value */
     haddr_t                 arr_addr; /* Address of array header in the file */
+    void *                  ret_value = NULL;
+
+    FUNC_ENTER_STATIC
 
     /* Sanity check */
     HDassert(udata);
@@ -628,7 +654,7 @@ BEGIN_FUNC(STATIC, ERR, void *, NULL, NULL,
 
     /* Allocate the fixed array data block */
     if (NULL == (dblock = H5FA__dblock_alloc(udata->hdr)))
-        H5E_THROW(H5E_CANTALLOC, "memory allocation failed for fixed array data block")
+        HGOTO_ERROR(H5E_FARRAY, H5E_CANTALLOC, NULL, "memory allocation failed for fixed array data block")
 
     HDassert(((!dblock->npages) && (len == (size_t)H5FA_DBLOCK_SIZE(dblock))) ||
              (len == (size_t)H5FA_DBLOCK_PREFIX_SIZE(dblock)));
@@ -638,27 +664,27 @@ BEGIN_FUNC(STATIC, ERR, void *, NULL, NULL,
 
     /* Magic number */
     if (HDmemcmp(image, H5FA_DBLOCK_MAGIC, (size_t)H5_SIZEOF_MAGIC) != 0)
-        H5E_THROW(H5E_BADVALUE, "wrong fixed array data block signature")
+        HGOTO_ERROR(H5E_FARRAY, H5E_BADVALUE, NULL, "wrong fixed array data block signature")
     image += H5_SIZEOF_MAGIC;
 
     /* Version */
     if (*image++ != H5FA_DBLOCK_VERSION)
-        H5E_THROW(H5E_VERSION, "wrong fixed array data block version")
+        HGOTO_ERROR(H5E_FARRAY, H5E_VERSION, NULL, "wrong fixed array data block version")
 
     /* Fixed array type */
     if (*image++ != (uint8_t)udata->hdr->cparam.cls->id)
-        H5E_THROW(H5E_BADTYPE, "incorrect fixed array class")
+        HGOTO_ERROR(H5E_FARRAY, H5E_BADTYPE, NULL, "incorrect fixed array class")
 
     /* Address of header for array that owns this block (just for file integrity checks) */
     H5F_addr_decode(udata->hdr->f, &image, &arr_addr);
     if (H5F_addr_ne(arr_addr, udata->hdr->addr))
-        H5E_THROW(H5E_BADVALUE, "wrong fixed array header address")
+        HGOTO_ERROR(H5E_FARRAY, H5E_BADVALUE, NULL, "wrong fixed array header address")
 
     /* Page initialization flags */
     if (dblock->npages > 0) {
         H5MM_memcpy(dblock->dblk_page_init, image, dblock->dblk_page_init_size);
         image += dblock->dblk_page_init_size;
-    } /* end if */
+    }
 
     /* Only decode elements if the data block is not paged */
     if (!dblock->npages) {
@@ -666,9 +692,9 @@ BEGIN_FUNC(STATIC, ERR, void *, NULL, NULL,
         /* Convert from raw elements on disk into native elements in memory */
         if ((udata->hdr->cparam.cls->decode)(image, dblock->elmts, (size_t)udata->hdr->cparam.nelmts,
                                              udata->hdr->cb_ctx) < 0)
-            H5E_THROW(H5E_CANTDECODE, "can't decode fixed array data elements")
+            HGOTO_ERROR(H5E_FARRAY, H5E_CANTDECODE, NULL, "can't decode fixed array data elements")
         image += (udata->hdr->cparam.nelmts * udata->hdr->cparam.raw_elmt_size);
-    } /* end if */
+    }
 
     /* Sanity check */
     /* (allow for checksum not decoded yet) */
@@ -688,14 +714,14 @@ BEGIN_FUNC(STATIC, ERR, void *, NULL, NULL,
     /* Set return value */
     ret_value = dblock;
 
-    CATCH
-
+done:
     /* Release resources */
     if (!ret_value)
         if (dblock && H5FA__dblock_dest(dblock) < 0)
-            H5E_THROW(H5E_CANTFREE, "unable to destroy fixed array data block")
+            HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, NULL, "unable to destroy fixed array data block")
 
-END_FUNC(STATIC) /* end H5FA__cache_dblock_deserialize() */
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5FA__cache_dblock_deserialize() */
 
 /*-------------------------------------------------------------------------
  * Function:    H5FA__cache_dblock_image_len
@@ -709,12 +735,13 @@ END_FUNC(STATIC) /* end H5FA__cache_dblock_deserialize() */
  *
  *-------------------------------------------------------------------------
  */
-BEGIN_FUNC(STATIC, NOERR, herr_t, SUCCEED, -,
-           H5FA__cache_dblock_image_len(const void *_thing, size_t *image_len))
-
-    /* Local variables */
+static herr_t
+H5FA__cache_dblock_image_len(const void *_thing, size_t *image_len)
+{
     const H5FA_dblock_t *dblock = (const H5FA_dblock_t *)_thing; /* Pointer to the object */
 
+    FUNC_ENTER_STATIC_NOERR
+
     /* Check arguments */
     HDassert(dblock);
     HDassert(image_len);
@@ -725,7 +752,8 @@ BEGIN_FUNC(STATIC, NOERR, herr_t, SUCCEED, -,
     else
         *image_len = H5FA_DBLOCK_PREFIX_SIZE(dblock);
 
-END_FUNC(STATIC) /* end H5FA__cache_dblock_image_len() */
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* end H5FA__cache_dblock_image_len() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5FA__cache_dblock_serialize
@@ -739,14 +767,15 @@ END_FUNC(STATIC) /* end H5FA__cache_dblock_image_len() */
  *
  *-------------------------------------------------------------------------
  */
-BEGIN_FUNC(STATIC, ERR, herr_t, SUCCEED, FAIL,
-           H5FA__cache_dblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_UNUSED len,
-                                        void *_thing))
-
-    /* Local variables */
+static herr_t
+H5FA__cache_dblock_serialize(const H5F_t *f, void *_image, size_t H5_ATTR_UNUSED len, void *_thing)
+{
     H5FA_dblock_t *dblock = (H5FA_dblock_t *)_thing; /* Pointer to the object to serialize */
     uint8_t *      image  = (uint8_t *)_image;       /* Pointer into raw data buffer */
     uint32_t       metadata_chksum;                  /* Computed metadata checksum value */
+    herr_t         ret_value = SUCCEED;
+
+    FUNC_ENTER_STATIC
 
     /* Check arguments */
     HDassert(f);
@@ -773,7 +802,7 @@ BEGIN_FUNC(STATIC, ERR, herr_t, SUCCEED, FAIL,
         /* Store the 'page init' bitmasks */
         H5MM_memcpy(image, dblock->dblk_page_init, dblock->dblk_page_init_size);
         image += dblock->dblk_page_init_size;
-    } /* end if */
+    }
 
     /* Only encode elements if the data block is not paged */
     if (!dblock->npages) {
@@ -783,9 +812,9 @@ BEGIN_FUNC(STATIC, ERR, herr_t, SUCCEED, FAIL,
         H5_CHECK_OVERFLOW(dblock->hdr->cparam.nelmts, /* From: */ hsize_t, /* To: */ size_t);
         if ((dblock->hdr->cparam.cls->encode)(image, dblock->elmts, (size_t)dblock->hdr->cparam.nelmts,
                                               dblock->hdr->cb_ctx) < 0)
-            H5E_THROW(H5E_CANTENCODE, "can't encode fixed array data elements")
+            HGOTO_ERROR(H5E_FARRAY, H5E_CANTENCODE, FAIL, "can't encode fixed array data elements")
         image += (dblock->hdr->cparam.nelmts * dblock->hdr->cparam.raw_elmt_size);
-    } /* end if */
+    }
 
     /* Compute metadata checksum */
     metadata_chksum = H5_checksum_metadata(_image, (size_t)(image - (uint8_t *)_image), 0);
@@ -796,9 +825,9 @@ BEGIN_FUNC(STATIC, ERR, herr_t, SUCCEED, FAIL,
     /* Sanity check */
     HDassert((size_t)(image - (uint8_t *)_image) == len);
 
-    CATCH
-
-END_FUNC(STATIC) /* end H5FA__cache_dblock_serialize() */
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5FA__cache_dblock_serialize() */
 
 /*-------------------------------------------------------------------------
  * Function:    H5FA__cache_dblock_notify
@@ -812,11 +841,13 @@ END_FUNC(STATIC) /* end H5FA__cache_dblock_serialize() */
  *
  *-------------------------------------------------------------------------
  */
-BEGIN_FUNC(STATIC, ERR, herr_t, SUCCEED, FAIL,
-           H5FA__cache_dblock_notify(H5AC_notify_action_t action, void *_thing))
+static herr_t
+H5FA__cache_dblock_notify(H5AC_notify_action_t action, void *_thing)
+{
+    H5FA_dblock_t *dblock    = (H5FA_dblock_t *)_thing;
+    herr_t         ret_value = SUCCEED;
 
-    /* Local variables */
-    H5FA_dblock_t *dblock = (H5FA_dblock_t *)_thing;
+    FUNC_ENTER_STATIC
 
     /* Sanity check */
     HDassert(dblock);
@@ -829,8 +860,8 @@ BEGIN_FUNC(STATIC, ERR, herr_t, SUCCEED, FAIL,
             case H5AC_NOTIFY_ACTION_AFTER_LOAD:
                 /* Create flush dependency on parent */
                 if (H5FA__create_flush_depend((H5AC_info_t *)dblock->hdr, (H5AC_info_t *)dblock) < 0)
-                    H5E_THROW(
-                        H5E_CANTDEPEND,
+                    HGOTO_ERROR(
+                        H5E_FARRAY, H5E_CANTDEPEND, FAIL,
                         "unable to create flush dependency between data block and header, address = %llu",
                         (unsigned long long)dblock->addr)
                 break;
@@ -842,35 +873,35 @@ BEGIN_FUNC(STATIC, ERR, herr_t, SUCCEED, FAIL,
             case H5AC_NOTIFY_ACTION_CHILD_CLEANED:
             case H5AC_NOTIFY_ACTION_CHILD_UNSERIALIZED:
             case H5AC_NOTIFY_ACTION_CHILD_SERIALIZED:
-                /* do nothing */
                 break;
 
             case H5AC_NOTIFY_ACTION_BEFORE_EVICT:
                 /* Destroy flush dependency on parent */
                 if (H5FA__destroy_flush_depend((H5AC_info_t *)dblock->hdr, (H5AC_info_t *)dblock) < 0)
-                    H5E_THROW(H5E_CANTUNDEPEND, "unable to destroy flush dependency")
+                    HGOTO_ERROR(H5E_FARRAY, H5E_CANTUNDEPEND, FAIL, "unable to destroy flush dependency")
 
                 /* Detach from 'top' proxy for fixed array */
                 if (dblock->top_proxy) {
                     if (H5AC_proxy_entry_remove_child(dblock->top_proxy, dblock) < 0)
-                        H5E_THROW(H5E_CANTUNDEPEND, "unable to destroy flush dependency between data block "
-                                                    "and fixed array 'top' proxy")
+                        HGOTO_ERROR(H5E_FARRAY, H5E_CANTUNDEPEND, FAIL,
+                                    "unable to destroy flush dependency between data block "
+                                    "and fixed array 'top' proxy")
                     dblock->top_proxy = NULL;
-                } /* end if */
+                }
                 break;
 
             default:
 #ifdef NDEBUG
-                H5E_THROW(H5E_BADVALUE, "unknown action from metadata cache")
-#else     /* NDEBUG */
+                HGOTO_ERROR(H5E_FARRAY, H5E_BADVALUE, FAIL, "unknown action from metadata cache")
+#else
                 HDassert(0 && "Unknown action?!?");
-#endif    /* NDEBUG */
+#endif
         } /* end switch */
     }     /* end if */
 
-    CATCH
-
-END_FUNC(STATIC) /* end H5FA__cache_dblock_notify() */
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5FA__cache_dblock_notify() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5FA__cache_dblock_free_icr
@@ -885,20 +916,24 @@ END_FUNC(STATIC) /* end H5FA__cache_dblock_notify() */
  *
  *-------------------------------------------------------------------------
  */
-BEGIN_FUNC(STATIC, ERR, herr_t, SUCCEED, FAIL, H5FA__cache_dblock_free_icr(void *_thing))
+static herr_t
+H5FA__cache_dblock_free_icr(void *_thing)
+{
+    H5FA_dblock_t *dblock    = (H5FA_dblock_t *)_thing; /* Pointer to the object */
+    herr_t         ret_value = SUCCEED;
 
-    H5FA_dblock_t *dblock = (H5FA_dblock_t *)_thing; /* Pointer to the object */
+    FUNC_ENTER_STATIC
 
     /* Check arguments */
     HDassert(dblock);
 
     /* Release the fixed array data block */
     if (H5FA__dblock_dest(dblock) < 0)
-        H5E_THROW(H5E_CANTFREE, "can't free fixed array data block")
-
-    CATCH
+        HGOTO_ERROR(H5E_FARRAY, H5E_CANTFREE, FAIL, "can't free fixed array data block")
 
-END_FUNC(STATIC) /* end H5FA__cache_dblock_free_icr() */
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5FA__cache_dblock_free_icr() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5FA__cache_dblock_fsf_size
@@ -929,11 +964,13 @@ END_FUNC(STATIC) /* end H5FA__cache_dblock_free_icr() */
  *
  *-------------------------------------------------------------------------
  */
-BEGIN_FUNC(STATIC, NOERR, herr_t, SUCCEED, -,
-           H5FA__cache_dblock_fsf_size(const void *_thing, hsize_t *fsf_size))
-
+static herr_t
+H5FA__cache_dblock_fsf_size(const void *_thing, hsize_t *fsf_size)
+{
     const H5FA_dblock_t *dblock = (const H5FA_dblock_t *)_thing; /* Pointer to the object */
 
+    FUNC_ENTER_STATIC_NOERR
+
     /* Check arguments */
     HDassert(dblock);
     HDassert(dblock->cache_info.magic == H5C__H5C_CACHE_ENTRY_T_MAGIC);
@@ -942,7 +979,8 @@ BEGIN_FUNC(STATIC, NOERR, herr_t, SUCCEED, -,
 
     *fsf_size = dblock->size;
 
-END_FUNC(STATIC) /* end H5FA__cache_dblock_fsf_size() */
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* end H5FA__cache_dblock_fsf_size() */
 
 /*-------------------------------------------------------------------------
  * Function:    H5FA__cache_dblk_page_get_initial_load_size
@@ -956,12 +994,13 @@ END_FUNC(STATIC) /* end H5FA__cache_dblock_fsf_size() */
  *
  *-------------------------------------------------------------------------
  */
-BEGIN_FUNC(STATIC, NOERR, herr_t, SUCCEED, -,
-           H5FA__cache_dblk_page_get_initial_load_size(void *_udata, size_t *image_len))
-
-    /* Local variables */
+static herr_t
+H5FA__cache_dblk_page_get_initial_load_size(void *_udata, size_t *image_len)
+{
     H5FA_dblk_page_cache_ud_t *udata = (H5FA_dblk_page_cache_ud_t *)_udata; /* User data */
 
+    FUNC_ENTER_STATIC_NOERR
+
     /* Check arguments */
     HDassert(udata);
     HDassert(udata->hdr);
@@ -971,7 +1010,8 @@ BEGIN_FUNC(STATIC, NOERR, herr_t, SUCCEED, -,
     /* Set the image length size */
     *image_len = (size_t)H5FA_DBLK_PAGE_SIZE(udata->hdr, udata->nelmts);
 
-END_FUNC(STATIC) /* end H5FA__cache_dblk_page_get_initial_load_size() */
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* end H5FA__cache_dblk_page_get_initial_load_size() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5FA__cache_dblk_page_verify_chksum
@@ -986,13 +1026,15 @@ END_FUNC(STATIC) /* end H5FA__cache_dblk_page_get_initial_load_size() */
  *
  *-------------------------------------------------------------------------
  */
-BEGIN_FUNC(STATIC, NOERR, htri_t, TRUE, -,
-           H5FA__cache_dblk_page_verify_chksum(const void *_image, size_t len, void H5_ATTR_UNUSED *_udata))
-
-    /* Local variables */
+static htri_t
+H5FA__cache_dblk_page_verify_chksum(const void *_image, size_t len, void H5_ATTR_UNUSED *_udata)
+{
     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;
+
+    FUNC_ENTER_STATIC_NOERR
 
     /* Check arguments */
     HDassert(image);
@@ -1003,7 +1045,8 @@ BEGIN_FUNC(STATIC, NOERR, htri_t, TRUE, -,
     if (stored_chksum != computed_chksum)
         ret_value = FALSE;
 
-END_FUNC(STATIC) /* end H5FA__cache_dblk_page_verify_chksum() */
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5FA__cache_dblk_page_verify_chksum() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5FA__cache_dblk_page_deserialize
@@ -1018,18 +1061,19 @@ END_FUNC(STATIC) /* end H5FA__cache_dblk_page_verify_chksum() */
  *
  *-------------------------------------------------------------------------
  */
-BEGIN_FUNC(STATIC, ERR, void *, NULL, NULL,
-           H5FA__cache_dblk_page_deserialize(const void *_image, size_t len, void *_udata,
-                                             hbool_t H5_ATTR_UNUSED *dirty))
-
-    /* Local variables */
+static void *
+H5FA__cache_dblk_page_deserialize(const void *_image, size_t len, void *_udata, hbool_t H5_ATTR_UNUSED *dirty)
+{
     H5FA_dblk_page_t *         dblk_page = NULL; /* Data block page info */
     H5FA_dblk_page_cache_ud_t *udata =
         (H5FA_dblk_page_cache_ud_t *)_udata;        /* User data for loading data block page */
     const uint8_t *image = (const uint8_t *)_image; /* Pointer into raw data buffer */
     uint32_t       stored_chksum;                   /* Stored metadata checksum value */
+    void *         ret_value = NULL;
 
     /* Sanity check */
+    FUNC_ENTER_STATIC
+
     HDassert(udata);
     HDassert(udata->hdr);
     HDassert(udata->nelmts > 0);
@@ -1037,7 +1081,8 @@ BEGIN_FUNC(STATIC, ERR, void *, NULL, NULL,
 
     /* Allocate the fixed array data block page */
     if (NULL == (dblk_page = H5FA__dblk_page_alloc(udata->hdr, udata->nelmts)))
-        H5E_THROW(H5E_CANTALLOC, "memory allocation failed for fixed array data block page")
+        HGOTO_ERROR(H5E_FARRAY, H5E_CANTALLOC, NULL,
+                    "memory allocation failed for fixed array data block page")
 
     /* Set the fixed array data block's information */
     dblk_page->addr = udata->dblk_page_addr;
@@ -1047,7 +1092,7 @@ BEGIN_FUNC(STATIC, ERR, void *, NULL, NULL,
     /* Decode elements in data block page */
     /* Convert from raw elements on disk into native elements in memory */
     if ((udata->hdr->cparam.cls->decode)(image, dblk_page->elmts, udata->nelmts, udata->hdr->cb_ctx) < 0)
-        H5E_THROW(H5E_CANTDECODE, "can't decode fixed array data elements")
+        HGOTO_ERROR(H5E_FARRAY, H5E_CANTDECODE, NULL, "can't decode fixed array data elements")
     image += (udata->nelmts * udata->hdr->cparam.raw_elmt_size);
 
     /* Sanity check */
@@ -1068,14 +1113,15 @@ BEGIN_FUNC(STATIC, ERR, void *, NULL, NULL,
     /* Set return value */
     ret_value = dblk_page;
 
-    CATCH
+done:
 
     /* Release resources */
     if (!ret_value)
         if (dblk_page && H5FA__dblk_page_dest(dblk_page) < 0)
-            H5E_THROW(H5E_CANTFREE, "unable to destroy fixed array data block page")
+            HDONE_ERROR(H5E_FARRAY, H5E_CANTFREE, NULL, "unable to destroy fixed array data block page")
 
-END_FUNC(STATIC) /* end H5FA__cache_dblk_page_deserialize() */
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5FA__cache_dblk_page_deserialize() */
 
 /*-------------------------------------------------------------------------
  * Function:    H5FA__cache_dblk_page_image_len
@@ -1089,12 +1135,13 @@ END_FUNC(STATIC) /* end H5FA__cache_dblk_page_deserialize() */
  *
  *-------------------------------------------------------------------------
  */
-BEGIN_FUNC(STATIC, NOERR, herr_t, SUCCEED, -,
-           H5FA__cache_dblk_page_image_len(const void *_thing, size_t *image_len))
-
-    /* Local variables */
+static herr_t
+H5FA__cache_dblk_page_image_len(const void *_thing, size_t *image_len)
+{
     const H5FA_dblk_page_t *dblk_page = (const H5FA_dblk_page_t *)_thing; /* Pointer to the object */
 
+    FUNC_ENTER_STATIC_NOERR
+
     /* Check arguments */
     HDassert(dblk_page);
     HDassert(image_len);
@@ -1102,7 +1149,8 @@ BEGIN_FUNC(STATIC, NOERR, herr_t, SUCCEED, -,
     /* Set the image length size */
     *image_len = dblk_page->size;
 
-END_FUNC(STATIC) /* end H5FA__cache_dblk_page_image_len() */
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* end H5FA__cache_dblk_page_image_len() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5FA__cache_dblk_page_serialize
@@ -1116,14 +1164,16 @@ END_FUNC(STATIC) /* end H5FA__cache_dblk_page_image_len() */
  *
  *-------------------------------------------------------------------------
  */
-BEGIN_FUNC(STATIC, ERR, herr_t, SUCCEED, FAIL,
-           H5FA__cache_dblk_page_serialize(const H5F_t H5_ATTR_NDEBUG_UNUSED *f, void *_image,
-                                           size_t H5_ATTR_UNUSED len, void *_thing))
-
-    /* Local variables */
+static herr_t
+H5FA__cache_dblk_page_serialize(const H5F_t H5_ATTR_NDEBUG_UNUSED *f, void *_image, size_t H5_ATTR_UNUSED len,
+                                void *_thing)
+{
     H5FA_dblk_page_t *dblk_page = (H5FA_dblk_page_t *)_thing; /* Pointer to the object to serialize */
     uint8_t *         image     = (uint8_t *)_image;          /* Pointer into raw data buffer */
     uint32_t          metadata_chksum;                        /* Computed metadata checksum value */
+    herr_t            ret_value = SUCCEED;
+
+    FUNC_ENTER_STATIC
 
     /* Sanity check */
     HDassert(f);
@@ -1138,7 +1188,7 @@ BEGIN_FUNC(STATIC, ERR, herr_t, SUCCEED, FAIL,
     /* Convert from native elements in memory into raw elements on disk */
     if ((dblk_page->hdr->cparam.cls->encode)(image, dblk_page->elmts, dblk_page->nelmts,
                                              dblk_page->hdr->cb_ctx) < 0)
-        H5E_THROW(H5E_CANTENCODE, "can't encode fixed array data elements")
+        HGOTO_ERROR(H5E_FARRAY, H5E_CANTENCODE, FAIL, "can't encode fixed array data elements")
     image += (dblk_page->nelmts * dblk_page->hdr->cparam.raw_elmt_size);
 
     /* Compute metadata checksum */
@@ -1150,9 +1200,9 @@ BEGIN_FUNC(STATIC, ERR, herr_t, SUCCEED, FAIL,
     /* Sanity check */
     HDassert((size_t)(image - (uint8_t *)_image) == len);
 
-    CATCH
-
-END_FUNC(STATIC) /* end H5FA__cache_dblk_page_serialize() */
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5FA__cache_dblk_page_serialize() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5FA__cache_dblk_page_notify
@@ -1166,11 +1216,13 @@ END_FUNC(STATIC) /* end H5FA__cache_dblk_page_serialize() */
  *
  *-------------------------------------------------------------------------
  */
-BEGIN_FUNC(STATIC, ERR, herr_t, SUCCEED, FAIL,
-           H5FA__cache_dblk_page_notify(H5AC_notify_action_t action, void *_thing))
-
-    /* Local variables */
+static herr_t
+H5FA__cache_dblk_page_notify(H5AC_notify_action_t action, void *_thing)
+{
     H5FA_dblk_page_t *dblk_page = (H5FA_dblk_page_t *)_thing; /* Pointer to the object */
+    herr_t            ret_value = SUCCEED;
+
+    FUNC_ENTER_STATIC
 
     /* Sanity check */
     HDassert(dblk_page);
@@ -1187,8 +1239,9 @@ BEGIN_FUNC(STATIC, ERR, herr_t, SUCCEED, FAIL,
             /* Detach from 'top' proxy for fixed array */
             if (dblk_page->top_proxy) {
                 if (H5AC_proxy_entry_remove_child(dblk_page->top_proxy, dblk_page) < 0)
-                    H5E_THROW(H5E_CANTUNDEPEND, "unable to destroy flush dependency between data block page "
-                                                "and fixed array 'top' proxy")
+                    HGOTO_ERROR(H5E_FARRAY, H5E_CANTUNDEPEND, FAIL,
+                                "unable to destroy flush dependency between data block page "
+                                "and fixed array 'top' proxy")
                 dblk_page->top_proxy = NULL;
             } /* end if */
             break;
@@ -1204,15 +1257,15 @@ BEGIN_FUNC(STATIC, ERR, herr_t, SUCCEED, FAIL,
 
         default:
 #ifdef NDEBUG
-            H5E_THROW(H5E_BADVALUE, "unknown action from metadata cache")
+            HGOTO_ERROR(H5E_FARRAY, H5E_BADVALUE, FAIL, "unknown action from metadata cache")
 #else  /* NDEBUG */
             HDassert(0 && "Unknown action?!?");
 #endif /* NDEBUG */
     }  /* end switch */
 
-    CATCH
-
-END_FUNC(STATIC) /* end H5FA__cache_dblk_page_notify() */
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5FA__cache_dblk_page_notify() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5FA__cache_dblk_page_free_icr
@@ -1227,15 +1280,20 @@ END_FUNC(STATIC) /* end H5FA__cache_dblk_page_notify() */
  *
  *-------------------------------------------------------------------------
  */
-BEGIN_FUNC(STATIC, ERR, herr_t, SUCCEED, FAIL, H5FA__cache_dblk_page_free_icr(void *thing))
+static herr_t
+H5FA__cache_dblk_page_free_icr(void *thing)
+{
+    herr_t ret_value = SUCCEED;
+
+    FUNC_ENTER_STATIC
 
     /* Check arguments */
     HDassert(thing);
 
     /* Release the fixed array data block page */
     if (H5FA__dblk_page_dest((H5FA_dblk_page_t *)thing) < 0)
-        H5E_THROW(H5E_CANTFREE, "can't free fixed array data block page")
-
-    CATCH
+        HGOTO_ERROR(H5E_FARRAY, H5E_CANTFREE, FAIL, "can't free fixed array data block page")
 
-END_FUNC(STATIC) /* end H5FA__cache_dblk_page_free_icr() */
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5FA__cache_dblk_page_free_icr() */