More normalization from develop

1 files changed, 203 insertions, 231 deletions

diff --git a/src/H5HFsection.c b/src/H5HFsection.c
index d80b2f3..eec41a4 100644
--- a/src/H5HFsection.c
+++ b/src/H5HFsection.c
@@ -12,7 +12,7 @@
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 /*
- * Programmer:  Quincey Koziol <koziol@hdfgroup.org>
+ * Programmer:  Quincey Koziol
  *              Monday, May  1, 2006
  *
  * Purpose:     Free space section routines for fractal heaps
@@ -64,11 +64,11 @@ typedef struct {
 /********************/
 
 /* Shared routines */
-static herr_t               H5HF_sect_init_cls(H5FS_section_class_t *cls, H5HF_hdr_t *hdr);
-static herr_t               H5HF_sect_term_cls(H5FS_section_class_t *cls);
-static H5HF_free_section_t *H5HF_sect_node_new(unsigned sect_type, haddr_t sect_addr, hsize_t sect_size,
-                                               H5FS_section_state_t state);
-static herr_t               H5HF_sect_node_free(H5HF_free_section_t *sect, H5HF_indirect_t *parent);
+static herr_t               H5FS__sect_init_cls(H5FS_section_class_t *cls, H5HF_hdr_t *hdr);
+static herr_t               H5FS__sect_term_cls(H5FS_section_class_t *cls);
+static H5HF_free_section_t *H5FS__sect_node_new(unsigned sect_type, haddr_t sect_addr, hsize_t sect_size,
+                                                H5FS_section_state_t state);
+static herr_t               H5HF__sect_node_free(H5HF_free_section_t *sect, H5HF_indirect_t *parent);
 
 /* 'single' section routines */
 static herr_t H5HF__sect_single_locate_parent(H5HF_hdr_t *hdr, hbool_t refresh, H5HF_free_section_t *sect);
@@ -87,12 +87,12 @@ static herr_t H5HF__sect_single_shrink(H5FS_section_info_t **_sect, void *udata)
 static herr_t H5HF__sect_single_valid(const H5FS_section_class_t *cls, const H5FS_section_info_t *sect);
 
 /* 'row' section routines */
-static H5HF_free_section_t *H5HF_sect_row_create(haddr_t sect_off, hsize_t sect_size, hbool_t is_first,
-                                                 unsigned row, unsigned col, unsigned nentries,
-                                                 H5HF_free_section_t *under_sect);
+static H5HF_free_section_t *H5HF__sect_row_create(haddr_t sect_off, hsize_t sect_size, hbool_t is_first,
+                                                  unsigned row, unsigned col, unsigned nentries,
+                                                  H5HF_free_section_t *under_sect);
 static herr_t               H5HF__sect_row_first(H5HF_hdr_t *hdr, H5HF_free_section_t *sect);
 static herr_t               H5HF__sect_row_parent_removed(H5HF_free_section_t *sect);
-static herr_t H5HF_sect_row_from_single(H5HF_hdr_t *hdr, H5HF_free_section_t *sect, H5HF_direct_t *dblock);
+static herr_t H5HF__sect_row_from_single(H5HF_hdr_t *hdr, H5HF_free_section_t *sect, H5HF_direct_t *dblock);
 static herr_t H5HF__sect_row_free_real(H5HF_free_section_t *sect);
 
 /* 'row' section callbacks */
@@ -113,16 +113,16 @@ static herr_t H5HF__sect_row_valid(const H5FS_section_class_t *cls, const H5FS_s
 static herr_t H5HF__sect_row_debug(const H5FS_section_info_t *sect, FILE *stream, int indent, int fwidth);
 
 /* 'indirect' section routines */
-static H5HF_free_section_t *H5HF_sect_indirect_new(H5HF_hdr_t *hdr, haddr_t sect_off, hsize_t sect_size,
-                                                   H5HF_indirect_t *iblock, hsize_t iblock_off, unsigned row,
-                                                   unsigned col, unsigned nentries);
+static H5HF_free_section_t *H5HF__sect_indirect_new(H5HF_hdr_t *hdr, haddr_t sect_off, hsize_t sect_size,
+                                                    H5HF_indirect_t *iblock, hsize_t iblock_off, unsigned row,
+                                                    unsigned col, unsigned nentries);
 static herr_t H5HF__sect_indirect_init_rows(H5HF_hdr_t *hdr, H5HF_free_section_t *sect, hbool_t first_child,
                                             H5HF_free_section_t **first_row_sect, unsigned space_flags,
                                             unsigned start_row, unsigned start_col, unsigned end_row,
                                             unsigned end_col);
-static H5HF_free_section_t *H5HF_sect_indirect_for_row(H5HF_hdr_t *hdr, H5HF_indirect_t *iblock,
-                                                       H5HF_free_section_t *row_sect);
-static herr_t               H5HF_sect_indirect_decr(H5HF_free_section_t *sect);
+static H5HF_free_section_t *H5HF__sect_indirect_for_row(H5HF_hdr_t *hdr, H5HF_indirect_t *iblock,
+                                                        H5HF_free_section_t *row_sect);
+static herr_t               H5HF__sect_indirect_decr(H5HF_free_section_t *sect);
 static herr_t               H5HF__sect_indirect_revive_row(H5HF_hdr_t *hdr, H5HF_free_section_t *sect);
 static herr_t               H5HF__sect_indirect_revive(H5HF_hdr_t *hdr, H5HF_free_section_t *sect,
                                                        H5HF_indirect_t *sect_iblock);
@@ -130,25 +130,26 @@ static herr_t               H5HF__sect_indirect_reduce_row(H5HF_hdr_t *hdr, H5HF
                                                            hbool_t *alloc_from_start);
 static herr_t  H5HF__sect_indirect_reduce(H5HF_hdr_t *hdr, H5HF_free_section_t *sect, unsigned child_entry);
 static herr_t  H5HF__sect_indirect_first(H5HF_hdr_t *hdr, H5HF_free_section_t *sect);
-static hbool_t H5HF_sect_indirect_is_first(H5HF_free_section_t *sect);
-static H5HF_indirect_t *    H5HF_sect_indirect_get_iblock(H5HF_free_section_t *sect);
-static hsize_t              H5HF_sect_indirect_iblock_off(const H5HF_free_section_t *sect);
-static H5HF_free_section_t *H5HF_sect_indirect_top(H5HF_free_section_t *sect);
+static hbool_t H5HF__sect_indirect_is_first(H5HF_free_section_t *sect);
+static H5HF_indirect_t *    H5HF__sect_indirect_get_iblock(H5HF_free_section_t *sect);
+static hsize_t              H5HF__sect_indirect_iblock_off(const H5HF_free_section_t *sect);
+static H5HF_free_section_t *H5HF__sect_indirect_top(H5HF_free_section_t *sect);
 static herr_t               H5HF__sect_indirect_merge_row(H5HF_hdr_t *hdr, H5HF_free_section_t *sect1,
                                                           H5HF_free_section_t *sect2);
 static herr_t               H5HF__sect_indirect_build_parent(H5HF_hdr_t *hdr, H5HF_free_section_t *sect);
 static herr_t               H5HF__sect_indirect_shrink(H5HF_hdr_t *hdr, H5HF_free_section_t *sect);
-static herr_t H5HF_sect_indirect_serialize(H5HF_hdr_t *hdr, const H5HF_free_section_t *sect, uint8_t *buf);
+static herr_t H5HF__sect_indirect_serialize(H5HF_hdr_t *hdr, const H5HF_free_section_t *sect, uint8_t *buf);
 static H5FS_section_info_t *H5HF__sect_indirect_deserialize(H5HF_hdr_t *hdr, const uint8_t *buf,
                                                             haddr_t sect_addr, hsize_t sect_size,
                                                             unsigned *des_flags);
-static herr_t               H5HF_sect_indirect_free(H5HF_free_section_t *sect);
-static herr_t               H5HF_sect_indirect_valid(const H5HF_hdr_t *hdr, const H5HF_free_section_t *sect);
-static herr_t H5HF_sect_indirect_debug(const H5HF_free_section_t *sect, FILE *stream, int indent, int fwidth);
+static herr_t               H5HF__sect_indirect_free(H5HF_free_section_t *sect);
+static herr_t               H5HF__sect_indirect_valid(const H5HF_hdr_t *hdr, const H5HF_free_section_t *sect);
+static herr_t H5HF__sect_indirect_debug(const H5HF_free_section_t *sect, FILE *stream, int indent,
+                                        int fwidth);
 
 /* 'indirect' section callbacks */
-static herr_t H5HF_sect_indirect_init_cls(H5FS_section_class_t *cls, void *udata);
-static herr_t H5HF_sect_indirect_term_cls(H5FS_section_class_t *cls);
+static herr_t H5HF__sect_indirect_init_cls(H5FS_section_class_t *cls, void *udata);
+static herr_t H5HF__sect_indirect_term_cls(H5FS_section_class_t *cls);
 
 /*********************/
 /* Package Variables */
@@ -247,8 +248,8 @@ H5FS_section_class_t H5HF_FSPACE_SECT_CLS_INDIRECT[1] = {{
     NULL,                                    /* Class private info           */
 
     /* Class methods */
-    H5HF_sect_indirect_init_cls, /* Initialize section class     */
-    H5HF_sect_indirect_term_cls, /* Terminate section class      */
+    H5HF__sect_indirect_init_cls, /* Initialize section class     */
+    H5HF__sect_indirect_term_cls, /* Terminate section class      */
 
     /* Object methods */
     NULL, /* Add section                  */
@@ -276,7 +277,7 @@ H5FL_DEFINE(H5HF_free_section_t);
 /*******************/
 
 /*-------------------------------------------------------------------------
- * Function:	H5HF_sect_init_cls
+ * Function:	H5FS__sect_init_cls
  *
  * Purpose:	Initialize the common class structure
  *
@@ -289,12 +290,12 @@ H5FL_DEFINE(H5HF_free_section_t);
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5HF_sect_init_cls(H5FS_section_class_t *cls, H5HF_hdr_t *hdr)
+H5FS__sect_init_cls(H5FS_section_class_t *cls, H5HF_hdr_t *hdr)
 {
     H5HF_sect_private_t *cls_prvt;            /* Pointer to class private info */
     herr_t               ret_value = SUCCEED; /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /* Check arguments. */
     HDassert(cls);
@@ -309,15 +310,15 @@ H5HF_sect_init_cls(H5FS_section_class_t *cls, H5HF_hdr_t *hdr)
     cls->cls_private = cls_prvt;
 
     /* Increment reference count on heap header */
-    if (H5HF_hdr_incr(hdr) < 0)
+    if (H5HF__hdr_incr(hdr) < 0)
         HGOTO_ERROR(H5E_HEAP, H5E_CANTINC, FAIL, "can't increment reference count on shared heap header")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* H5HF_sect_init_cls() */
+} /* H5FS__sect_init_cls() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5HF_sect_term_cls
+ * Function:	H5FS__sect_term_cls
  *
  * Purpose:	Terminate the common class structure
  *
@@ -330,12 +331,12 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5HF_sect_term_cls(H5FS_section_class_t *cls)
+H5FS__sect_term_cls(H5FS_section_class_t *cls)
 {
     H5HF_sect_private_t *cls_prvt;            /* Pointer to class private info */
     herr_t               ret_value = SUCCEED; /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /* Check arguments. */
     HDassert(cls);
@@ -344,7 +345,7 @@ H5HF_sect_term_cls(H5FS_section_class_t *cls)
     cls_prvt = (H5HF_sect_private_t *)cls->cls_private;
 
     /* Decrement reference count on heap header */
-    if (H5HF_hdr_decr(cls_prvt->hdr) < 0)
+    if (H5HF__hdr_decr(cls_prvt->hdr) < 0)
         HGOTO_ERROR(H5E_HEAP, H5E_CANTDEC, FAIL, "can't decrement reference count on shared heap header")
 
     /* Free the class private information */
@@ -352,10 +353,10 @@ H5HF_sect_term_cls(H5FS_section_class_t *cls)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* H5HF_sect_term_cls() */
+} /* H5FS__sect_term_cls() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5HF_sect_node_new
+ * Function:	H5FS__sect_node_new
  *
  * Purpose:	Allocate a free space section node of a particular type
  *
@@ -369,12 +370,12 @@ done:
  *-------------------------------------------------------------------------
  */
 static H5HF_free_section_t *
-H5HF_sect_node_new(unsigned sect_type, haddr_t sect_addr, hsize_t sect_size, H5FS_section_state_t sect_state)
+H5FS__sect_node_new(unsigned sect_type, haddr_t sect_addr, hsize_t sect_size, H5FS_section_state_t sect_state)
 {
     H5HF_free_section_t *new_sect;         /* New section */
     H5HF_free_section_t *ret_value = NULL; /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /* Check arguments. */
     HDassert(H5F_addr_defined(sect_addr));
@@ -397,10 +398,10 @@ H5HF_sect_node_new(unsigned sect_type, haddr_t sect_addr, hsize_t sect_size, H5F
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* H5HF_sect_node_new() */
+} /* H5FS__sect_node_new() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5HF_sect_node_free
+ * Function:	H5HF__sect_node_free
  *
  * Purpose:	Free a section node
  *
@@ -414,11 +415,11 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5HF_sect_node_free(H5HF_free_section_t *sect, H5HF_indirect_t *iblock)
+H5HF__sect_node_free(H5HF_free_section_t *sect, H5HF_indirect_t *iblock)
 {
     herr_t ret_value = SUCCEED; /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     HDassert(sect);
 
@@ -433,28 +434,27 @@ H5HF_sect_node_free(H5HF_free_section_t *sect, H5HF_indirect_t *iblock)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* H5HF_sect_node_free() */
+} /* H5HF__sect_node_free() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5HF_sect_single_new
+ * Function:	H5HF__sect_single_new
  *
  * Purpose:	Create a new 'single' section and return it to the caller
  *
  * Return:	Pointer to new section on success/NULL on failure
  *
  * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
  *		May 30 2006
  *
  *-------------------------------------------------------------------------
  */
 H5HF_free_section_t *
-H5HF_sect_single_new(hsize_t sect_off, size_t sect_size, H5HF_indirect_t *parent, unsigned par_entry)
+H5HF__sect_single_new(hsize_t sect_off, size_t sect_size, H5HF_indirect_t *parent, unsigned par_entry)
 {
     H5HF_free_section_t *sect      = NULL; /* 'Single' free space section to add */
     H5HF_free_section_t *ret_value = NULL; /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_PACKAGE
 
     /*
      * Check arguments.
@@ -463,13 +463,13 @@ H5HF_sect_single_new(hsize_t sect_off, size_t sect_size, H5HF_indirect_t *parent
 
     /* Create free space section node */
     if (NULL ==
-        (sect = H5HF_sect_node_new(H5HF_FSPACE_SECT_SINGLE, sect_off, (hsize_t)sect_size, H5FS_SECT_LIVE)))
+        (sect = H5FS__sect_node_new(H5HF_FSPACE_SECT_SINGLE, sect_off, (hsize_t)sect_size, H5FS_SECT_LIVE)))
         HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for single section")
 
     /* Set the 'single' specific fields */
     sect->u.single.parent = parent;
     if (sect->u.single.parent) {
-        if (H5HF_iblock_incr(sect->u.single.parent) < 0)
+        if (H5HF__iblock_incr(sect->u.single.parent) < 0)
             HGOTO_ERROR(H5E_HEAP, H5E_CANTINC, NULL,
                         "can't increment reference count on shared indirect block")
     } /* end if */
@@ -485,7 +485,7 @@ done:
     } /* end if */
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5HF_sect_single_new() */
+} /* end H5HF__sect_single_new() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5HF__sect_single_locate_parent
@@ -495,7 +495,6 @@ done:
  * Return:	Non-negative on success/Negative on failure
  *
  * Programmer:	Quincey Koziol
- *		koziol@hdfgroup.org
  *		October 24 2006
  *
  *-------------------------------------------------------------------------
@@ -523,7 +522,7 @@ H5HF__sect_single_locate_parent(H5HF_hdr_t *hdr, hbool_t refresh, H5HF_free_sect
         HGOTO_ERROR(H5E_HEAP, H5E_CANTCOMPUTE, FAIL, "can't compute row & column of section")
 
     /* Increment reference count on indirect block that free section is in */
-    if (H5HF_iblock_incr(sec_iblock) < 0)
+    if (H5HF__iblock_incr(sec_iblock) < 0)
         HGOTO_ERROR(H5E_HEAP, H5E_CANTINC, FAIL, "can't increment reference count on shared indirect block")
 
     /* Check for refreshing existing parent information */
@@ -557,7 +556,6 @@ done:
  * Return:      SUCCEED/FAIL
  *
  * Programmer:  Quincey Koziol
- *              koziol@hdfgroup.org
  *              May  8 2006
  *
  *-------------------------------------------------------------------------
@@ -597,23 +595,22 @@ done:
 } /* end H5HF__sect_single_revive() */
 
 /*-------------------------------------------------------------------------
- * Function:    H5HF_sect_single_dblock_info
+ * Function:    H5HF__sect_single_dblock_info
  *
  * Purpose:     Retrieve the direct block information for a single section
  *
  * Return:      SUCCEED/FAIL
  *
  * Programmer:  Quincey Koziol
- *              koziol@hdfgroup.org
  *              October 24 2006
  *
  *-------------------------------------------------------------------------
  */
 herr_t
-H5HF_sect_single_dblock_info(H5HF_hdr_t *hdr, const H5HF_free_section_t *sect, haddr_t *dblock_addr,
-                             size_t *dblock_size)
+H5HF__sect_single_dblock_info(H5HF_hdr_t *hdr, const H5HF_free_section_t *sect, haddr_t *dblock_addr,
+                              size_t *dblock_size)
 {
-    FUNC_ENTER_NOAPI_NOERR
+    FUNC_ENTER_PACKAGE_NOERR
 
     /*
      * Check arguments.
@@ -640,7 +637,7 @@ H5HF_sect_single_dblock_info(H5HF_hdr_t *hdr, const H5HF_free_section_t *sect, h
     } /* end else */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5HF_sect_single_dblock_info() */
+} /* end H5HF__sect_single_dblock_info() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5HF__sect_single_reduce
@@ -652,7 +649,6 @@ H5HF_sect_single_dblock_info(H5HF_hdr_t *hdr, const H5HF_free_section_t *sect, h
  * Return:	Non-negative on success/Negative on failure
  *
  * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
  *		May 31 2006
  *
  *-------------------------------------------------------------------------
@@ -717,7 +713,7 @@ H5HF__sect_single_full_dblock(H5HF_hdr_t *hdr, H5HF_free_section_t *sect)
     size_t  dblock_overhead;     /* Direct block's overhead */
     herr_t  ret_value = SUCCEED; /* Return value */
 
-    FUNC_ENTER_PACKAGE
+    FUNC_ENTER_STATIC
 
     /* Check arguments. */
     HDassert(sect);
@@ -725,7 +721,7 @@ H5HF__sect_single_full_dblock(H5HF_hdr_t *hdr, H5HF_free_section_t *sect)
     HDassert(hdr);
 
     /* Retrieve direct block address from section */
-    if (H5HF_sect_single_dblock_info(hdr, sect, &dblock_addr, &dblock_size) < 0)
+    if (H5HF__sect_single_dblock_info(hdr, sect, &dblock_addr, &dblock_size) < 0)
         HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't retrieve direct block information")
 
     /* Check for section occupying entire direct block */
@@ -741,7 +737,7 @@ H5HF__sect_single_full_dblock(H5HF_hdr_t *hdr, H5HF_free_section_t *sect)
         HDassert(H5F_addr_eq(dblock->block_off + dblock_overhead, sect->sect_info.addr));
 
         /* Convert 'single' section into 'row' section */
-        if (H5HF_sect_row_from_single(hdr, sect, dblock) < 0)
+        if (H5HF__sect_row_from_single(hdr, sect, dblock) < 0)
             HGOTO_ERROR(H5E_HEAP, H5E_CANTCONVERT, FAIL, "can't convert single section into row section")
 
         /* Destroy direct block */
@@ -840,7 +836,7 @@ H5HF__sect_single_deserialize(const H5FS_section_class_t H5_ATTR_UNUSED *cls,
 
     /* Create free list section node */
     if (NULL ==
-        (new_sect = H5HF_sect_node_new(H5HF_FSPACE_SECT_SINGLE, sect_addr, sect_size, H5FS_SECT_SERIALIZED)))
+        (new_sect = H5FS__sect_node_new(H5HF_FSPACE_SECT_SINGLE, sect_addr, sect_size, H5FS_SECT_SERIALIZED)))
         HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "allocation failed for direct block free list section")
 
     /* Set return value */
@@ -1045,7 +1041,7 @@ H5HF__sect_single_shrink(H5FS_section_info_t **_sect, void *_udata)
             HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "can't revive single free section")
 
     /* Retrieve direct block address from section */
-    if (H5HF_sect_single_dblock_info(hdr, (*sect), &dblock_addr, &dblock_size) < 0)
+    if (H5HF__sect_single_dblock_info(hdr, (*sect), &dblock_addr, &dblock_size) < 0)
         HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL, "can't retrieve direct block information")
 
     /* Protect the direct block for the section */
@@ -1099,14 +1095,13 @@ H5HF__sect_single_free(H5FS_section_info_t *_sect)
     HDassert(sect);
 
     /* Check for live reference to an indirect block */
-    if (sect->sect_info.state == H5FS_SECT_LIVE) {
+    if (sect->sect_info.state == H5FS_SECT_LIVE)
         /* Get parent indirect block, if there was one */
         if (sect->u.single.parent)
             parent = sect->u.single.parent;
-    } /* end if */
 
     /* Release the section */
-    if (H5HF_sect_node_free(sect, parent) < 0)
+    if (H5HF__sect_node_free(sect, parent) < 0)
         HGOTO_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL, "can't free section node")
 
 done:
@@ -1152,8 +1147,8 @@ H5HF__sect_single_valid(const H5FS_section_class_t H5_ATTR_UNUSED *cls, const H5
             HDassert(H5F_addr_defined(iblock->ents[sect->u.single.par_entry].addr));
 
             /* Retrieve direct block address from section */
-            status = H5HF_sect_single_dblock_info(iblock->hdr, (const H5HF_free_section_t *)sect,
-                                                  &dblock_addr, &dblock_size);
+            status = H5HF__sect_single_dblock_info(iblock->hdr, (const H5HF_free_section_t *)sect,
+                                                   &dblock_addr, &dblock_size);
             HDassert(status >= 0);
             HDassert(H5F_addr_eq(iblock->ents[sect->u.single.par_entry].addr, dblock_addr));
             HDassert(dblock_size > 0);
@@ -1200,7 +1195,7 @@ H5HF__sect_single_valid(const H5FS_section_class_t H5_ATTR_UNUSED *cls, const H5
 } /* H5HF__sect_single_valid() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5HF_sect_row_create
+ * Function:	H5HF__sect_row_create
  *
  * Purpose:	Create a new 'row' section
  *
@@ -1214,13 +1209,13 @@ H5HF__sect_single_valid(const H5FS_section_class_t H5_ATTR_UNUSED *cls, const H5
  *-------------------------------------------------------------------------
  */
 static H5HF_free_section_t *
-H5HF_sect_row_create(haddr_t sect_off, hsize_t sect_size, hbool_t is_first, unsigned row, unsigned col,
-                     unsigned nentries, H5HF_free_section_t *under_sect)
+H5HF__sect_row_create(haddr_t sect_off, hsize_t sect_size, hbool_t is_first, unsigned row, unsigned col,
+                      unsigned nentries, H5HF_free_section_t *under_sect)
 {
     H5HF_free_section_t *sect      = NULL; /* 'Row' section created */
     H5HF_free_section_t *ret_value = NULL; /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /* Check arguments. */
     HDassert(sect_size);
@@ -1229,7 +1224,7 @@ H5HF_sect_row_create(haddr_t sect_off, hsize_t sect_size, hbool_t is_first, unsi
 
     /* Create 'row' free space section node */
     /* ("inherits" underlying indirect section's state) */
-    if (NULL == (sect = H5HF_sect_node_new(
+    if (NULL == (sect = H5FS__sect_node_new(
                      (unsigned)(is_first ? H5HF_FSPACE_SECT_FIRST_ROW : H5HF_FSPACE_SECT_NORMAL_ROW),
                      sect_off, sect_size, under_sect->sect_info.state)))
         HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for row section")
@@ -1246,27 +1241,26 @@ H5HF_sect_row_create(haddr_t sect_off, hsize_t sect_size, hbool_t is_first, unsi
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* H5HF_sect_row_create() */
+} /* H5HF__sect_row_create() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5HF_sect_row_from_single
+ * Function:	H5HF__sect_row_from_single
  *
  * Purpose:	Convert a 'single' section into a 'row' section
  *
  * Return:	Non-negative on success/Negative on failure
  *
  * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
  *		July  6 2006
  *
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5HF_sect_row_from_single(H5HF_hdr_t *hdr, H5HF_free_section_t *sect, H5HF_direct_t *dblock)
+H5HF__sect_row_from_single(H5HF_hdr_t *hdr, H5HF_free_section_t *sect, H5HF_direct_t *dblock)
 {
     herr_t ret_value = SUCCEED; /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /*
      * Check arguments.
@@ -1284,7 +1278,7 @@ H5HF_sect_row_from_single(H5HF_hdr_t *hdr, H5HF_free_section_t *sect, H5HF_direc
     sect->u.row.checked_out = FALSE;
 
     /* Create indirect section that underlies the row section */
-    if (NULL == (sect->u.row.under = H5HF_sect_indirect_for_row(hdr, dblock->parent, sect)))
+    if (NULL == (sect->u.row.under = H5HF__sect_indirect_for_row(hdr, dblock->parent, sect)))
         HGOTO_ERROR(H5E_HEAP, H5E_CANTCREATE, FAIL, "serializing row section not supported yet")
 
     /* Release single section's hold on underlying indirect block */
@@ -1293,7 +1287,7 @@ H5HF_sect_row_from_single(H5HF_hdr_t *hdr, H5HF_free_section_t *sect, H5HF_direc
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5HF_sect_row_from_single() */
+} /* end H5HF__sect_row_from_single() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5HF__sect_row_revive
@@ -1303,7 +1297,6 @@ done:
  * Return:	Non-negative on success/Negative on failure
  *
  * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
  *		July  6 2006
  *
  *-------------------------------------------------------------------------
@@ -1350,7 +1343,6 @@ done:
  * Return:	Non-negative on success/Negative on failure
  *
  * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
  *		July  6 2006
  *
  *-------------------------------------------------------------------------
@@ -1424,7 +1416,6 @@ done:
  * Return:	Non-negative on success/Negative on failure
  *
  * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
  *		July 10 2006
  *
  *-------------------------------------------------------------------------
@@ -1457,24 +1448,23 @@ done:
 } /* end H5HF__sect_row_first() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5HF_sect_row_get_iblock
+ * Function:	H5HF__sect_row_get_iblock
  *
  * Purpose:	Retrieve the indirect block for a row section
  *
  * Return:	Pointer to indirect block on success/NULL on failure
  *
  * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
  *		July  9 2006
  *
  *-------------------------------------------------------------------------
  */
 H5HF_indirect_t *
-H5HF_sect_row_get_iblock(H5HF_free_section_t *sect)
+H5HF__sect_row_get_iblock(H5HF_free_section_t *sect)
 {
     H5HF_indirect_t *ret_value = NULL; /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_PACKAGE_NOERR
 
     /*
      * Check arguments.
@@ -1484,10 +1474,10 @@ H5HF_sect_row_get_iblock(H5HF_free_section_t *sect)
              sect->sect_info.type == H5HF_FSPACE_SECT_NORMAL_ROW);
     HDassert(sect->sect_info.state == H5FS_SECT_LIVE);
 
-    ret_value = H5HF_sect_indirect_get_iblock(sect->u.row.under);
+    ret_value = H5HF__sect_indirect_get_iblock(sect->u.row.under);
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5HF_sect_row_get_iblock() */
+} /* end H5HF__sect_row_get_iblock() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5HF__sect_row_parent_removed
@@ -1498,7 +1488,6 @@ H5HF_sect_row_get_iblock(H5HF_free_section_t *sect)
  * Return:	Non-negative on success / Negative on failure
  *
  * Programmer:	Quincey Koziol
- *		koziol@lbl.gov
  *		February 4 2018
  *
  *-------------------------------------------------------------------------
@@ -1571,7 +1560,7 @@ H5HF__sect_row_init_cls(H5FS_section_class_t *cls, void *_udata)
     HDassert(hdr);
 
     /* Call common class initialization */
-    if (H5HF_sect_init_cls(cls, hdr) < 0)
+    if (H5FS__sect_init_cls(cls, hdr) < 0)
         HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "can't initialize common section class")
 
     /* First row sections actually are proxies for indirection sections on disk */
@@ -1612,7 +1601,7 @@ H5HF__sect_row_term_cls(H5FS_section_class_t *cls)
     HDassert(cls);
 
     /* Call common class termination */
-    if (H5HF_sect_term_cls(cls) < 0)
+    if (H5FS__sect_term_cls(cls) < 0)
         HGOTO_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL, "can't terminate common section class")
 
 done:
@@ -1651,7 +1640,7 @@ H5HF__sect_row_serialize(const H5FS_section_class_t *cls, const H5FS_section_inf
 
     /* Forward to indirect routine to serialize underlying section */
     hdr = ((H5HF_sect_private_t *)(cls->cls_private))->hdr;
-    if (H5HF_sect_indirect_serialize(hdr, sect->u.row.under, buf) < 0)
+    if (H5HF__sect_indirect_serialize(hdr, sect->u.row.under, buf) < 0)
         HGOTO_ERROR(H5E_HEAP, H5E_CANTSERIALIZE, FAIL,
                     "can't serialize row section's underlying indirect section")
 
@@ -1736,24 +1725,22 @@ H5HF__sect_row_can_merge(const H5FS_section_info_t *_sect1, const H5FS_section_i
     HDassert(H5F_addr_lt(sect1->sect_info.addr, sect2->sect_info.addr));
 
     /* Get the top indirect section underlying each row */
-    top_indir_sect1 = H5HF_sect_indirect_top(sect1->u.row.under);
+    top_indir_sect1 = H5HF__sect_indirect_top(sect1->u.row.under);
     HDassert(top_indir_sect1);
-    top_indir_sect2 = H5HF_sect_indirect_top(sect2->u.row.under);
+    top_indir_sect2 = H5HF__sect_indirect_top(sect2->u.row.under);
     HDassert(top_indir_sect2);
 
     /* Check if second section shares the same underlying indirect block as
      *  the first section, but doesn't already have same underlying indirect
      *  section.
      */
-    if (top_indir_sect1 != top_indir_sect2) {
-        if (H5HF_sect_indirect_iblock_off(sect1->u.row.under) ==
-            H5HF_sect_indirect_iblock_off(sect2->u.row.under)) {
+    if (top_indir_sect1 != top_indir_sect2)
+        if (H5HF__sect_indirect_iblock_off(sect1->u.row.under) ==
+            H5HF__sect_indirect_iblock_off(sect2->u.row.under))
             /* Check if second section adjoins first section */
             if (H5F_addr_eq((top_indir_sect1->sect_info.addr + top_indir_sect1->u.indirect.span_size),
                             top_indir_sect2->sect_info.addr))
                 HGOTO_DONE(TRUE)
-        } /* end if */
-    }     /* end if */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -1797,7 +1784,7 @@ H5HF__sect_row_merge(H5FS_section_info_t **_sect1, H5FS_section_info_t *_sect2,
         H5HF_free_section_t *top_indir_sect; /* Top indirect section for row */
 
         /* Get the top indirect section underlying second row section */
-        top_indir_sect = H5HF_sect_indirect_top(sect2->u.row.under);
+        top_indir_sect = H5HF__sect_indirect_top(sect2->u.row.under);
 
         /* Shrink away underlying indirect section */
         if (H5HF__sect_indirect_shrink(hdr, top_indir_sect) < 0)
@@ -1883,7 +1870,7 @@ H5HF__sect_row_shrink(H5FS_section_info_t **_sect, void *_udata)
     HDassert((*sect)->sect_info.type == H5HF_FSPACE_SECT_FIRST_ROW);
 
     /* Get the top indirect section underlying each row */
-    top_indir_sect = H5HF_sect_indirect_top((*sect)->u.row.under);
+    top_indir_sect = H5HF__sect_indirect_top((*sect)->u.row.under);
 
     /* Shrink away underlying indirect section */
     if (H5HF__sect_indirect_shrink(hdr, top_indir_sect) < 0)
@@ -1920,7 +1907,7 @@ H5HF__sect_row_free_real(H5HF_free_section_t *sect)
     HDassert(sect);
 
     /* Release the section */
-    if (H5HF_sect_node_free(sect, NULL) < 0)
+    if (H5HF__sect_node_free(sect, NULL) < 0)
         HGOTO_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL, "can't free section node")
 
 done:
@@ -1953,7 +1940,7 @@ H5HF__sect_row_free(H5FS_section_info_t *_sect)
     HDassert(sect->u.row.under);
 
     /* Decrement the ref. count on the row section's underlying indirect section */
-    if (H5HF_sect_indirect_decr(sect->u.row.under) < 0)
+    if (H5HF__sect_indirect_decr(sect->u.row.under) < 0)
         HGOTO_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL, "can't detach section node")
 
     /* Release the section */
@@ -2015,10 +2002,10 @@ H5HF__sect_row_valid(const H5FS_section_class_t *cls, const H5FS_section_info_t
         HDassert(sect->u.row.row == indir_sect->u.indirect.row);
 
         /* Get the top indirect section underlying row */
-        top_indir_sect = H5HF_sect_indirect_top(sect->u.row.under);
+        top_indir_sect = H5HF__sect_indirect_top(sect->u.row.under);
 
         /* Check that the row's underlying indirect section is valid */
-        H5HF_sect_indirect_valid(hdr, top_indir_sect);
+        H5HF__sect_indirect_valid(hdr, top_indir_sect);
     } /* end if */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
@@ -2057,31 +2044,30 @@ H5HF__sect_row_debug(const H5FS_section_info_t *_sect, FILE *stream, int indent,
         /* Print indirect section header */
         HDfprintf(stream, "%*s%-*s\n", indent, "", fwidth, "Underlying indirect section:");
 
-        H5HF_sect_indirect_debug(sect->u.row.under, stream, indent + 3, MAX(0, fwidth - 3));
+        H5HF__sect_indirect_debug(sect->u.row.under, stream, indent + 3, MAX(0, fwidth - 3));
     } /* end if */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* H5HF__sect_row_debug() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5HF_sect_indirect_iblock_off
+ * Function:	H5HF__sect_indirect_iblock_off
  *
  * Purpose:	Get the offset of the indirect block for the section
  *
  * Return:	Offset of indirect block in "heap space" (can't fail)
  *
  * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
  *		July  6 2006
  *
  *-------------------------------------------------------------------------
  */
 static hsize_t
-H5HF_sect_indirect_iblock_off(const H5HF_free_section_t *sect)
+H5HF__sect_indirect_iblock_off(const H5HF_free_section_t *sect)
 {
     hsize_t ret_value = 0; /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
     /*
      * Check arguments.
@@ -2092,27 +2078,26 @@ H5HF_sect_indirect_iblock_off(const H5HF_free_section_t *sect)
                                                         : sect->u.indirect.u.iblock_off;
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5HF_sect_indirect_iblock_off() */
+} /* end H5HF__sect_indirect_iblock_off() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5HF_sect_indirect_top
+ * Function:	H5HF__sect_indirect_top
  *
  * Purpose:	Get the "top" indirect section
  *
  * Return:	Pointer to the top indirect section (can't fail)
  *
  * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
  *		July  6 2006
  *
  *-------------------------------------------------------------------------
  */
 static H5HF_free_section_t *
-H5HF_sect_indirect_top(H5HF_free_section_t *sect)
+H5HF__sect_indirect_top(H5HF_free_section_t *sect)
 {
     H5HF_free_section_t *ret_value = NULL; /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
     /*
      * Check arguments.
@@ -2120,15 +2105,15 @@ H5HF_sect_indirect_top(H5HF_free_section_t *sect)
     HDassert(sect);
 
     if (sect->u.indirect.parent)
-        ret_value = H5HF_sect_indirect_top(sect->u.indirect.parent);
+        ret_value = H5HF__sect_indirect_top(sect->u.indirect.parent);
     else
         ret_value = sect;
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5HF_sect_indirect_top() */
+} /* end H5HF__sect_indirect_top() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5HF_sect_indirect_init_cls
+ * Function:	H5HF__sect_indirect_init_cls
  *
  * Purpose:	Initialize the "indirect" class structure
  *
@@ -2142,19 +2127,19 @@ H5HF_sect_indirect_top(H5HF_free_section_t *sect)
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5HF_sect_indirect_init_cls(H5FS_section_class_t *cls, void *_udata)
+H5HF__sect_indirect_init_cls(H5FS_section_class_t *cls, void *_udata)
 {
     H5HF_hdr_t *hdr       = (H5HF_hdr_t *)_udata; /* Fractal heap header */
     herr_t      ret_value = SUCCEED;              /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /* Check arguments. */
     HDassert(cls);
     HDassert(hdr);
 
     /* Call to common class initialization */
-    if (H5HF_sect_init_cls(cls, hdr) < 0)
+    if (H5FS__sect_init_cls(cls, hdr) < 0)
         HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "can't initialize common section class")
 
     /* Set the size of all serialized objects of this class of sections */
@@ -2162,10 +2147,10 @@ H5HF_sect_indirect_init_cls(H5FS_section_class_t *cls, void *_udata)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* H5HF_sect_indirect_init_cls() */
+} /* H5HF__sect_indirect_init_cls() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5HF_sect_indirect_term_cls
+ * Function:	H5HF__sect_indirect_term_cls
  *
  * Purpose:	Terminate the "indirect" class structure
  *
@@ -2179,25 +2164,25 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5HF_sect_indirect_term_cls(H5FS_section_class_t *cls)
+H5HF__sect_indirect_term_cls(H5FS_section_class_t *cls)
 {
     herr_t ret_value = SUCCEED; /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /* Check arguments. */
     HDassert(cls);
 
     /* Call common class termination */
-    if (H5HF_sect_term_cls(cls) < 0)
+    if (H5FS__sect_term_cls(cls) < 0)
         HGOTO_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL, "can't terminate common section class")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* H5HF_sect_indirect_term_cls() */
+} /* H5HF__sect_indirect_term_cls() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5HF_sect_indirect_new
+ * Function:	H5HF__sect_indirect_new
  *
  * Purpose:	Create a new 'indirect' section for other routines to finish
  *              initializing.
@@ -2205,19 +2190,18 @@ done:
  * Return:	Non-negative on success/Negative on failure
  *
  * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
  *		July  6 2006
  *
  *-------------------------------------------------------------------------
  */
 static H5HF_free_section_t *
-H5HF_sect_indirect_new(H5HF_hdr_t *hdr, haddr_t sect_off, hsize_t sect_size, H5HF_indirect_t *iblock,
-                       hsize_t iblock_off, unsigned row, unsigned col, unsigned nentries)
+H5HF__sect_indirect_new(H5HF_hdr_t *hdr, haddr_t sect_off, hsize_t sect_size, H5HF_indirect_t *iblock,
+                        hsize_t iblock_off, unsigned row, unsigned col, unsigned nentries)
 {
     H5HF_free_section_t *sect      = NULL; /* 'Indirect' free space section to add */
     H5HF_free_section_t *ret_value = NULL; /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /*
      * Check arguments.
@@ -2226,15 +2210,15 @@ H5HF_sect_indirect_new(H5HF_hdr_t *hdr, haddr_t sect_off, hsize_t sect_size, H5H
     HDassert(nentries);
 
     /* Create free space section node */
-    if (NULL == (sect = H5HF_sect_node_new(H5HF_FSPACE_SECT_INDIRECT, sect_off, sect_size,
-                                           (iblock ? H5FS_SECT_LIVE : H5FS_SECT_SERIALIZED))))
+    if (NULL == (sect = H5FS__sect_node_new(H5HF_FSPACE_SECT_INDIRECT, sect_off, sect_size,
+                                            (iblock ? H5FS_SECT_LIVE : H5FS_SECT_SERIALIZED))))
         HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed for indirect section")
 
     /* Set the 'indirect' specific fields */
     if (iblock) {
         sect->u.indirect.u.iblock       = iblock;
         sect->u.indirect.iblock_entries = hdr->man_dtable.cparam.width * sect->u.indirect.u.iblock->max_rows;
-        if (H5HF_iblock_incr(sect->u.indirect.u.iblock) < 0)
+        if (H5HF__iblock_incr(sect->u.indirect.u.iblock) < 0)
             HGOTO_ERROR(H5E_HEAP, H5E_CANTINC, NULL,
                         "can't increment reference count on shared indirect block")
     } /* end if */
@@ -2247,7 +2231,7 @@ H5HF_sect_indirect_new(H5HF_hdr_t *hdr, haddr_t sect_off, hsize_t sect_size, H5H
     sect->u.indirect.num_entries = nentries;
 
     /* Compute span size of indirect section */
-    sect->u.indirect.span_size = H5HF_dtable_span_size(&hdr->man_dtable, row, col, nentries);
+    sect->u.indirect.span_size = H5HF__dtable_span_size(&hdr->man_dtable, row, col, nentries);
     HDassert(sect->u.indirect.span_size > 0);
 
     /* This indirect section doesn't (currently) have a parent */
@@ -2264,28 +2248,27 @@ done:
     } /* end if */
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5HF_sect_indirect_new() */
+} /* end H5HF__sect_indirect_new() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5HF_sect_indirect_for_row
+ * Function:	H5HF__sect_indirect_for_row
  *
  * Purpose:	Create the underlying indirect section for a new row section
  *
  * Return:	Non-negative on success/Negative on failure
  *
  * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
  *		July  6 2006
  *
  *-------------------------------------------------------------------------
  */
 static H5HF_free_section_t *
-H5HF_sect_indirect_for_row(H5HF_hdr_t *hdr, H5HF_indirect_t *iblock, H5HF_free_section_t *row_sect)
+H5HF__sect_indirect_for_row(H5HF_hdr_t *hdr, H5HF_indirect_t *iblock, H5HF_free_section_t *row_sect)
 {
     H5HF_free_section_t *sect      = NULL; /* 'Indirect' free space section to add */
     H5HF_free_section_t *ret_value = NULL; /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /*
      * Check arguments.
@@ -2296,9 +2279,9 @@ H5HF_sect_indirect_for_row(H5HF_hdr_t *hdr, H5HF_indirect_t *iblock, H5HF_free_s
     HDassert(row_sect->u.row.row < hdr->man_dtable.max_direct_rows);
 
     /* Create free space section node */
-    if (NULL == (sect = H5HF_sect_indirect_new(hdr, row_sect->sect_info.addr, row_sect->sect_info.size,
-                                               iblock, iblock->block_off, row_sect->u.row.row,
-                                               row_sect->u.row.col, row_sect->u.row.num_entries)))
+    if (NULL == (sect = H5HF__sect_indirect_new(hdr, row_sect->sect_info.addr, row_sect->sect_info.size,
+                                                iblock, iblock->block_off, row_sect->u.row.row,
+                                                row_sect->u.row.col, row_sect->u.row.num_entries)))
         HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, NULL, "can't create indirect section")
 
     /* Set # of direct rows covered */
@@ -2322,11 +2305,11 @@ H5HF_sect_indirect_for_row(H5HF_hdr_t *hdr, H5HF_indirect_t *iblock, H5HF_free_s
 
 done:
     if (!ret_value && sect)
-        if (H5HF_sect_indirect_free(sect) < 0)
+        if (H5HF__sect_indirect_free(sect) < 0)
             HDONE_ERROR(H5E_HEAP, H5E_CANTRELEASE, NULL, "can't free indirect section node")
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5HF_sect_indirect_for_row() */
+} /* end H5HF__sect_indirect_for_row() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5HF__sect_indirect_init_rows
@@ -2337,7 +2320,6 @@ done:
  * Return:	Non-negative on success/Negative on failure
  *
  * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
  *		July  6 2006
  *
  *-------------------------------------------------------------------------
@@ -2451,7 +2433,7 @@ H5HF__sect_indirect_init_rows(H5HF_hdr_t *hdr, H5HF_free_section_t *sect, hbool_
             H5HF_free_section_t *row_sect = NULL; /* 'Row' free space section to add */
 
             /* Create 'row' free space section node */
-            if (NULL == (row_sect = H5HF_sect_row_create(
+            if (NULL == (row_sect = H5HF__sect_row_create(
                              curr_off, (hdr->man_dtable.row_block_size[u] - dblock_overhead), first_child, u,
                              row_col, row_entries, sect)))
                 HGOTO_ERROR(H5E_HEAP, H5E_CANTCREATE, FAIL, "creation failed for child row section")
@@ -2488,20 +2470,20 @@ H5HF__sect_indirect_init_rows(H5HF_hdr_t *hdr, H5HF_free_section_t *sect, hbool_
             unsigned             v;              /* Local index variable */
 
             /* Compute info about row's indirect blocks for child section */
-            child_nrows    = H5HF_dtable_size_to_rows(&hdr->man_dtable, hdr->man_dtable.row_block_size[u]);
+            child_nrows    = H5HF__dtable_size_to_rows(&hdr->man_dtable, hdr->man_dtable.row_block_size[u]);
             child_nentries = child_nrows * hdr->man_dtable.cparam.width;
 
             /* Add an indirect section for each indirect block in the row */
             for (v = 0; v < row_entries; v++) {
-                hbool_t did_protect; /* Whether we protected the indirect block or not */
+                hbool_t did_protect = FALSE; /* Whether we protected the indirect block or not */
 
                 /* Try to get the child section's indirect block, if it's available */
                 if (sect->sect_info.state == H5FS_SECT_LIVE) {
                     haddr_t child_iblock_addr; /* Child indirect block's address on disk */
 
                     /* Get the address of the child indirect block */
-                    if (H5HF_man_iblock_entry_addr(sect->u.indirect.u.iblock, curr_entry,
-                                                   &child_iblock_addr) < 0)
+                    if (H5HF__man_iblock_entry_addr(sect->u.indirect.u.iblock, curr_entry,
+                                                    &child_iblock_addr) < 0)
                         HGOTO_ERROR(H5E_HEAP, H5E_CANTGET, FAIL,
                                     "unable to retrieve child indirect block's address")
 
@@ -2520,8 +2502,8 @@ H5HF__sect_indirect_init_rows(H5HF_hdr_t *hdr, H5HF_free_section_t *sect, hbool_
                     child_iblock = NULL;
 
                 /* Create free space section node */
-                if (NULL == (child_sect = H5HF_sect_indirect_new(hdr, curr_off, (hsize_t)0, child_iblock,
-                                                                 curr_off, 0, 0, child_nentries)))
+                if (NULL == (child_sect = H5HF__sect_indirect_new(hdr, curr_off, (hsize_t)0, child_iblock,
+                                                                  curr_off, 0, 0, child_nentries)))
                     HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "can't create indirect section")
 
                 /* Initialize rows for new indirect section */
@@ -2592,7 +2574,6 @@ done:
  * Return:	Non-negative on success/Negative on failure
  *
  * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
  *		July  3 2006
  *
  *-------------------------------------------------------------------------
@@ -2636,8 +2617,8 @@ H5HF__sect_indirect_add(H5HF_hdr_t *hdr, H5HF_indirect_t *iblock, unsigned start
     sect_off += hdr->man_dtable.row_block_size[start_row] * start_col;
 
     /* Create free space section node */
-    if (NULL == (sect = H5HF_sect_indirect_new(hdr, sect_off, (hsize_t)0, iblock, iblock->block_off,
-                                               start_row, start_col, nentries)))
+    if (NULL == (sect = H5HF__sect_indirect_new(hdr, sect_off, (hsize_t)0, iblock, iblock->block_off,
+                                                start_row, start_col, nentries)))
         HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "can't create indirect section")
 
     /* Initialize rows for new indirect section */
@@ -2654,31 +2635,30 @@ H5HF__sect_indirect_add(H5HF_hdr_t *hdr, H5HF_indirect_t *iblock, unsigned start
 
 done:
     if (ret_value < 0 && sect)
-        if (H5HF_sect_indirect_free(sect) < 0)
+        if (H5HF__sect_indirect_free(sect) < 0)
             HDONE_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL, "can't free indirect section node")
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5HF__sect_indirect_add() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5HF_sect_indirect_decr
+ * Function:	H5HF__sect_indirect_decr
  *
  * Purpose:	Decrement ref. count on indirect section
  *
  * Return:	Non-negative on success/Negative on failure
  *
  * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
  *		July  6 2006
  *
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5HF_sect_indirect_decr(H5HF_free_section_t *sect)
+H5HF__sect_indirect_decr(H5HF_free_section_t *sect)
 {
     herr_t ret_value = SUCCEED; /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /*
      * Check arguments.
@@ -2697,19 +2677,19 @@ H5HF_sect_indirect_decr(H5HF_free_section_t *sect)
         par_sect = sect->u.indirect.parent;
 
         /* Free indirect section */
-        if (H5HF_sect_indirect_free(sect) < 0)
+        if (H5HF__sect_indirect_free(sect) < 0)
             HGOTO_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL, "can't free indirect section node")
 
         /* Decrement ref. count on indirect section's parent */
         if (par_sect)
-            if (H5HF_sect_indirect_decr(par_sect) < 0)
+            if (H5HF__sect_indirect_decr(par_sect) < 0)
                 HGOTO_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL,
                             "can't decrement ref. count on parent indirect section")
     } /* end if */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5HF_sect_indirect_decr() */
+} /* end H5HF__sect_indirect_decr() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5HF__sect_indirect_revive_row
@@ -2719,7 +2699,6 @@ done:
  * Return:	Non-negative on success/Negative on failure
  *
  * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
  *		July  3 2006
  *
  *-------------------------------------------------------------------------
@@ -2765,7 +2744,6 @@ done:
  * Return:	Non-negative on success/Negative on failure
  *
  * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
  *		July 10 2006
  *
  *-------------------------------------------------------------------------
@@ -2787,7 +2765,7 @@ H5HF__sect_indirect_revive(H5HF_hdr_t *hdr, H5HF_free_section_t *sect, H5HF_indi
     HDassert(sect_iblock);
 
     /* Increment reference count on indirect block that free section is in */
-    if (H5HF_iblock_incr(sect_iblock) < 0)
+    if (H5HF__iblock_incr(sect_iblock) < 0)
         HGOTO_ERROR(H5E_HEAP, H5E_CANTDEC, FAIL, "can't decrement reference count on shared indirect block")
 
     /* Set the pointer to the section's indirect block */
@@ -2822,7 +2800,6 @@ done:
  * Return:	Non-negative on success/Negative on failure
  *
  * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
  *		July 10 2006
  *
  *-------------------------------------------------------------------------
@@ -2884,7 +2861,7 @@ H5HF__sect_indirect_reduce_row(H5HF_hdr_t *hdr, H5HF_free_section_t *row_sect, h
         hbool_t is_first; /* Flag to indicate that this section is the first section in hierarchy */
 
         /* Check if this section is the first section */
-        is_first = H5HF_sect_indirect_is_first(sect);
+        is_first = H5HF__sect_indirect_is_first(sect);
 
         /* Remove this indirect section from parent indirect section */
         if (H5HF__sect_indirect_reduce(hdr, sect->u.indirect.parent, sect->u.indirect.par_entry) < 0)
@@ -3001,8 +2978,8 @@ H5HF__sect_indirect_reduce_row(H5HF_hdr_t *hdr, H5HF_free_section_t *row_sect, h
 
             /* Create peer indirect section */
             if (NULL ==
-                (peer_sect = H5HF_sect_indirect_new(hdr, sect->sect_info.addr, sect->sect_info.size, iblock,
-                                                    iblock_off, start_row, start_col, peer_nentries)))
+                (peer_sect = H5HF__sect_indirect_new(hdr, sect->sect_info.addr, sect->sect_info.size, iblock,
+                                                     iblock_off, start_row, start_col, peer_nentries)))
                 HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "can't create indirect section")
 
             /* Set up direct row & indirect entry information for peer section */
@@ -3076,7 +3053,7 @@ done:
         /* Sanity check - we should only be here if an error occurred */
         HDassert(ret_value < 0);
 
-        if (H5HF_sect_indirect_free(peer_sect) < 0)
+        if (H5HF__sect_indirect_free(peer_sect) < 0)
             HDONE_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL, "can't free indirect section node")
     } /* end if */
 
@@ -3093,7 +3070,6 @@ done:
  * Return:	Non-negative on success/Negative on failure
  *
  * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
  *		July 10 2006
  *
  *-------------------------------------------------------------------------
@@ -3133,7 +3109,7 @@ H5HF__sect_indirect_reduce(H5HF_hdr_t *hdr, H5HF_free_section_t *sect, unsigned
             hbool_t is_first; /* Flag to indicate that this section is the first section in hierarchy */
 
             /* Check if this section is the first section */
-            is_first = H5HF_sect_indirect_is_first(sect);
+            is_first = H5HF__sect_indirect_is_first(sect);
 
             /* Reduce parent indirect section */
             if (H5HF__sect_indirect_reduce(hdr, sect->u.indirect.parent, sect->u.indirect.par_entry) < 0)
@@ -3229,8 +3205,8 @@ H5HF__sect_indirect_reduce(H5HF_hdr_t *hdr, H5HF_free_section_t *sect, unsigned
             /* Update the number of entries in current section & calculate it's span size */
             /* (Will use this to compute the section address for the peer section */
             sect->u.indirect.num_entries = new_nentries;
-            sect->u.indirect.span_size   = H5HF_dtable_span_size(&hdr->man_dtable, sect->u.indirect.row,
-                                                               sect->u.indirect.col, new_nentries);
+            sect->u.indirect.span_size   = H5HF__dtable_span_size(&hdr->man_dtable, sect->u.indirect.row,
+                                                                sect->u.indirect.col, new_nentries);
             HDassert(sect->u.indirect.span_size > 0);
 
             /* Compute address of peer indirect section */
@@ -3239,9 +3215,9 @@ H5HF__sect_indirect_reduce(H5HF_hdr_t *hdr, H5HF_free_section_t *sect, unsigned
             peer_sect_addr += hdr->man_dtable.row_block_size[child_row];
 
             /* Create peer indirect section */
-            if (NULL == (peer_sect = H5HF_sect_indirect_new(hdr, peer_sect_addr, sect->sect_info.size, iblock,
-                                                            iblock_off, peer_start_row, peer_start_col,
-                                                            peer_nentries)))
+            if (NULL == (peer_sect = H5HF__sect_indirect_new(hdr, peer_sect_addr, sect->sect_info.size,
+                                                             iblock, iblock_off, peer_start_row,
+                                                             peer_start_col, peer_nentries)))
                 HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "can't create indirect section")
 
             /* Set up direct row & indirect entry information for peer section */
@@ -3305,7 +3281,7 @@ H5HF__sect_indirect_reduce(H5HF_hdr_t *hdr, H5HF_free_section_t *sect, unsigned
 
     /* Decrement # of sections which depend on this row */
     /* (Must be last as section can be freed) */
-    if (H5HF_sect_indirect_decr(sect) < 0)
+    if (H5HF__sect_indirect_decr(sect) < 0)
         HGOTO_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL, "can't decrement section's ref. count ")
 
 done:
@@ -3315,7 +3291,7 @@ done:
         /* Sanity check - we should only be here if an error occurred */
         HDassert(ret_value < 0);
 
-        if (H5HF_sect_indirect_free(peer_sect) < 0)
+        if (H5HF__sect_indirect_free(peer_sect) < 0)
             HDONE_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL, "can't free indirect section node")
     } /* end if */
 
@@ -3323,24 +3299,23 @@ done:
 } /* end H5HF__sect_indirect_reduce() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5HF_sect_indirect_is_first
+ * Function:	H5HF__sect_indirect_is_first
  *
  * Purpose:	Check if indirect section is first in all parents
  *
  * Return:	Non-negative (TRUE/FALSE) on success/<can't fail>
  *
  * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
  *		July 17 2006
  *
  *-------------------------------------------------------------------------
  */
 static hbool_t
-H5HF_sect_indirect_is_first(H5HF_free_section_t *sect)
+H5HF__sect_indirect_is_first(H5HF_free_section_t *sect)
 {
     hbool_t ret_value = FALSE; /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
     /* Sanity check */
     HDassert(sect);
@@ -3348,13 +3323,13 @@ H5HF_sect_indirect_is_first(H5HF_free_section_t *sect)
     /* Recurse to parent */
     if (sect->u.indirect.parent) {
         if (sect->sect_info.addr == sect->u.indirect.parent->sect_info.addr)
-            ret_value = H5HF_sect_indirect_is_first(sect->u.indirect.parent);
+            ret_value = H5HF__sect_indirect_is_first(sect->u.indirect.parent);
     } /* end if */
     else
         ret_value = TRUE;
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5HF_sect_indirect_is_first() */
+} /* end H5HF__sect_indirect_is_first() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5HF__sect_indirect_first
@@ -3364,7 +3339,6 @@ H5HF_sect_indirect_is_first(H5HF_free_section_t *sect)
  * Return:	Non-negative on success/Negative on failure
  *
  * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
  *		July 10 2006
  *
  *-------------------------------------------------------------------------
@@ -3408,22 +3382,21 @@ done:
 } /* end H5HF__sect_indirect_first() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5HF_sect_indirect_get_iblock
+ * Function:	H5HF__sect_indirect_get_iblock
  *
  * Purpose:	Retrieve the indirect block for a indirect section
  *
  * Return:	Pointer to indirect block on success/NULL on failure
  *
  * Programmer:	Quincey Koziol
- *		koziol@ncsa.uiuc.edu
  *		July  9 2006
  *
  *-------------------------------------------------------------------------
  */
 static H5HF_indirect_t *
-H5HF_sect_indirect_get_iblock(H5HF_free_section_t *sect)
+H5HF__sect_indirect_get_iblock(H5HF_free_section_t *sect)
 {
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
     /*
      * Check arguments.
@@ -3433,7 +3406,7 @@ H5HF_sect_indirect_get_iblock(H5HF_free_section_t *sect)
     HDassert(sect->sect_info.state == H5FS_SECT_LIVE);
 
     FUNC_LEAVE_NOAPI(sect->u.indirect.u.iblock)
-} /* end H5HF_sect_indirect_get_iblock() */
+} /* end H5HF__sect_indirect_get_iblock() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5HF__sect_indirect_merge_row
@@ -3475,9 +3448,9 @@ H5HF__sect_indirect_merge_row(H5HF_hdr_t *hdr, H5HF_free_section_t *row_sect1, H
     HDassert(row_sect2->sect_info.type == H5HF_FSPACE_SECT_FIRST_ROW);
 
     /* Set up indirect section information */
-    sect1 = H5HF_sect_indirect_top(row_sect1->u.row.under);
+    sect1 = H5HF__sect_indirect_top(row_sect1->u.row.under);
     HDassert(sect1);
-    sect2 = H5HF_sect_indirect_top(row_sect2->u.row.under);
+    sect2 = H5HF__sect_indirect_top(row_sect2->u.row.under);
     HDassert(sect2);
 
     /* Sanity check some assumptions about the indirect sections */
@@ -3653,12 +3626,12 @@ H5HF__sect_indirect_merge_row(H5HF_hdr_t *hdr, H5HF_free_section_t *row_sect1, H
         /* Decrement ref. count on second indirect section's parent */
         HDassert(sect2->u.indirect.rc == 0);
         if (sect2->u.indirect.parent)
-            if (H5HF_sect_indirect_decr(sect2->u.indirect.parent) < 0)
+            if (H5HF__sect_indirect_decr(sect2->u.indirect.parent) < 0)
                 HGOTO_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL,
                             "can't decrement ref. count on parent indirect section")
 
         /* Free second indirect section */
-        if (H5HF_sect_indirect_free(sect2) < 0)
+        if (H5HF__sect_indirect_free(sect2) < 0)
             HGOTO_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL, "can't free indirect section node")
 
         /* Re-add the second section's first row */
@@ -3737,8 +3710,8 @@ H5HF__sect_indirect_build_parent(H5HF_hdr_t *hdr, H5HF_free_section_t *sect)
     HDassert(par_row >= hdr->man_dtable.max_direct_rows);
 
     /* Create parent indirect section */
-    if (NULL == (par_sect = H5HF_sect_indirect_new(hdr, sect->sect_info.addr, sect->sect_info.size,
-                                                   par_iblock, par_block_off, par_row, par_col, 1)))
+    if (NULL == (par_sect = H5HF__sect_indirect_new(hdr, sect->sect_info.addr, sect->sect_info.size,
+                                                    par_iblock, par_block_off, par_row, par_col, 1)))
         HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "can't create indirect section")
 
     /* No rows of direct blocks covered in parent, reset direct row information */
@@ -3759,7 +3732,7 @@ H5HF__sect_indirect_build_parent(H5HF_hdr_t *hdr, H5HF_free_section_t *sect)
 
 done:
     if (ret_value < 0)
-        if (par_sect && H5HF_sect_indirect_free(par_sect) < 0)
+        if (par_sect && H5HF__sect_indirect_free(par_sect) < 0)
             HDONE_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL, "can't free indirect section node")
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -3813,7 +3786,7 @@ H5HF__sect_indirect_shrink(H5HF_hdr_t *hdr, H5HF_free_section_t *sect)
             HGOTO_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL, "can't free child section node")
 
     /* Free the indirect section itself */
-    if (H5HF_sect_indirect_free(sect) < 0)
+    if (H5HF__sect_indirect_free(sect) < 0)
         HGOTO_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL, "can't free indirect section node")
 
 done:
@@ -3821,7 +3794,7 @@ done:
 } /* end H5HF__sect_indirect_shrink() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5HF_sect_indirect_serialize
+ * Function:	H5HF__sect_indirect_serialize
  *
  * Purpose:	Serialize a "live" indirect section into a buffer
  *
@@ -3835,11 +3808,11 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5HF_sect_indirect_serialize(H5HF_hdr_t *hdr, const H5HF_free_section_t *sect, uint8_t *buf)
+H5HF__sect_indirect_serialize(H5HF_hdr_t *hdr, const H5HF_free_section_t *sect, uint8_t *buf)
 {
     herr_t ret_value = SUCCEED; /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     /* Check arguments. */
     HDassert(hdr);
@@ -3849,7 +3822,7 @@ H5HF_sect_indirect_serialize(H5HF_hdr_t *hdr, const H5HF_free_section_t *sect, u
     /* Check if this indirect section has a parent & forward if this section is first */
     if (sect->u.indirect.parent) {
         if (sect->sect_info.addr == sect->u.indirect.parent->sect_info.addr)
-            if (H5HF_sect_indirect_serialize(hdr, sect->u.indirect.parent, buf) < 0)
+            if (H5HF__sect_indirect_serialize(hdr, sect->u.indirect.parent, buf) < 0)
                 HGOTO_ERROR(H5E_HEAP, H5E_CANTSERIALIZE, FAIL,
                             "can't serialize indirect section's parent indirect section")
     } /* end if */
@@ -3874,7 +3847,7 @@ H5HF_sect_indirect_serialize(H5HF_hdr_t *hdr, const H5HF_free_section_t *sect, u
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* H5HF_sect_indirect_serialize() */
+} /* H5HF__sect_indirect_serialize() */
 
 /*-------------------------------------------------------------------------
  * Function:	H5HF__sect_indirect_deserialize
@@ -3925,8 +3898,8 @@ H5HF__sect_indirect_deserialize(H5HF_hdr_t *hdr, const uint8_t *buf, haddr_t sec
     UINT16DECODE(buf, nentries);
 
     /* Create free space section node */
-    if (NULL == (new_sect = H5HF_sect_indirect_new(hdr, sect_addr, sect_size, NULL, iblock_off, start_row,
-                                                   start_col, nentries)))
+    if (NULL == (new_sect = H5HF__sect_indirect_new(hdr, sect_addr, sect_size, NULL, iblock_off, start_row,
+                                                    start_col, nentries)))
         HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, NULL, "can't create indirect section")
 
     /* Compute start entry */
@@ -3954,7 +3927,7 @@ done:
 } /* H5HF__sect_indirect_deserialize() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5HF_sect_indirect_free
+ * Function:	H5HF__sect_indirect_free
  *
  * Purpose:	Free a 'indirect' section node
  *
@@ -3968,12 +3941,12 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5HF_sect_indirect_free(H5HF_free_section_t *sect)
+H5HF__sect_indirect_free(H5HF_free_section_t *sect)
 {
     H5HF_indirect_t *iblock    = NULL;    /* Indirect block for section */
     herr_t           ret_value = SUCCEED; /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
     HDassert(sect);
 
@@ -3984,22 +3957,21 @@ H5HF_sect_indirect_free(H5HF_free_section_t *sect)
     sect->u.indirect.indir_ents = (H5HF_free_section_t **)H5MM_xfree(sect->u.indirect.indir_ents);
 
     /* Check for live reference to an indirect block */
-    if (sect->sect_info.state == H5FS_SECT_LIVE) {
+    if (sect->sect_info.state == H5FS_SECT_LIVE)
         /* Get indirect block, if there was one */
         if (sect->u.indirect.u.iblock)
             iblock = sect->u.indirect.u.iblock;
-    } /* end if */
 
     /* Release the sections */
-    if (H5HF_sect_node_free(sect, iblock) < 0)
+    if (H5HF__sect_node_free(sect, iblock) < 0)
         HGOTO_ERROR(H5E_HEAP, H5E_CANTRELEASE, FAIL, "can't free section node")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* H5HF_sect_indirect_free() */
+} /* H5HF__sect_indirect_free() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5HF_sect_indirect_valid
+ * Function:	H5HF__sect_indirect_valid
  *
  * Purpose:	Check the validity of a section
  *
@@ -4012,7 +3984,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5HF_sect_indirect_valid(const H5HF_hdr_t *hdr, const H5HF_free_section_t *sect)
+H5HF__sect_indirect_valid(const H5HF_hdr_t *hdr, const H5HF_free_section_t *sect)
 {
     unsigned start_row;   /* Row for first block covered */
     unsigned start_col;   /* Column for first block covered */
@@ -4021,7 +3993,7 @@ H5HF_sect_indirect_valid(const H5HF_hdr_t *hdr, const H5HF_free_section_t *sect)
     unsigned end_entry;   /* Entry for last block covered */
     unsigned u;           /* Local index variable */
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
     /* Sanity check arguments */
     HDassert(hdr);
@@ -4094,15 +4066,15 @@ H5HF_sect_indirect_valid(const H5HF_hdr_t *hdr, const H5HF_free_section_t *sect)
             } /* end if */
 
             /* Recursively check child indirect section */
-            H5HF_sect_indirect_valid(hdr, tmp_child_sect);
+            H5HF__sect_indirect_valid(hdr, tmp_child_sect);
         } /* end for */
     }     /* end if */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* H5HF_sect_indirect_valid() */
+} /* H5HF__sect_indirect_valid() */
 
 /*-------------------------------------------------------------------------
- * Function:	H5HF_sect_indirect_debug
+ * Function:	H5HF__sect_indirect_debug
  *
  * Purpose:	Dump debugging information about an indirect free space section
  *
@@ -4116,9 +4088,9 @@ H5HF_sect_indirect_valid(const H5HF_hdr_t *hdr, const H5HF_free_section_t *sect)
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5HF_sect_indirect_debug(const H5HF_free_section_t *sect, FILE *stream, int indent, int fwidth)
+H5HF__sect_indirect_debug(const H5HF_free_section_t *sect, FILE *stream, int indent, int fwidth)
 {
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
     /* Check arguments. */
     HDassert(sect);
@@ -4129,4 +4101,4 @@ H5HF_sect_indirect_debug(const H5HF_free_section_t *sect, FILE *stream, int inde
     HDfprintf(stream, "%*s%-*s %u\n", indent, "", fwidth, "Number of entries:", sect->u.indirect.num_entries);
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* H5HF_sect_indirect_debug() */
+} /* H5HF__sect_indirect_debug() */