Clean up private / package / static namespace issues (function naming, which

header file, FUNC_ENTER / LEAVE, etc).  Removed remaining personal email
addresses from library source code (still needs cleaned from other directories).
Misc. warning, style, and whitespace cleanup.

1 files changed, 324 insertions, 450 deletions

diff --git a/src/H5FDsplitter.c b/src/H5FDsplitter.c
index 4ed3c4a..18a8735 100644
--- a/src/H5FDsplitter.c
+++ b/src/H5FDsplitter.c
@@ -27,8 +27,6 @@
 #include "H5FLprivate.h"    /* Free Lists               */
 #include "H5Iprivate.h"     /* IDs                      */
 #include "H5MMprivate.h"    /* Memory management        */
-#include "H5FDsec2.h"       /* Generic Functions        */
-#include "H5FDstdio.h"      /* Generic Functions        */
 #include "H5Pprivate.h"     /* Property lists           */
 
 /* The driver identification number, initialized at runtime */
@@ -83,9 +81,8 @@ typedef struct H5FD_splitter_t {
 #define H5FD_SPLITTER_WO_ERROR(file, funcname, errmajor, errminor, ret, mesg) \
 {                                                                             \
     H5FD__splitter_log_error((file), (funcname), (mesg));                     \
-    if (FALSE == (file)->fa.ignore_wo_errs) {                                 \
+    if(FALSE == (file)->fa.ignore_wo_errs)                                    \
         HGOTO_ERROR((errmajor), (errminor), (ret), (mesg))                    \
-    }                                                                         \
 }
 
 #define H5FD_SPLITTER_DEBUG_OP_CALLS 0 /* debugging print toggle; 0 disables */
@@ -93,7 +90,7 @@ typedef struct H5FD_splitter_t {
 #if H5FD_SPLITTER_DEBUG_OP_CALLS
 #define H5FD_SPLITTER_LOG_CALL(name) do { \
     HDprintf("called %s()\n", (name));    \
-    fflush(stdout);                       \
+    HDfflush(stdout);                     \
 } while (0)
 #else
 #define H5FD_SPLITTER_LOG_CALL(name) /* no-op */
@@ -103,73 +100,75 @@ typedef struct H5FD_splitter_t {
 
 /* Print error messages from W/O channel to log file */
 static herr_t H5FD__splitter_log_error(const H5FD_splitter_t *file, const char *atfunc, const char *msg);
-
 static int H5FD__copy_plist(hid_t fapl_id, hid_t *id_out_ptr);
 
 /* Prototypes */
-static herr_t H5FD_splitter_term(void);
-static hsize_t H5FD_splitter_sb_size(H5FD_t *_file);
-static herr_t H5FD_splitter_sb_encode(H5FD_t *_file, char *name/*out*/, unsigned char *buf/*out*/);
-static herr_t H5FD_splitter_sb_decode(H5FD_t *_file, const char *name, const unsigned char *buf);
-static void *H5FD_splitter_fapl_get(H5FD_t *_file);
-static void *H5FD_splitter_fapl_copy(const void *_old_fa);
-static herr_t H5FD_splitter_fapl_free(void *_fapl);
-static H5FD_t *H5FD_splitter_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr);
-static herr_t H5FD_splitter_close(H5FD_t *_file);
-static int H5FD_splitter_cmp(const H5FD_t *_f1, const H5FD_t *_f2);
-static herr_t H5FD_splitter_query(const H5FD_t *_file, unsigned long *flags /* out */);
-static herr_t H5FD_splitter_get_type_map(const H5FD_t *_file, H5FD_mem_t *type_map);
-static haddr_t H5FD_splitter_alloc(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, hsize_t size);
-static herr_t H5FD_splitter_free(H5FD_t *_file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, hsize_t size);
-static haddr_t H5FD_splitter_get_eoa(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type);
-static herr_t H5FD_splitter_set_eoa(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type, haddr_t addr);
-static haddr_t H5FD_splitter_get_eof(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type);
-static herr_t  H5FD_splitter_get_handle(H5FD_t *_file, hid_t H5_ATTR_UNUSED fapl, void** file_handle);
-static herr_t H5FD_splitter_read(H5FD_t *_file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, size_t size, void *buf);
-static herr_t H5FD_splitter_write(H5FD_t *_file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, size_t size, const void *buf);
-static herr_t H5FD_splitter_flush(H5FD_t *_file, hid_t dxpl_id, hbool_t closing);
-static herr_t H5FD_splitter_truncate(H5FD_t *_file, hid_t dxpl_id, hbool_t closing);
-static herr_t H5FD_splitter_lock(H5FD_t *_file, hbool_t rw);
-static herr_t H5FD_splitter_unlock(H5FD_t *_file);
+static herr_t H5FD__splitter_term(void);
+static hsize_t H5FD__splitter_sb_size(H5FD_t *_file);
+static herr_t H5FD__splitter_sb_encode(H5FD_t *_file, char *name/*out*/, unsigned char *buf/*out*/);
+static herr_t H5FD__splitter_sb_decode(H5FD_t *_file, const char *name, const unsigned char *buf);
+static void *H5FD__splitter_fapl_get(H5FD_t *_file);
+static void *H5FD__splitter_fapl_copy(const void *_old_fa);
+static herr_t H5FD__splitter_fapl_free(void *_fapl);
+static H5FD_t *H5FD__splitter_open(const char *name, unsigned flags, hid_t fapl_id, haddr_t maxaddr);
+static herr_t H5FD__splitter_close(H5FD_t *_file);
+static int H5FD__splitter_cmp(const H5FD_t *_f1, const H5FD_t *_f2);
+static herr_t H5FD__splitter_query(const H5FD_t *_file, unsigned long *flags /* out */);
+static herr_t H5FD__splitter_get_type_map(const H5FD_t *_file, H5FD_mem_t *type_map);
+static haddr_t H5FD__splitter_alloc(H5FD_t *file, H5FD_mem_t type, hid_t dxpl_id, hsize_t size);
+static herr_t H5FD__splitter_free(H5FD_t *_file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, hsize_t size);
+static haddr_t H5FD__splitter_get_eoa(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type);
+static herr_t H5FD__splitter_set_eoa(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type, haddr_t addr);
+static haddr_t H5FD__splitter_get_eof(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type);
+static herr_t H5FD__splitter_get_handle(H5FD_t *_file, hid_t H5_ATTR_UNUSED fapl, void** file_handle);
+static herr_t H5FD__splitter_read(H5FD_t *_file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, size_t size, void *buf);
+static herr_t H5FD__splitter_write(H5FD_t *_file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, size_t size, const void *buf);
+static herr_t H5FD__splitter_flush(H5FD_t *_file, hid_t dxpl_id, hbool_t closing);
+static herr_t H5FD__splitter_truncate(H5FD_t *_file, hid_t dxpl_id, hbool_t closing);
+static herr_t H5FD__splitter_lock(H5FD_t *_file, hbool_t rw);
+static herr_t H5FD__splitter_unlock(H5FD_t *_file);
 
 static const H5FD_class_t H5FD_splitter_g = {
     "splitter",                 /* name                 */
     MAXADDR,                    /* maxaddr              */
     H5F_CLOSE_WEAK,             /* fc_degree            */
-    H5FD_splitter_term,         /* terminate            */
-    H5FD_splitter_sb_size,      /* sb_size              */
-    H5FD_splitter_sb_encode,    /* sb_encode            */
-    H5FD_splitter_sb_decode,    /* sb_decode            */
+    H5FD__splitter_term,        /* terminate            */
+    H5FD__splitter_sb_size,     /* sb_size              */
+    H5FD__splitter_sb_encode,   /* sb_encode            */
+    H5FD__splitter_sb_decode,   /* sb_decode            */
     sizeof(H5FD_splitter_fapl_t), /* fapl_size          */
-    H5FD_splitter_fapl_get,     /* fapl_get             */
-    H5FD_splitter_fapl_copy,    /* fapl_copy            */
-    H5FD_splitter_fapl_free,    /* fapl_free            */
+    H5FD__splitter_fapl_get,    /* fapl_get             */
+    H5FD__splitter_fapl_copy,   /* fapl_copy            */
+    H5FD__splitter_fapl_free,   /* fapl_free            */
     0,                          /* dxpl_size            */
     NULL,                       /* dxpl_copy            */
     NULL,                       /* dxpl_free            */
-    H5FD_splitter_open,         /* open                 */
-    H5FD_splitter_close,        /* close                */
-    H5FD_splitter_cmp,          /* cmp                  */
-    H5FD_splitter_query,        /* query                */
-    H5FD_splitter_get_type_map, /* get_type_map         */
-    H5FD_splitter_alloc,        /* alloc                */
-    H5FD_splitter_free,         /* free                 */
-    H5FD_splitter_get_eoa,      /* get_eoa              */
-    H5FD_splitter_set_eoa,      /* set_eoa              */
-    H5FD_splitter_get_eof,      /* get_eof              */
-    H5FD_splitter_get_handle,   /* get_handle           */
-    H5FD_splitter_read,         /* read                 */
-    H5FD_splitter_write,        /* write                */
-    H5FD_splitter_flush,        /* flush                */
-    H5FD_splitter_truncate,     /* truncate             */
-    H5FD_splitter_lock,         /* lock                 */
-    H5FD_splitter_unlock,       /* unlock               */
+    H5FD__splitter_open,        /* open                 */
+    H5FD__splitter_close,       /* close                */
+    H5FD__splitter_cmp,         /* cmp                  */
+    H5FD__splitter_query,       /* query                */
+    H5FD__splitter_get_type_map, /* get_type_map        */
+    H5FD__splitter_alloc,       /* alloc                */
+    H5FD__splitter_free,        /* free                 */
+    H5FD__splitter_get_eoa,     /* get_eoa              */
+    H5FD__splitter_set_eoa,     /* set_eoa              */
+    H5FD__splitter_get_eof,     /* get_eof              */
+    H5FD__splitter_get_handle,  /* get_handle           */
+    H5FD__splitter_read,        /* read                 */
+    H5FD__splitter_write,       /* write                */
+    H5FD__splitter_flush,       /* flush                */
+    H5FD__splitter_truncate,    /* truncate             */
+    H5FD__splitter_lock,        /* lock                 */
+    H5FD__splitter_unlock,      /* unlock               */
     H5FD_FLMAP_DICHOTOMY        /* fl_map               */
 };
 
 /* Declare a free list to manage the H5FD_splitter_t struct */
 H5FL_DEFINE_STATIC(H5FD_splitter_t);
 
+/* Declare a free list to manage the H5FD_splitter_fapl_t struct */
+H5FL_DEFINE_STATIC(H5FD_splitter_fapl_t);
+
 
 /*-------------------------------------------------------------------------
  * Function:    H5FD__init_package
@@ -186,11 +185,10 @@ H5FD__init_package(void)
 
     FUNC_ENTER_STATIC
 
-    H5FD_SPLITTER_LOG_CALL("H5FD__init_package");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
-    if (H5FD_splitter_init() < 0) {
+    if(H5FD_splitter_init() < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, FAIL, "unable to initialize splitter VFD")
-    }
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -214,11 +212,10 @@ H5FD_splitter_init(void)
 
     FUNC_ENTER_NOAPI(FAIL)
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_init");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
-    if (H5I_VFL != H5I_get_type(H5FD_SPLITTER_g)) {
+    if(H5I_VFL != H5I_get_type(H5FD_SPLITTER_g))
         H5FD_SPLITTER_g = H5FDregister(&H5FD_splitter_g);
-    }
 
     ret_value = H5FD_SPLITTER_g;
 
@@ -228,7 +225,7 @@ done:
 
 
 /*---------------------------------------------------------------------------
- * Function:    H5FD_splitter_term
+ * Function:    H5FD__splitter_term
  *
  * Purpose:     Shut down the splitter VFD.
  *
@@ -236,17 +233,17 @@ done:
  *---------------------------------------------------------------------------
  */
 static herr_t
-H5FD_splitter_term(void)
+H5FD__splitter_term(void)
 {
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_term");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
     /* Reset VFL ID */
     H5FD_SPLITTER_g = 0;
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5FD_splitter_term() */
+} /* end H5FD__splitter_term() */
 
 
  /*-------------------------------------------------------------------------
@@ -265,25 +262,22 @@ H5FD__copy_plist(hid_t   fapl_id,
     int                 ret_value = 0;
     H5P_genplist_t     *plist_ptr = NULL;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    H5FD_SPLITTER_LOG_CALL("H5FD__copy_plist");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
     HDassert(id_out_ptr != NULL);
 
-    if (FALSE == H5P_isa_class(fapl_id, H5P_FILE_ACCESS)) {
+    if(FALSE == H5P_isa_class(fapl_id, H5P_FILE_ACCESS))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, -1, "not a file access property list");
-    }
 
     plist_ptr = (H5P_genplist_t *)H5I_object(fapl_id);
-    if (NULL == plist_ptr) {
+    if(NULL == plist_ptr)
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, -1, "unable to get property list");
-    }
 
     *id_out_ptr = H5P_copy_plist(plist_ptr, FALSE);
-    if (H5I_INVALID_HID == *id_out_ptr) {
+    if(H5I_INVALID_HID == *id_out_ptr)
         HGOTO_ERROR(H5E_VFL, H5E_BADTYPE, -1, "unable to copy file access property list");
-    }
 
 done:
     FUNC_LEAVE_NOAPI(ret_value);
@@ -302,28 +296,21 @@ done:
 herr_t
 H5Pset_fapl_splitter(hid_t fapl_id, H5FD_splitter_vfd_config_t *vfd_config)
 {
-    H5FD_splitter_fapl_t  info;
+    H5FD_splitter_fapl_t *info = NULL;
     H5P_genplist_t       *plist_ptr = NULL;
     herr_t                ret_value = SUCCEED;
 
-    H5Eclear2(H5E_DEFAULT);
-
     FUNC_ENTER_API(FAIL)
     H5TRACE2("e", "i*Dr", fapl_id, vfd_config);
 
-    H5FD_SPLITTER_LOG_CALL("H5Pset_fapl_splitter");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
-    if (H5FD_SPLITTER_MAGIC != vfd_config->magic) {
+    if(H5FD_SPLITTER_MAGIC != vfd_config->magic)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid configuration (magic number mismatch)")
-    }
-    if (H5FD_CURR_SPLITTER_VFD_CONFIG_VERSION != vfd_config->version) {
-        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invlaid config (version number mismatch)")
-    }
-
-    if (NULL == (plist_ptr = (H5P_genplist_t *)H5I_object(fapl_id))) {
+    if(H5FD_CURR_SPLITTER_VFD_CONFIG_VERSION != vfd_config->version)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid config (version number mismatch)")
+    if(NULL == (plist_ptr = (H5P_genplist_t *)H5I_object(fapl_id)))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a valid property list")
-    }
-
 
     /* Make sure that the W/O channel supports write-only capability.
      * Some drivers (e.g. family or multi) do revision of the superblock
@@ -331,55 +318,54 @@ H5Pset_fapl_splitter(hid_t fapl_id, H5FD_splitter_vfd_config_t *vfd_config)
      * Uses the feature flag H5FD_FEAT_DEFAULT_VFD_COMPATIBLE as the
      * determining attribute.
      */
-    if (H5P_DEFAULT != vfd_config->wo_fapl_id) {
+    if(H5P_DEFAULT != vfd_config->wo_fapl_id) {
         H5FD_class_t       *wo_driver = NULL;
         H5FD_driver_prop_t  wo_driver_prop;
         H5P_genplist_t     *wo_plist_ptr = NULL;
         unsigned long       wo_driver_flags = 0;
 
         wo_plist_ptr = (H5P_genplist_t *)H5I_object(vfd_config->wo_fapl_id);
-        if (NULL == wo_plist_ptr) {
+        if(NULL == wo_plist_ptr)
             HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file access property list")
-        }
-        if (H5P_peek(wo_plist_ptr, H5F_ACS_FILE_DRV_NAME, &wo_driver_prop) < 0) {
+        if(H5P_peek(wo_plist_ptr, H5F_ACS_FILE_DRV_NAME, &wo_driver_prop) < 0)
             HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, FAIL, "can't get driver ID & info")
-        }
         wo_driver = (H5FD_class_t *)H5I_object(wo_driver_prop.driver_id);
-        if (NULL == wo_driver) {
+        if(NULL == wo_driver)
             HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "invalid driver ID in file access property list")
-        }
-        if (H5FD_driver_query(wo_driver, &wo_driver_flags) < 0) {
+        if(H5FD_driver_query(wo_driver, &wo_driver_flags) < 0)
             HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "can't query VFD flags")
-        }
-        if (0 == (H5FD_FEAT_DEFAULT_VFD_COMPATIBLE & wo_driver_flags)) {
+        if(0 == (H5FD_FEAT_DEFAULT_VFD_COMPATIBLE & wo_driver_flags))
             HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "unsuitable W/O driver")
-        }
     } /* end if W/O VFD is non-default */
 
+    info = H5FL_CALLOC(H5FD_splitter_fapl_t);
+    if(NULL == info)
+        HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, FAIL, "unable to allocate file access property list struct")
 
-    info.ignore_wo_errs = vfd_config->ignore_wo_errs;
-    HDstrncpy(info.wo_path, vfd_config->wo_path, H5FD_SPLITTER_PATH_MAX);
-    HDstrncpy(info.log_file_path, vfd_config->log_file_path, H5FD_SPLITTER_PATH_MAX);
-    info.rw_fapl_id = H5P_FILE_ACCESS_DEFAULT; /* pre-set value */
-    info.wo_fapl_id = H5P_FILE_ACCESS_DEFAULT; /* pre-set value */
+    info->ignore_wo_errs = vfd_config->ignore_wo_errs;
+    HDstrncpy(info->wo_path, vfd_config->wo_path, H5FD_SPLITTER_PATH_MAX);
+    HDstrncpy(info->log_file_path, vfd_config->log_file_path, H5FD_SPLITTER_PATH_MAX);
+    info->rw_fapl_id = H5P_FILE_ACCESS_DEFAULT; /* pre-set value */
+    info->wo_fapl_id = H5P_FILE_ACCESS_DEFAULT; /* pre-set value */
 
     /* Set non-default channel FAPL IDs in splitter configuration info */
-    if (H5P_DEFAULT != vfd_config->rw_fapl_id) {
-        if (FALSE == H5P_isa_class(vfd_config->rw_fapl_id, H5P_FILE_ACCESS)) {
+    if(H5P_DEFAULT != vfd_config->rw_fapl_id) {
+        if(FALSE == H5P_isa_class(vfd_config->rw_fapl_id, H5P_FILE_ACCESS))
             HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file access list")
-        }
-        info.rw_fapl_id = vfd_config->rw_fapl_id;
+        info->rw_fapl_id = vfd_config->rw_fapl_id;
     }
-    if (H5P_DEFAULT != vfd_config->wo_fapl_id) {
-        if (FALSE == H5P_isa_class(vfd_config->wo_fapl_id, H5P_FILE_ACCESS)) {
+    if(H5P_DEFAULT != vfd_config->wo_fapl_id) {
+        if(FALSE == H5P_isa_class(vfd_config->wo_fapl_id, H5P_FILE_ACCESS))
             HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file access list")
-        }
-        info.wo_fapl_id = vfd_config->wo_fapl_id;
+        info->wo_fapl_id = vfd_config->wo_fapl_id;
     }
 
-    ret_value = H5P_set_driver(plist_ptr, H5FD_SPLITTER, &info);
+    ret_value = H5P_set_driver(plist_ptr, H5FD_SPLITTER, info);
 
 done:
+    if(info)
+        info = H5FL_FREE(H5FD_splitter_fapl_t, info);
+
     FUNC_LEAVE_API(ret_value)
 } /* end H5Pset_fapl_splitter() */
 
@@ -406,48 +392,39 @@ H5Pget_fapl_splitter(hid_t fapl_id, H5FD_splitter_vfd_config_t *config_out)
     FUNC_ENTER_API(FAIL)
     H5TRACE2("e", "i*Dr", fapl_id, config_out);
 
-    H5FD_SPLITTER_LOG_CALL("H5Pget_fapl_splitter");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
     /* Check arguments */
-    if (TRUE != H5P_isa_class(fapl_id, H5P_FILE_ACCESS)) {
+    if(TRUE != H5P_isa_class(fapl_id, H5P_FILE_ACCESS))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file access property list")
-    }
-    if (config_out == NULL) {
+    if(config_out == NULL)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "config_out pointer is null")
-    }
-    if (H5FD_SPLITTER_MAGIC != config_out->magic) {
+    if(H5FD_SPLITTER_MAGIC != config_out->magic)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "info-out pointer invalid (magic number mismatch)")
-    }
-    if (H5FD_CURR_SPLITTER_VFD_CONFIG_VERSION != config_out->version) {
+    if(H5FD_CURR_SPLITTER_VFD_CONFIG_VERSION != config_out->version)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "info-out pointer invalid (version unsafe)")
-    }
 
     /* Pre-set out FAPL IDs with intent to replace these values */
     config_out->rw_fapl_id = H5I_INVALID_HID;
     config_out->wo_fapl_id = H5I_INVALID_HID;
 
     /* Check and get the splitter fapl */
-    if (NULL == (plist_ptr = H5P_object_verify(fapl_id, H5P_FILE_ACCESS))) {
+    if(NULL == (plist_ptr = H5P_object_verify(fapl_id, H5P_FILE_ACCESS)))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file access property list")
-    }
-    if (H5FD_SPLITTER != H5P_peek_driver(plist_ptr)) {
+    if(H5FD_SPLITTER != H5P_peek_driver(plist_ptr))
         HGOTO_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "incorrect VFL driver")
-    }
-    if (NULL == (fapl_ptr = (const H5FD_splitter_fapl_t *)H5P_peek_driver_info(plist_ptr))) {
+    if(NULL == (fapl_ptr = (const H5FD_splitter_fapl_t *)H5P_peek_driver_info(plist_ptr)))
         HGOTO_ERROR(H5E_PLIST, H5E_BADVALUE, FAIL, "unable to get specific-driver info")
-    }
 
     HDstrncpy(config_out->wo_path, fapl_ptr->wo_path, H5FD_SPLITTER_PATH_MAX);
     HDstrncpy(config_out->log_file_path, fapl_ptr->log_file_path, H5FD_SPLITTER_PATH_MAX);
     config_out->ignore_wo_errs = fapl_ptr->ignore_wo_errs;
 
     /* Copy R/W and W/O FAPLs */
-    if (H5FD__copy_plist(fapl_ptr->rw_fapl_id, &(config_out->rw_fapl_id)) < 0) {
+    if(H5FD__copy_plist(fapl_ptr->rw_fapl_id, &(config_out->rw_fapl_id)) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "can't copy R/W FAPL");
-    }
-    if (H5FD__copy_plist(fapl_ptr->wo_fapl_id, &(config_out->wo_fapl_id)) < 0) {
+    if(H5FD__copy_plist(fapl_ptr->wo_fapl_id, &(config_out->wo_fapl_id)) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, FAIL, "can't copy W/O FAPL");
-    }
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -455,7 +432,7 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_splitter_flush
+ * Function:    H5FD__splitter_flush
  *
  * Purpose:     Flushes all data to disk for both channels.
  *
@@ -463,32 +440,28 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_splitter_flush(H5FD_t *_file, hid_t H5_ATTR_UNUSED dxpl_id, hbool_t closing)
+H5FD__splitter_flush(H5FD_t *_file, hid_t H5_ATTR_UNUSED dxpl_id, hbool_t closing)
 {
     H5FD_splitter_t *file = (H5FD_splitter_t *)_file;
     herr_t      ret_value = SUCCEED;       /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_flush");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
     /* Public API for dxpl "context" */
-    if (H5FDflush(file->rw_file, dxpl_id, closing) < 0) {
+    if(H5FDflush(file->rw_file, dxpl_id, closing) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTFLUSH, FAIL, "unable to flush R/W file")
-    }
-    if (H5FDflush(file->wo_file, dxpl_id, closing) < 0) {
-       H5FD_SPLITTER_WO_ERROR(file, "H5FD_splitter_flush",
-                              H5E_VFL, H5E_CANTFLUSH, FAIL,
-                              "unable to flush W/O file")
-    }
+    if(H5FDflush(file->wo_file, dxpl_id, closing) < 0)
+       H5FD_SPLITTER_WO_ERROR(file, FUNC, H5E_VFL, H5E_CANTFLUSH, FAIL, "unable to flush W/O file")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_splitter_flush() */
+} /* end H5FD__splitter_flush() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_splitter_read
+ * Function:    H5FD__splitter_read
  *
  * Purpose:     Reads SIZE bytes of data from the R/W channel, beginning at
  *              address ADDR into buffer BUF according to data transfer
@@ -502,45 +475,37 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_splitter_read(
-        H5FD_t     *_file,
-        H5FD_mem_t  H5_ATTR_UNUSED type,
-        hid_t       H5_ATTR_UNUSED dxpl_id,
-        haddr_t     addr,
-        size_t      size,
-        void       *buf /*out*/)
+H5FD__splitter_read(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type,
+    hid_t H5_ATTR_UNUSED dxpl_id, haddr_t addr, size_t size, void *buf)
 {
     H5FD_splitter_t *file       = (H5FD_splitter_t *)_file;
     herr_t          ret_value   = SUCCEED;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_read");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
     HDassert(file && file->pub.cls);
     HDassert(buf);
 
     /* Check for overflow conditions */
-    if (!H5F_addr_defined(addr)) {
+    if(!H5F_addr_defined(addr))
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "addr undefined, addr = %llu", (unsigned long long)addr)
-    }
-    if (REGION_OVERFLOW(addr, size)) {
+    if(REGION_OVERFLOW(addr, size))
         HGOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, FAIL, "addr overflow, addr = %llu", (unsigned long long)addr)
-    }
 
     /* Only read from R/W channel */
     /* Public API for dxpl "context" */
-    if (H5FDread(file->rw_file, type, dxpl_id, addr, size, buf) < 0) {
+    if(H5FDread(file->rw_file, type, dxpl_id, addr, size, buf) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_READERROR, FAIL, "Reading from R/W channel failed")
-    }
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_splitter_read() */
+} /* end H5FD__splitter_read() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_splitter_write
+ * Function:    H5FD__splitter_write
  *
  * Purpose:     Writes SIZE bytes of data to R/W and W/O channels, beginning
  *              at address ADDR from buffer BUF according to data transfer
@@ -550,38 +515,34 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_splitter_write(H5FD_t *_file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, size_t size, const void *buf)
+H5FD__splitter_write(H5FD_t *_file, H5FD_mem_t type, hid_t dxpl_id,
+    haddr_t addr, size_t size, const void *buf)
 {
     H5FD_splitter_t *file      = (H5FD_splitter_t *)_file;
     H5P_genplist_t  *plist_ptr     = NULL;
     herr_t           ret_value = SUCCEED;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_write");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
-    if (NULL == (plist_ptr = (H5P_genplist_t *)H5I_object(dxpl_id))) {
+    if(NULL == (plist_ptr = (H5P_genplist_t *)H5I_object(dxpl_id)))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a property list")
-    }
 
     /* Write to each file */
     /* Public API for dxpl "context" */
-    if (H5FDwrite(file->rw_file, type, dxpl_id, addr, size, buf) < 0) {
+    if(H5FDwrite(file->rw_file, type, dxpl_id, addr, size, buf) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_WRITEERROR, FAIL, "R/W file write failed")
-    }
-    if (H5FDwrite(file->wo_file, type, dxpl_id, addr, size, buf) < 0) {
-       H5FD_SPLITTER_WO_ERROR(file, "H5FD_splitter_write",
-                              H5E_VFL, H5E_WRITEERROR, FAIL,
-                              "unable to write W/O file")
-    }
+    if(H5FDwrite(file->wo_file, type, dxpl_id, addr, size, buf) < 0)
+       H5FD_SPLITTER_WO_ERROR(file, FUNC, H5E_VFL, H5E_WRITEERROR, FAIL, "unable to write W/O file")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_splitter_write() */
+} /* end H5FD__splitter_write() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_splitter_fapl_get
+ * Function:    H5FD__splitter_fapl_get
  *
  * Purpose:     Returns a file access property list which indicates how the
  *              specified file is being accessed. The return list could be
@@ -593,23 +554,23 @@ done:
  *-------------------------------------------------------------------------
  */
 static void *
-H5FD_splitter_fapl_get(H5FD_t *_file)
+H5FD__splitter_fapl_get(H5FD_t *_file)
 {
     H5FD_splitter_t *file      = (H5FD_splitter_t *)_file;
     void            *ret_value = NULL;
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_fapl_get");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
-    ret_value = H5FD_splitter_fapl_copy(&(file->fa));
+    ret_value = H5FD__splitter_fapl_copy(&(file->fa));
 
     FUNC_LEAVE_NOAPI(ret_value)
-}
+} /* end H5FD__splitter_fapl_get() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_splitter_fapl_copy
+ * Function:    H5FD__splitter_fapl_copy
  *
  * Purpose:     Copies the file access properties.
  *
@@ -618,56 +579,45 @@ H5FD_splitter_fapl_get(H5FD_t *_file)
  *-------------------------------------------------------------------------
  */
 static void *
-H5FD_splitter_fapl_copy(const void *_old_fa)
+H5FD__splitter_fapl_copy(const void *_old_fa)
 {
     const H5FD_splitter_fapl_t *old_fa_ptr = (const H5FD_splitter_fapl_t *)_old_fa;
     H5FD_splitter_fapl_t       *new_fa_ptr = NULL;
     void                       *ret_value  = NULL;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_fapl_copy");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
     HDassert(old_fa_ptr);
 
-    new_fa_ptr = (H5FD_splitter_fapl_t *)H5MM_calloc(sizeof(H5FD_splitter_fapl_t));
-    if (NULL == new_fa_ptr) {
+    new_fa_ptr = H5FL_CALLOC(H5FD_splitter_fapl_t);
+    if(NULL == new_fa_ptr)
         HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, NULL, "unable to allocate log file FAPL")
-    }
 
-    if (HDmemcpy(new_fa_ptr, old_fa_ptr, sizeof(H5FD_splitter_fapl_t)) == NULL) {
-        HGOTO_ERROR(H5E_ARGS, H5E_CANTCOPY, NULL, "unable to shallow-copy info")
-    }
-    if (HDstrncpy(new_fa_ptr->wo_path, old_fa_ptr->wo_path, H5FD_SPLITTER_PATH_MAX) == NULL) {
-        HGOTO_ERROR(H5E_ARGS, H5E_CANTCOPY, NULL, "unable to copy write-only channel file path")
-    }
-    if (HDstrncpy(new_fa_ptr->log_file_path, old_fa_ptr->log_file_path, H5FD_SPLITTER_PATH_MAX) == NULL) {
-        HGOTO_ERROR(H5E_ARGS, H5E_CANTCOPY, NULL, "unable to copy log file path")
-    }
+    HDmemcpy(new_fa_ptr, old_fa_ptr, sizeof(H5FD_splitter_fapl_t));
+    HDstrncpy(new_fa_ptr->wo_path, old_fa_ptr->wo_path, H5FD_SPLITTER_PATH_MAX);
+    HDstrncpy(new_fa_ptr->log_file_path, old_fa_ptr->log_file_path, H5FD_SPLITTER_PATH_MAX);
 
     /* Copy R/W and W/O FAPLs */
-    if (H5FD__copy_plist(old_fa_ptr->rw_fapl_id, &(new_fa_ptr->rw_fapl_id)) < 0) {
+    if(H5FD__copy_plist(old_fa_ptr->rw_fapl_id, &(new_fa_ptr->rw_fapl_id)) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, NULL, "can't copy R/W FAPL");
-    }
-    if (H5FD__copy_plist(old_fa_ptr->wo_fapl_id, &(new_fa_ptr->wo_fapl_id)) < 0) {
+    if(H5FD__copy_plist(old_fa_ptr->wo_fapl_id, &(new_fa_ptr->wo_fapl_id)) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, NULL, "can't copy W/O FAPL");
-    }
 
     ret_value = (void *)new_fa_ptr;
 
 done:
-    if (NULL == ret_value) {
-        if (new_fa_ptr) {
-            H5MM_free(new_fa_ptr);
-        }
-    }
+    if(NULL == ret_value)
+        if(new_fa_ptr)
+            new_fa_ptr = H5FL_FREE(H5FD_splitter_fapl_t, new_fa_ptr);
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_splitter_fapl_copy() */
+} /* end H5FD__splitter_fapl_copy() */
 
 
 /*--------------------------------------------------------------------------
- * Function:    H5FD_splitter_fapl_free
+ * Function:    H5FD__splitter_fapl_free
  *
  * Purpose:     Releases the file access lists
  *
@@ -675,35 +625,33 @@ done:
  *--------------------------------------------------------------------------
  */
 static herr_t
-H5FD_splitter_fapl_free(void *_fapl)
+H5FD__splitter_fapl_free(void *_fapl)
 {
     H5FD_splitter_fapl_t *fapl      = (H5FD_splitter_fapl_t*)_fapl;
     herr_t                ret_value = SUCCEED;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_fapl_free");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
     /* Check arguments */
     HDassert(fapl);
 
-    if (H5I_dec_ref(fapl->rw_fapl_id) < 0) {
+    if(H5I_dec_ref(fapl->rw_fapl_id) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTDEC, FAIL, "can't close R/W FAPL ID")
-    }
-    if (H5I_dec_ref(fapl->wo_fapl_id) < 0) {
+    if(H5I_dec_ref(fapl->wo_fapl_id) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTDEC, FAIL, "can't close W/O FAPL ID")
-    }
 
     /* Free the property list */
-    H5MM_free(fapl);
+    fapl = H5FL_FREE(H5FD_splitter_fapl_t, fapl);
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_splitter_fapl_free() */
+} /* end H5FD__splitter_fapl_free() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_splitter_open
+ * Function:    H5FD__splitter_open
  *
  * Purpose:     Create and/or opens a file as an HDF5 file.
  *
@@ -714,123 +662,99 @@ done:
  *-------------------------------------------------------------------------
  */
 static H5FD_t *
-H5FD_splitter_open(const char *name, unsigned flags, hid_t splitter_fapl_id, haddr_t maxaddr)
+H5FD__splitter_open(const char *name, unsigned flags, hid_t splitter_fapl_id, haddr_t maxaddr)
 {
     H5FD_splitter_t            *file_ptr  = NULL; /* Splitter VFD info */
     const H5FD_splitter_fapl_t *fapl_ptr  = NULL; /* Driver-specific property list */
     H5P_genplist_t     *plist_ptr = NULL;
     H5FD_t     *ret_value = NULL;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_open");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
     /* Check arguments */
-    if (!name || !*name) {
+    if(!name || !*name)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "invalid file name")
-    }
-    if (0 == maxaddr || HADDR_UNDEF == maxaddr) {
+    if(0 == maxaddr || HADDR_UNDEF == maxaddr)
         HGOTO_ERROR(H5E_ARGS, H5E_BADRANGE, NULL, "bogus maxaddr")
-    }
-    if (ADDR_OVERFLOW(maxaddr)) {
+    if(ADDR_OVERFLOW(maxaddr))
         HGOTO_ERROR(H5E_ARGS, H5E_OVERFLOW, NULL, "bogus maxaddr")
-    }
-    if ( (H5P_FILE_ACCESS_DEFAULT == splitter_fapl_id) ||
-         (H5FD_SPLITTER != H5Pget_driver(splitter_fapl_id)) )
-    {
+    if((H5P_FILE_ACCESS_DEFAULT == splitter_fapl_id) ||
+            (H5FD_SPLITTER != H5Pget_driver(splitter_fapl_id)) )
         /* presupposes that H5P_FILE_ACCESS_DEFAULT is not a splitter */
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "driver is not splitter")
-    }
 
     file_ptr = (H5FD_splitter_t *)H5FL_CALLOC(H5FD_splitter_t);
-    if (NULL == file_ptr) {
-        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "unable to allocate file struct")
-    }
+    if(NULL == file_ptr)
+        HGOTO_ERROR(H5E_VFL, H5E_CANTALLOC, NULL, "unable to allocate file struct")
     file_ptr->fa.rw_fapl_id = H5I_INVALID_HID;
     file_ptr->fa.wo_fapl_id = H5I_INVALID_HID;
 
     /* Get the driver-specific file access properties */
     plist_ptr = (H5P_genplist_t *)H5I_object(splitter_fapl_id);
-    if (NULL == plist_ptr) {
+    if(NULL == plist_ptr)
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a file access property list")
-    }
     fapl_ptr = (const H5FD_splitter_fapl_t *)H5P_peek_driver_info(plist_ptr);
-    if (NULL == fapl_ptr) {
+    if(NULL == fapl_ptr)
         HGOTO_ERROR(H5E_PLIST, H5E_CANTGET, NULL, "unable to get VFL driver info")
-    }
 
     /* Copy simpler info */
-    if (HDstrncpy(file_ptr->fa.wo_path, fapl_ptr->wo_path, H5FD_SPLITTER_PATH_MAX) == NULL) {
-        HGOTO_ERROR(H5E_VFL, H5E_CANTCOPY, NULL, "unable to copy write-only path")
-    }
-    if (HDstrncpy(file_ptr->fa.log_file_path, fapl_ptr->log_file_path, H5FD_SPLITTER_PATH_MAX) == NULL) {
-        HGOTO_ERROR(H5E_VFL, H5E_CANTCOPY, NULL, "unable to copy logfile path")
-    }
+    HDstrncpy(file_ptr->fa.wo_path, fapl_ptr->wo_path, H5FD_SPLITTER_PATH_MAX);
+    HDstrncpy(file_ptr->fa.log_file_path, fapl_ptr->log_file_path, H5FD_SPLITTER_PATH_MAX);
     file_ptr->fa.ignore_wo_errs = fapl_ptr->ignore_wo_errs;
 
     /* Copy R/W and W/O channel FAPLs. */
-    if (H5FD__copy_plist(fapl_ptr->rw_fapl_id, &(file_ptr->fa.rw_fapl_id)) < 0) {
+    if(H5FD__copy_plist(fapl_ptr->rw_fapl_id, &(file_ptr->fa.rw_fapl_id)) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, NULL, "can't copy R/W FAPL");
-    }
-    if (H5FD__copy_plist(fapl_ptr->wo_fapl_id, &(file_ptr->fa.wo_fapl_id)) < 0) {
+    if(H5FD__copy_plist(fapl_ptr->wo_fapl_id, &(file_ptr->fa.wo_fapl_id)) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, NULL, "can't copy W/O FAPL");
-    }
 
     /* Prepare log file if necessary.
      * If application wants to ignore the errors from W/O channel and
      * provided a name for the log file, then open it
      */
-    if (!file_ptr->logfp) {
-        if (file_ptr->fa.log_file_path[0] != '\0') {
+    if(!file_ptr->logfp) {
+        if(file_ptr->fa.log_file_path[0] != '\0') {
             file_ptr->logfp = HDfopen(file_ptr->fa.log_file_path, "w");
-            if (file_ptr->logfp == NULL) {
+            if(file_ptr->logfp == NULL)
                 HGOTO_ERROR(H5E_VFL, H5E_CANTOPENFILE, NULL, "unable to open log file")
-            }
         } /* end if logfile path given */
     } /* end if logfile pointer/handle does not exist */
 
     file_ptr->rw_file = H5FD_open(name, flags, fapl_ptr->rw_fapl_id, HADDR_UNDEF);
-    if (!file_ptr->rw_file) {
+    if(!file_ptr->rw_file)
         HGOTO_ERROR(H5E_VFL, H5E_CANTOPENFILE, NULL, "unable to open R/W file")
-    }
 
     file_ptr->wo_file = H5FD_open(fapl_ptr->wo_path, flags, fapl_ptr->wo_fapl_id, HADDR_UNDEF);
-    if (!file_ptr->wo_file) {
-       H5FD_SPLITTER_WO_ERROR(file_ptr, "H5FD_splitter_open",
-                              H5E_VFL, H5E_CANTOPENFILE, NULL,
-                              "unable to open W/O file")
-    }
+    if(!file_ptr->wo_file)
+       H5FD_SPLITTER_WO_ERROR(file_ptr, FUNC, H5E_VFL, H5E_CANTOPENFILE, NULL, "unable to open W/O file")
 
     ret_value = (H5FD_t*)file_ptr;
 
 done:
-    if (NULL == ret_value) {
-        if (file_ptr) {
-            if (H5I_INVALID_HID != file_ptr->fa.rw_fapl_id) {
+    if(NULL == ret_value) {
+        if(file_ptr) {
+            if(H5I_INVALID_HID != file_ptr->fa.rw_fapl_id)
                 H5I_dec_ref(file_ptr->fa.rw_fapl_id);
-            }
-            if (H5I_INVALID_HID != file_ptr->fa.wo_fapl_id) {
+            if(H5I_INVALID_HID != file_ptr->fa.wo_fapl_id)
                 H5I_dec_ref(file_ptr->fa.wo_fapl_id);
-            }
-            if (file_ptr->rw_file) {
+            if(file_ptr->rw_file)
                 H5FD_close(file_ptr->rw_file);
-            }
-            if (file_ptr->wo_file) {
+            if(file_ptr->wo_file)
                 H5FD_close(file_ptr->wo_file);
-            }
-            if (file_ptr->logfp) {
+            if(file_ptr->logfp)
                 HDfclose(file_ptr->logfp);
-            }
             H5FL_FREE(H5FD_splitter_t, file_ptr);
         }
     } /* end if error */
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_splitter_open() */
+} /* end H5FD__splitter_open() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_splitter_close
+ * Function:    H5FD__splitter_close
  *
  * Purpose:     Closes files on both read-write and write-only channels.
  *
@@ -839,39 +763,31 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_splitter_close(H5FD_t *_file)
+H5FD__splitter_close(H5FD_t *_file)
 {
     H5FD_splitter_t *file      = (H5FD_splitter_t *)_file;
     herr_t           ret_value = SUCCEED;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_close");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
     /* Sanity check */
     HDassert(file);
 
-    if (H5I_dec_ref(file->fa.rw_fapl_id) < 0) {
+    if(H5I_dec_ref(file->fa.rw_fapl_id) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_ARGS, FAIL, "can't close R/W FAPL")
-    }
-    if (H5I_dec_ref(file->fa.wo_fapl_id) < 0) {
+    if(H5I_dec_ref(file->fa.wo_fapl_id) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_ARGS, FAIL, "can't close W/O FAPL")
-    }
 
-    if (file->rw_file) {
-        if (H5FD_close(file->rw_file) == FAIL) {
+    if(file->rw_file)
+        if(H5FD_close(file->rw_file) == FAIL)
             HGOTO_ERROR(H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "unable to close R/W file")
-        }
-    }
-    if (file->wo_file) {
-        if (H5FD_close(file->wo_file) == FAIL) {
-            H5FD_SPLITTER_WO_ERROR(file, "H5FD_splitter_close",
-                              H5E_VFL, H5E_CANTCLOSEFILE, FAIL,
-                              "unable to close W/O file")
-        }
-    }
+    if(file->wo_file)
+        if(H5FD_close(file->wo_file) == FAIL)
+            H5FD_SPLITTER_WO_ERROR(file, FUNC, H5E_VFL, H5E_CANTCLOSEFILE, FAIL, "unable to close W/O file")
 
-    if (file->logfp) {
+    if(file->logfp) {
         HDfclose(file->logfp);
         file->logfp = NULL;
     }
@@ -882,11 +798,11 @@ H5FD_splitter_close(H5FD_t *_file)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_splitter_close() */
+} /* end H5FD__splitter_close() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_splitter_get_eoa
+ * Function:    H5FD__splitter_get_eoa
  *
  * Purpose:     Returns the end-of-address marker for the file. The EOA
  *              marker is the first address past the last byte allocated in
@@ -898,30 +814,29 @@ done:
  *-------------------------------------------------------------------------
  */
 static haddr_t
-H5FD_splitter_get_eoa(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
+H5FD__splitter_get_eoa(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
 {
     const H5FD_splitter_t *file      = (const H5FD_splitter_t *)_file;
     haddr_t                ret_value = HADDR_UNDEF;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_get_eoa");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
     /* Sanity check */
     HDassert(file);
     HDassert(file->rw_file);
 
-    if ((ret_value = H5FD_get_eoa(file->rw_file, type)) == HADDR_UNDEF) {
+    if((ret_value = H5FD_get_eoa(file->rw_file, type)) == HADDR_UNDEF)
         HGOTO_ERROR(H5E_VFL, H5E_BADVALUE, HADDR_UNDEF, "unable to get eoa")
-    }
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_splitter_get_eoa */
+} /* end H5FD__splitter_get_eoa */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_splitter_set_eoa
+ * Function:    H5FD__splitter_set_eoa
  *
  * Purpose:     Set the end-of-address marker for the file. This function is
  *              called shortly after an existing HDF5 file is opened in order
@@ -931,37 +846,33 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_splitter_set_eoa(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type, haddr_t addr)
+H5FD__splitter_set_eoa(H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type, haddr_t addr)
 {
     H5FD_splitter_t *file = (H5FD_splitter_t *)_file;
     herr_t      ret_value = SUCCEED;                /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_set_eoa";)
+    H5FD_SPLITTER_LOG_CALL(FUNC)
 
     /* Sanity check */
     HDassert(file);
     HDassert(file->rw_file);
     HDassert(file->wo_file);
 
-    if (H5FD_set_eoa(file->rw_file, type, addr) < 0) {
+    if(H5FD_set_eoa(file->rw_file, type, addr) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTSET, FAIL, "H5FDset_eoa failed for R/W file")
-    }
 
-    if (H5FD_set_eoa(file->wo_file, type, addr) < 0) {
-       H5FD_SPLITTER_WO_ERROR(file, "H5FD_splitter_set_eoa",
-                              H5E_VFL, H5E_CANTSET, FAIL,
-                              "unable to set EOA for W/O file")
-    }
+    if(H5FD_set_eoa(file->wo_file, type, addr) < 0)
+       H5FD_SPLITTER_WO_ERROR(file, FUNC, H5E_VFL, H5E_CANTSET, FAIL, "unable to set EOA for W/O file")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_splitter_set_eoa() */
+} /* end H5FD__splitter_set_eoa() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_splitter_get_eof
+ * Function:    H5FD__splitter_get_eof
  *
  * Purpose:     Returns the end-of-address marker for the file. The EOA
  *              marker is the first address past the last byte allocated in
@@ -973,30 +884,29 @@ done:
  *-------------------------------------------------------------------------
  */
 static haddr_t
-H5FD_splitter_get_eof(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
+H5FD__splitter_get_eof(const H5FD_t *_file, H5FD_mem_t H5_ATTR_UNUSED type)
 {
     const H5FD_splitter_t *file = (const H5FD_splitter_t *)_file;
     haddr_t ret_value = HADDR_UNDEF;        /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_get_eof");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
     /* Sanity check */
     HDassert(file);
     HDassert(file->rw_file);
 
-    if (HADDR_UNDEF == (ret_value = H5FD_get_eof(file->rw_file, type))) {
+    if(HADDR_UNDEF == (ret_value = H5FD_get_eof(file->rw_file, type)))
         HGOTO_ERROR(H5E_VFL, H5E_CANTGET, HADDR_UNDEF, "unable to get eof")
-    }
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_splitter_get_eof */
+} /* end H5FD__splitter_get_eof */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_splitter_truncate
+ * Function:    H5FD__splitter_truncate
  *
  * Purpose:     Notify driver to truncate the file back to the allocated size.
  *
@@ -1004,36 +914,32 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_splitter_truncate(H5FD_t *_file, hid_t dxpl_id, hbool_t closing)
+H5FD__splitter_truncate(H5FD_t *_file, hid_t dxpl_id, hbool_t closing)
 {
     H5FD_splitter_t *file = (H5FD_splitter_t *)_file;
     herr_t           ret_value = SUCCEED;       /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_truncate");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
     HDassert(file);
     HDassert(file->rw_file);
     HDassert(file->wo_file);
 
-    if (H5FDtruncate(file->rw_file, dxpl_id, closing) < 0) {
+    if(H5FDtruncate(file->rw_file, dxpl_id, closing) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTUPDATE, FAIL, "unable to truncate R/W file")
-    }
 
-    if (H5FDtruncate(file->wo_file, dxpl_id, closing) < 0) {
-       H5FD_SPLITTER_WO_ERROR(file, "H5FD_splitter_truncate",
-                              H5E_VFL, H5E_CANTUPDATE, FAIL,
-                              "unable to truncate W/O file")
-    }
+    if(H5FDtruncate(file->wo_file, dxpl_id, closing) < 0)
+       H5FD_SPLITTER_WO_ERROR(file, FUNC, H5E_VFL, H5E_CANTUPDATE, FAIL, "unable to truncate W/O file")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_splitter_truncate */
+} /* end H5FD__splitter_truncate */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_splitter_sb_size
+ * Function:    H5FD__splitter_sb_size
  *
  * Purpose:     Obtains the number of bytes required to store the driver file
  *              access data in the HDF5 superblock.
@@ -1047,29 +953,28 @@ done:
  *-------------------------------------------------------------------------
  */
 static hsize_t
-H5FD_splitter_sb_size(H5FD_t *_file)
+H5FD__splitter_sb_size(H5FD_t *_file)
 {
     H5FD_splitter_t *file      = (H5FD_splitter_t *)_file;
     hsize_t          ret_value = 0;
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_sb_size");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
     /* Sanity check */
     HDassert(file);
     HDassert(file->rw_file);
 
-    if (file->rw_file) {
+    if(file->rw_file)
         ret_value = H5FD_sb_size(file->rw_file);
-    }
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_splitter_sb_size */
+} /* end H5FD__splitter_sb_size */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_splitter_sb_encode
+ * Function:    H5FD__splitter_sb_encode
  *
  * Purpose:     Encode driver-specific data into the output arguments.
  *
@@ -1077,30 +982,29 @@ H5FD_splitter_sb_size(H5FD_t *_file)
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_splitter_sb_encode(H5FD_t *_file, char *name/*out*/, unsigned char *buf/*out*/)
+H5FD__splitter_sb_encode(H5FD_t *_file, char *name/*out*/, unsigned char *buf/*out*/)
 {
     H5FD_splitter_t *file = (H5FD_splitter_t *)_file;
     herr_t           ret_value = SUCCEED;       /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_sb_encode");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
     /* Sanity check */
     HDassert(file);
     HDassert(file->rw_file);
 
-    if (file->rw_file && H5FD_sb_encode(file->rw_file, name, buf) < 0) {
+    if(file->rw_file && H5FD_sb_encode(file->rw_file, name, buf) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTENCODE, FAIL, "unable to encode the superblock in R/W file")
-    }
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_splitter_sb_encode */
+} /* end H5FD__splitter_sb_encode */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_splitter_sb_decode
+ * Function:    H5FD__splitter_sb_decode
  *
  * Purpose:     Decodes the driver information block.
  *
@@ -1110,30 +1014,29 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_splitter_sb_decode(H5FD_t *_file, const char *name, const unsigned char *buf)
+H5FD__splitter_sb_decode(H5FD_t *_file, const char *name, const unsigned char *buf)
 {
     H5FD_splitter_t *file = (H5FD_splitter_t *)_file;
     herr_t           ret_value = SUCCEED;       /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_sb_decode");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
     /* Sanity check */
     HDassert(file);
     HDassert(file->rw_file);
 
-    if (H5FD_sb_load(file->rw_file, name, buf) < 0) {
+    if(H5FD_sb_load(file->rw_file, name, buf) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTDECODE, FAIL, "unable to decode the superblock in R/W file")
-    }
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_splitter_sb_decode */
+} /* end H5FD__splitter_sb_decode */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_splitter_cmp
+ * Function:    H5FD__splitter_cmp
  *
  * Purpose:     Compare the keys of two files.
  *
@@ -1142,15 +1045,15 @@ done:
  *-------------------------------------------------------------------------
  */
 static int
-H5FD_splitter_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
+H5FD__splitter_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
 {
     const H5FD_splitter_t  *f1 = (const H5FD_splitter_t *)_f1;
     const H5FD_splitter_t  *f2 = (const H5FD_splitter_t *)_f2;
     herr_t ret_value = 0;   /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_STATIC_NOERR
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_cmp");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
     HDassert(f1);
     HDassert(f2);
@@ -1158,11 +1061,11 @@ H5FD_splitter_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
     ret_value = H5FD_cmp(f1->rw_file, f2->rw_file);
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_splitter_cmp */
+} /* end H5FD__splitter_cmp */
 
 
 /*--------------------------------------------------------------------------
- * Function:    H5FD_splitter_get_handle
+ * Function:    H5FD__splitter_get_handle
  *
  * Purpose:     Returns a pointer to the file handle of low-level virtual
  *              file driver.
@@ -1171,17 +1074,15 @@ H5FD_splitter_cmp(const H5FD_t *_f1, const H5FD_t *_f2)
  *--------------------------------------------------------------------------
  */
 static herr_t
-H5FD_splitter_get_handle(
-        H5FD_t                *_file,
-        hid_t H5_ATTR_UNUSED   fapl,
-        void                 **file_handle)
+H5FD__splitter_get_handle(H5FD_t *_file, hid_t H5_ATTR_UNUSED fapl,
+    void **file_handle)
 {
     H5FD_splitter_t  *file = (H5FD_splitter_t*)_file;
     herr_t ret_value = SUCCEED;   /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_get_handle");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
     /* Check arguments */
     HDassert(file);
@@ -1189,18 +1090,16 @@ H5FD_splitter_get_handle(
     HDassert(file_handle);
 
     /* Only do for R/W channel */
-    if (H5FD_get_vfd_handle(file->rw_file, file->fa.rw_fapl_id, file_handle) < 0)
-    {
+    if(H5FD_get_vfd_handle(file->rw_file, file->fa.rw_fapl_id, file_handle) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTGET, FAIL, "unable to get handle of R/W file")
-    }
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_splitter_get_handle */
+} /* end H5FD__splitter_get_handle */
 
 
 /*--------------------------------------------------------------------------
- * Function:    H5FD_splitter_lock
+ * Function:    H5FD__splitter_lock
  *
  * Purpose:     Sets a file lock.
  *
@@ -1208,37 +1107,32 @@ done:
  *--------------------------------------------------------------------------
  */
 static herr_t
-H5FD_splitter_lock(H5FD_t *_file, hbool_t rw)
+H5FD__splitter_lock(H5FD_t *_file, hbool_t rw)
 {
     H5FD_splitter_t *file = (H5FD_splitter_t *)_file;   /* VFD file struct */
     herr_t ret_value = SUCCEED;         /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_lock");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
     HDassert(file);
     HDassert(file->rw_file);
 
     /* Place the lock on each file */
-    if (H5FD_lock(file->rw_file, rw) < 0) {
+    if(H5FD_lock(file->rw_file, rw) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTLOCK, FAIL, "unable to lock R/W file")
-    }
-    if (file->wo_file != NULL) {
-        if (H5FD_lock(file->wo_file, rw) < 0) {
-           H5FD_SPLITTER_WO_ERROR(file, "H5FD_splitter_lock",
-                                  H5E_VFL, H5E_CANTLOCK, FAIL,
-                                  "unable to lock W/O file")
-        }
-    }
+    if(file->wo_file != NULL)
+        if(H5FD_lock(file->wo_file, rw) < 0)
+            H5FD_SPLITTER_WO_ERROR(file, FUNC, H5E_VFL, H5E_CANTLOCK, FAIL, "unable to lock W/O file")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_splitter_lock */
+} /* end H5FD__splitter_lock */
 
 
 /*--------------------------------------------------------------------------
- * Function:    H5FD_splitter_unlock
+ * Function:    H5FD__splitter_unlock
  *
  * Purpose:     Removes a file lock.
  *
@@ -1246,37 +1140,33 @@ done:
  *--------------------------------------------------------------------------
  */
 static herr_t
-H5FD_splitter_unlock(H5FD_t *_file)
+H5FD__splitter_unlock(H5FD_t *_file)
 {
     H5FD_splitter_t *file = (H5FD_splitter_t *)_file;   /* VFD file struct */
     herr_t ret_value = SUCCEED;         /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_unlock");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
     /* Check arguments */
     HDassert(file);
     HDassert(file->rw_file);
 
     /* Remove the lock on each file */
-    if (H5FD_unlock(file->rw_file) < 0) {
+    if(H5FD_unlock(file->rw_file) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTUNLOCK, FAIL, "unable to unlock R/W file")
-    }
-    if (file->wo_file != NULL) {
-        if (H5FD_unlock(file->wo_file) < 0) {
-            HGOTO_ERROR(H5E_VFL, H5E_CANTUNLOCK, FAIL,
-                        "unable to unlock W/O file")
-        }
-    }
+    if(file->wo_file != NULL)
+        if(H5FD_unlock(file->wo_file) < 0)
+            HGOTO_ERROR(H5E_VFL, H5E_CANTUNLOCK, FAIL, "unable to unlock W/O file")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_splitter_unlock */
+} /* end H5FD__splitter_unlock */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_splitter_query
+ * Function:    H5FD__splitter_query
  *
  * Purpose:     Set the flags that this VFL driver is capable of supporting.
  *              (listed in H5FDpublic.h)
@@ -1285,40 +1175,37 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_splitter_query(const H5FD_t *_file, unsigned long *flags /* out */)
+H5FD__splitter_query(const H5FD_t *_file, unsigned long *flags /* out */)
 {
     const H5FD_splitter_t *file      = (const H5FD_splitter_t *)_file;
     herr_t                 ret_value = SUCCEED;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_query");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
-    if (file) {
+    if(file) {
         HDassert(file);
         HDassert(file->rw_file);
 
-        if (H5FDquery(file->rw_file, flags) < 0) {
-            HGOTO_ERROR(H5E_VFL, H5E_CANTLOCK, FAIL,
-                        "unable to query R/W file");
-        }
+        if(H5FDquery(file->rw_file, flags) < 0)
+            HGOTO_ERROR(H5E_VFL, H5E_CANTLOCK, FAIL, "unable to query R/W file");
     }
     else {
         /* There is no file. Because this is a pure passthrough VFD,
          * it has no features of its own.
          */
-        if (flags) {
+        if(flags)
             *flags = 0;
-        }
     }
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_splitter_query() */
+} /* end H5FD__splitter_query() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_splitter_alloc
+ * Function:    H5FD__splitter_alloc
  *
  * Purpose:     Allocate file memory.
  *
@@ -1326,37 +1213,33 @@ done:
  *-------------------------------------------------------------------------
  */
 static haddr_t
-H5FD_splitter_alloc(H5FD_t *_file, H5FD_mem_t type, hid_t dxpl_id, hsize_t size)
+H5FD__splitter_alloc(H5FD_t *_file, H5FD_mem_t type, hid_t dxpl_id, hsize_t size)
 {
     H5FD_splitter_t *file = (H5FD_splitter_t *)_file;   /* VFD file struct */
     haddr_t ret_value = HADDR_UNDEF;         /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_alloc");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
     /* Check arguments */
     HDassert(file);
     HDassert(file->rw_file);
 
     /* Allocate memory for each file, only return the return value for R/W file. */
-    if ((ret_value = H5FDalloc(file->rw_file, type, dxpl_id, size)) == HADDR_UNDEF) {
+    if((ret_value = H5FDalloc(file->rw_file, type, dxpl_id, size)) == HADDR_UNDEF)
         HGOTO_ERROR(H5E_VFL, H5E_CANTINIT, HADDR_UNDEF, "unable to allocate for R/W file")
-    }
 
-    if (H5FDalloc(file->wo_file, type, dxpl_id, size) == HADDR_UNDEF) {
-       H5FD_SPLITTER_WO_ERROR(file, "H5FD_splitter_alloc",
-                              H5E_VFL, H5E_CANTINIT, HADDR_UNDEF,
-                              "unable to alloc for W/O file")
-    }
+    if(H5FDalloc(file->wo_file, type, dxpl_id, size) == HADDR_UNDEF)
+       H5FD_SPLITTER_WO_ERROR(file, FUNC, H5E_VFL, H5E_CANTINIT, HADDR_UNDEF, "unable to alloc for W/O file")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_splitter_alloc() */
+} /* end H5FD__splitter_alloc() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_splitter_get_type_map
+ * Function:    H5FD__splitter_get_type_map
  *
  * Purpose:     Retrieve the memory type mapping for this file
  *
@@ -1364,31 +1247,30 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_splitter_get_type_map(const H5FD_t *_file, H5FD_mem_t *type_map)
+H5FD__splitter_get_type_map(const H5FD_t *_file, H5FD_mem_t *type_map)
 {
     const H5FD_splitter_t *file      = (const H5FD_splitter_t *)_file;
     herr_t                 ret_value = SUCCEED;
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_get_type_map");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
     /* Check arguments */
     HDassert(file);
     HDassert(file->rw_file);
 
     /* Retrieve memory type mapping for R/W channel only */
-    if (H5FD_get_fs_type_map(file->rw_file, type_map) < 0) {
+    if(H5FD_get_fs_type_map(file->rw_file, type_map) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTGET, FAIL, "unable to allocate for R/W file")
-    }
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_splitter_get_type_map() */
+} /* end H5FD__splitter_get_type_map() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5FD_splitter_free
+ * Function:    H5FD__splitter_free
  *
  * Purpose:     Free the resources for the splitter VFD.
  *
@@ -1396,32 +1278,28 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5FD_splitter_free(H5FD_t *_file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, hsize_t size)
+H5FD__splitter_free(H5FD_t *_file, H5FD_mem_t type, hid_t dxpl_id, haddr_t addr, hsize_t size)
 {
     H5FD_splitter_t *file = (H5FD_splitter_t *)_file;   /* VFD file struct */
     herr_t ret_value = SUCCEED;         /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC
 
-    H5FD_SPLITTER_LOG_CALL("H5FD_splitter_free");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
     /* Check arguments */
     HDassert(file);
     HDassert(file->rw_file);
 
-    if (H5FDfree(file->rw_file, type, dxpl_id, addr, size) < 0) {
+    if(H5FDfree(file->rw_file, type, dxpl_id, addr, size) < 0)
         HGOTO_ERROR(H5E_VFL, H5E_CANTFREE, FAIL, "unable to free for R/W file")
-    }
 
-    if (H5FDfree(file->wo_file, type, dxpl_id, addr, size) < 0) {
-       H5FD_SPLITTER_WO_ERROR(file, "H5FD_splitter_free",
-                              H5E_VFL, H5E_CANTINIT, FAIL,
-                              "unable to free for W/O file")
-    }
+    if(H5FDfree(file->wo_file, type, dxpl_id, addr, size) < 0)
+       H5FD_SPLITTER_WO_ERROR(file, FUNC, H5E_VFL, H5E_CANTINIT, FAIL, "unable to free for W/O file")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5FD_splitter_free() */
+} /* end H5FD__splitter_free() */
 
 
 /*-------------------------------------------------------------------------
@@ -1435,33 +1313,29 @@ done:
 static herr_t
 H5FD__splitter_log_error(const H5FD_splitter_t *file, const char *atfunc, const char *msg)
 {
-    size_t size = 0;
-    char  *s = NULL;
     herr_t ret_value = SUCCEED;
 
     FUNC_ENTER_STATIC_NOERR
 
-    H5FD_SPLITTER_LOG_CALL("H5FD__splitter_log_error");
+    H5FD_SPLITTER_LOG_CALL(FUNC);
 
     /* Check arguments */
     HDassert(file);
     HDassert(atfunc && *atfunc);
     HDassert(msg && *msg);
 
-    if (file->logfp != NULL) {
-        size = strlen(atfunc) + strlen(msg) + 3; /* ':', ' ', '\n' */
-        s = (char *)malloc(sizeof(char) * (size+1));
-        if (NULL == s) {
+    if(file->logfp != NULL) {
+        size_t size;
+        char  *s;
+
+        size = HDstrlen(atfunc) + HDstrlen(msg) + 3; /* ':', ' ', '\n' */
+        s = (char *)HDmalloc(sizeof(char) * (size + 1));
+        if(NULL == s)
             ret_value = FAIL;
-        }
-        else
-        if (size < (size_t)HDsnprintf(s, size+1, "%s: %s\n", atfunc, msg)) {
+        else if(size < (size_t)HDsnprintf(s, size+1, "%s: %s\n", atfunc, msg))
             ret_value = FAIL;
-        }
-        else
-        if (size != HDfwrite(s, 1, size, file->logfp)) {
+        else if(size != HDfwrite(s, 1, size, file->logfp))
             ret_value = FAIL;
-        }
         HDfree(s);
     }