[svn-r157] Reformatted code with indent...

1 files changed, 902 insertions, 948 deletions

diff --git a/src/H5G.c b/src/H5G.c
index 7975c56..e5acde2 100644
--- a/src/H5G.c
+++ b/src/H5G.c
@@ -1,36 +1,36 @@
 /*-------------------------------------------------------------------------
- * Copyright (C) 1997	National Center for Supercomputing Applications.
+ * Copyright (C) 1997   National Center for Supercomputing Applications.
  *                      All rights reserved.
  *
  *-------------------------------------------------------------------------
  *
- * Created:		H5G.c
- * 			Jul 18 1997
- * 			Robb Matzke <matzke@llnl.gov>
+ * Created:             H5G.c
+ *                      Jul 18 1997
+ *                      Robb Matzke <matzke@llnl.gov>
  *
- * Purpose:		Symbol table functions.  The functions that
- *			begin with `H5G_stab_' don't understand the
- *			naming system; they operate on a single
- *			symbol table at a time.
+ * Purpose:             Symbol table functions.  The functions that
+ *                      begin with `H5G_stab_' don't understand the
+ *                      naming system; they operate on a single
+ *                      symbol table at a time.
  *
- * 			The functions that begin with `H5G_node_' operate
- *			on the leaf nodes of a symbol table B-tree.  They
- *			should be defined in the H5Gnode.c file.
+ *                      The functions that begin with `H5G_node_' operate
+ *                      on the leaf nodes of a symbol table B-tree.  They
+ *                      should be defined in the H5Gnode.c file.
  *
- *			The remaining functions know how to traverse the
- *			group directed graph
+ *                      The remaining functions know how to traverse the
+ *                      group directed graph
  *
  * Modifications:
  *
- *	Robb Matzke, 5 Aug 1997
- *	Added calls to H5E.
+ *      Robb Matzke, 5 Aug 1997
+ *      Added calls to H5E.
  *
- * 	Robb Matzke, 30 Aug 1997
- *	Added `Errors:' field to function prologues.
+ *      Robb Matzke, 30 Aug 1997
+ *      Added `Errors:' field to function prologues.
  *
  *-------------------------------------------------------------------------
  */
-#define H5G_PACKAGE	/*suppress error message about including H5Gpkg.h*/
+#define H5G_PACKAGE             /*suppress error message about including H5Gpkg.h */
 
 /* Packages needed by this file... */
 #include <H5private.h>
@@ -42,43 +42,42 @@
 #include <H5MMprivate.h>
 #include <H5Oprivate.h>
 
-#define H5G_INIT_HEAP		8192
-#define H5G_RESERVED_ATOMS	0
-#define PABLO_MASK		H5G_mask
+#define H5G_INIT_HEAP           8192
+#define H5G_RESERVED_ATOMS      0
+#define PABLO_MASK              H5G_mask
 
 /* Interface initialization */
-static hbool_t interface_initialize_g = FALSE;
-#define INTERFACE_INIT		H5G_init_interface
-static herr_t H5G_init_interface (void);
-static void H5G_term_interface (void);
-
-static H5G_entry_t *H5G_getcwg (H5F_t *f);
+static hbool_t          interface_initialize_g = FALSE;
+#define INTERFACE_INIT          H5G_init_interface
+static herr_t           H5G_init_interface(void);
+static void             H5G_term_interface(void);
 
+static H5G_entry_t     *H5G_getcwg(H5F_t *f);
 
 /*-------------------------------------------------------------------------
- * Function:	H5Gcreate
+ * Function:    H5Gcreate
  *
- * Purpose:	Creates a new group in FILE and gives it the specified
- *		NAME. Unless NAME begins with `/' it is relative to the
- *		current working group.  The group is opened for write access
- *		and it's object ID is returned.
+ * Purpose:     Creates a new group in FILE and gives it the specified
+ *              NAME. Unless NAME begins with `/' it is relative to the
+ *              current working group.  The group is opened for write access
+ *              and it's object ID is returned.
  *
- * 		The optional SIZE_HINT specifies how much file space to
- *		reserve to store the names that will appear in this
- *		group. If a non-positive value is supplied for the SIZE_HINT
- *		then a default size is chosen.
+ *              The optional SIZE_HINT specifies how much file space to
+ *              reserve to store the names that will appear in this
+ *              group. If a non-positive value is supplied for the SIZE_HINT
+ *              then a default size is chosen.
  *
- * See also:	H5Gset(), H5Gpush(), H5Gpop()
+ * See also:    H5Gset(), H5Gpush(), H5Gpop()
  *
  * Errors:
  *
- * Return:	Success:	The object ID of a new, empty group open for
- *				writing.  Call H5Gclose() when finished with
- *				the group.
+ * Return:      Success:        The object ID of a new, empty group open for
+ *                              writing.  Call H5Gclose() when finished with
+ *                              the group.
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, September 24, 1997
  *
  * Modifications:
@@ -86,52 +85,48 @@ static H5G_entry_t *H5G_getcwg (H5F_t *f);
  *-------------------------------------------------------------------------
  */
 hid_t
-H5Gcreate (hid_t file_id, const char *name, size_t size_hint)
+H5Gcreate(hid_t file_id, const char *name, size_t size_hint)
 {
-   H5F_t	*f = NULL;
-   H5G_t	*grp;
-   hid_t	ret_value = FAIL;
-   
-   FUNC_ENTER (H5Gcreate, FAIL);
-   H5ECLEAR;
-
-   /* Check arguments */
-   if (H5_FILE!=H5Aatom_group (file_id) ||
-       NULL==(f=H5Aatom_object (file_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file");
-   }
-   if (!name || !*name) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no name given");
-   }
-   
-   /* Create the group */
-   if (NULL==(grp=H5G_create (f, name, size_hint))) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "unable to create group");
-   }
-
-   if ((ret_value = H5Aregister_atom (H5_GROUP, grp))<0) {
-      H5G_close (grp);
-      HRETURN_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL,
-		     "unable to register group");
-   }
-
-   FUNC_LEAVE (ret_value);
+    H5F_t                  *f = NULL;
+    H5G_t                  *grp;
+    hid_t                   ret_value = FAIL;
+
+    FUNC_ENTER(H5Gcreate, FAIL);
+    H5ECLEAR;
+
+    /* Check arguments */
+    if (H5_FILE != H5Aatom_group(file_id) ||
+        NULL == (f = H5Aatom_object(file_id))) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file");
+    }
+    if (!name || !*name) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name given");
+    }
+    /* Create the group */
+    if (NULL == (grp = H5G_create(f, name, size_hint))) {
+        HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to create group");
+    }
+    if ((ret_value = H5Aregister_atom(H5_GROUP, grp)) < 0) {
+        H5G_close(grp);
+        HRETURN_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL,
+                      "unable to register group");
+    }
+    FUNC_LEAVE(ret_value);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Gopen
+ * Function:    H5Gopen
  *
- * Purpose:	Opens an existing group for modification.  When finished,
- *		call H5Gclose() to close it and release resources.
+ * Purpose:     Opens an existing group for modification.  When finished,
+ *              call H5Gclose() to close it and release resources.
  *
  * Errors:
  *
- * Return:	Success:	Object ID of the group.
+ * Return:      Success:        Object ID of the group.
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, December 31, 1997
  *
  * Modifications:
@@ -139,51 +134,47 @@ H5Gcreate (hid_t file_id, const char *name, size_t size_hint)
  *-------------------------------------------------------------------------
  */
 hid_t
-H5Gopen (hid_t file_id, const char *name)
+H5Gopen(hid_t file_id, const char *name)
 {
-   hid_t	ret_value = FAIL;
-   H5F_t	*f = NULL;
-   H5G_t	*grp = NULL;
-   
-   FUNC_ENTER (H5Gopen, FAIL);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_FILE!=H5Aatom_group (file_id) ||
-       NULL==(f=H5Aatom_object (file_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file");
-   }
-   if (!name || !*name) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no name");
-   }
-
-   /* Open the group */
-   if (NULL==(grp=H5G_open (f, name))) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTOPENOBJ, FAIL, "unable to open group");
-   }
-
-   /* Register an atom for the group */
-   if ((ret_value=H5Aregister_atom (H5_GROUP, grp))<0) {
-      H5G_close (grp);
-      HRETURN_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL,
-		     "unable to register group");
-   }
-
-   FUNC_LEAVE (ret_value);
+    hid_t                   ret_value = FAIL;
+    H5F_t                  *f = NULL;
+    H5G_t                  *grp = NULL;
+
+    FUNC_ENTER(H5Gopen, FAIL);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_FILE != H5Aatom_group(file_id) ||
+        NULL == (f = H5Aatom_object(file_id))) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file");
+    }
+    if (!name || !*name) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name");
+    }
+    /* Open the group */
+    if (NULL == (grp = H5G_open(f, name))) {
+        HRETURN_ERROR(H5E_SYM, H5E_CANTOPENOBJ, FAIL, "unable to open group");
+    }
+    /* Register an atom for the group */
+    if ((ret_value = H5Aregister_atom(H5_GROUP, grp)) < 0) {
+        H5G_close(grp);
+        HRETURN_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL,
+                      "unable to register group");
+    }
+    FUNC_LEAVE(ret_value);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Gclose
+ * Function:    H5Gclose
  *
- * Purpose:	Closes the specified group.  The group ID will no longer be
- *		valid for accessing the group.
+ * Purpose:     Closes the specified group.  The group ID will no longer be
+ *              valid for accessing the group.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, December 31, 1997
  *
  * Modifications:
@@ -191,52 +182,49 @@ H5Gopen (hid_t file_id, const char *name)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Gclose (hid_t grp_id)
+H5Gclose(hid_t grp_id)
 {
-   H5G_t	*grp = NULL;
-   
-   FUNC_ENTER (H5Gclose, FAIL);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_GROUP!=H5Aatom_group (grp_id) ||
-       NULL==(grp=H5Aatom_object (grp_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a group");
-   }
-
-   /*
-    * Decrement the counter on the group atom.  It will be freed if the count
-    * reaches zero.
-    */
-   if (H5A_dec_ref (grp_id)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "unable to close group");
-   }
-
-   FUNC_LEAVE (SUCCEED);
+    H5G_t                  *grp = NULL;
+
+    FUNC_ENTER(H5Gclose, FAIL);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_GROUP != H5Aatom_group(grp_id) ||
+        NULL == (grp = H5Aatom_object(grp_id))) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a group");
+    }
+    /*
+     * Decrement the counter on the group atom.  It will be freed if the count
+     * reaches zero.
+     */
+    if (H5A_dec_ref(grp_id) < 0) {
+        HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to close group");
+    }
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Gset
+ * Function:    H5Gset
  *
- * Purpose:	Sets the working group for file handle FILE to the
- *		specified group.
+ * Purpose:     Sets the working group for file handle FILE to the
+ *              specified group.
  *
- *		Each file handle maintains its own notion of the current
- *		working group.  That is, if a single file is opened with
- *		multiple calls to H5Fopen(), which returns multiple file
- *		handles, then each handle's current working group can be
- *		set independently of the other file handles for that file.
+ *              Each file handle maintains its own notion of the current
+ *              working group.  That is, if a single file is opened with
+ *              multiple calls to H5Fopen(), which returns multiple file
+ *              handles, then each handle's current working group can be
+ *              set independently of the other file handles for that file.
  *
- * See also:	H5Gpush(), H5Gpop()
+ * See also:    H5Gpush(), H5Gpop()
  *
  * Errors:
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, September 24, 1997
  *
  * Modifications:
@@ -244,62 +232,58 @@ H5Gclose (hid_t grp_id)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Gset (hid_t file_id, const char *name)
+H5Gset(hid_t file_id, const char *name)
 {
-   H5F_t	*f=NULL;
-   H5G_t	*grp;
-   
-   FUNC_ENTER (H5Gset, FAIL);
-   H5ECLEAR;
-
-   /* Check/fix arguments */
-   if (H5_FILE!=H5Aatom_group (file_id) ||
-       NULL==(f=H5Aatom_object (file_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file");
-   }
-   if (!name || !*name) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no name");
-   }
-   if (NULL==(grp=H5G_open (f, name))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_NOTFOUND, FAIL, "no such group");
-   }
-
-   /* Set the current working group */
-   if (H5G_set (f, grp)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
-		     "unable to change current working group");
-   }
-
-   /* Close the handle */
-   if (H5G_close (grp)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "unable to close group");
-   }
-
-   FUNC_LEAVE (SUCCEED);
+    H5F_t                  *f = NULL;
+    H5G_t                  *grp;
+
+    FUNC_ENTER(H5Gset, FAIL);
+    H5ECLEAR;
+
+    /* Check/fix arguments */
+    if (H5_FILE != H5Aatom_group(file_id) ||
+        NULL == (f = H5Aatom_object(file_id))) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file");
+    }
+    if (!name || !*name) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name");
+    }
+    if (NULL == (grp = H5G_open(f, name))) {
+        HRETURN_ERROR(H5E_ARGS, H5E_NOTFOUND, FAIL, "no such group");
+    }
+    /* Set the current working group */
+    if (H5G_set(f, grp) < 0) {
+        HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, FAIL,
+                      "unable to change current working group");
+    }
+    /* Close the handle */
+    if (H5G_close(grp) < 0) {
+        HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to close group");
+    }
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Gpush
+ * Function:    H5Gpush
  *
- * Purpose:	Similar to H5Gset() except the new working group is pushed
- *		on a stack.
+ * Purpose:     Similar to H5Gset() except the new working group is pushed
+ *              on a stack.
  *
- *		Each file handle maintains its own notion of the current
- *		working group.  That is, if a single file is opened with
- *		multiple calls to H5Fopen(), which returns multiple file
- *		handles, then each handle's current working group can be
- *		set independently of the other file handles for that file.
+ *              Each file handle maintains its own notion of the current
+ *              working group.  That is, if a single file is opened with
+ *              multiple calls to H5Fopen(), which returns multiple file
+ *              handles, then each handle's current working group can be
+ *              set independently of the other file handles for that file.
  *
- * See also:	H5Gset(), H5Gpop()
+ * See also:    H5Gset(), H5Gpop()
  *
  * Errors:
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, September 24, 1997
  *
  * Modifications:
@@ -307,64 +291,60 @@ H5Gset (hid_t file_id, const char *name)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Gpush (hid_t file_id, const char *name)
+H5Gpush(hid_t file_id, const char *name)
 {
-   H5F_t	*f=NULL;
-   H5G_t	*grp;
-   
-   FUNC_ENTER (H5Gpush, FAIL);
-   H5ECLEAR;
-
-   /* Check arguments */
-   if (H5_FILE!=H5Aatom_group (file_id) ||
-       NULL==(f=H5Aatom_object (file_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file");
-   }
-   if (!name || !*name) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no name");
-   }
-   if (NULL==(grp=H5G_open (f, name))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_NOTFOUND, FAIL, "no such group");
-   }
-   
-   /* Push group onto stack */
-   if (H5G_push (f, grp)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
-		     "can't change current working group");
-   }
-
-   /* Close the handle */
-   if (H5G_close (grp)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "unable to close group");
-   }
-   
-   FUNC_LEAVE (SUCCEED);
+    H5F_t                  *f = NULL;
+    H5G_t                  *grp;
+
+    FUNC_ENTER(H5Gpush, FAIL);
+    H5ECLEAR;
+
+    /* Check arguments */
+    if (H5_FILE != H5Aatom_group(file_id) ||
+        NULL == (f = H5Aatom_object(file_id))) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file");
+    }
+    if (!name || !*name) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name");
+    }
+    if (NULL == (grp = H5G_open(f, name))) {
+        HRETURN_ERROR(H5E_ARGS, H5E_NOTFOUND, FAIL, "no such group");
+    }
+    /* Push group onto stack */
+    if (H5G_push(f, grp) < 0) {
+        HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, FAIL,
+                      "can't change current working group");
+    }
+    /* Close the handle */
+    if (H5G_close(grp) < 0) {
+        HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to close group");
+    }
+    FUNC_LEAVE(SUCCEED);
 }
-   
 
 /*-------------------------------------------------------------------------
- * Function:	H5Gpop
+ * Function:    H5Gpop
  *
- * Purpose:	Removes the top (latest) entry from the working group stack
- *		and sets the current working group to the previous value.
+ * Purpose:     Removes the top (latest) entry from the working group stack
+ *              and sets the current working group to the previous value.
  *
- *		Each file handle maintains its own notion of the current
- *		working group.  That is, if a single file is opened with
- *		multiple calls to H5Fopen(), which returns multiple file
- *		handles, then each handle's current working group can be
- *		set independently of the other file handles for that file.
+ *              Each file handle maintains its own notion of the current
+ *              working group.  That is, if a single file is opened with
+ *              multiple calls to H5Fopen(), which returns multiple file
+ *              handles, then each handle's current working group can be
+ *              set independently of the other file handles for that file.
  *
- * See also:	H5Gset(), H5Gpush()
+ * See also:    H5Gset(), H5Gpush()
  *
  * Errors:
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL.  The final entry cannot be popped from
- *				the group stack (but it can be changed
- *				with H5Gset()).
+ *              Failure:        FAIL.  The final entry cannot be popped from
+ *                              the group stack (but it can be changed
+ *                              with H5Gset()).
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, September 24, 1997
  *
  * Modifications:
@@ -372,30 +352,25 @@ H5Gpush (hid_t file_id, const char *name)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Gpop (hid_t file_id)
+H5Gpop(hid_t file_id)
 {
-   H5F_t	*f=NULL;
-   
-   FUNC_ENTER (H5Gpop, FAIL);
-   H5ECLEAR;
-   
-   /* Check arguments */
-   if (H5_FILE!=H5Aatom_group (file_id) ||
-       NULL==(f=H5Aatom_object (file_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a file");
-   }
-
-   /* pop */
-   if (H5G_pop (f)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
-		     "stack is empty");
-   }
-
-   FUNC_LEAVE (SUCCEED);
+    H5F_t                  *f = NULL;
+
+    FUNC_ENTER(H5Gpop, FAIL);
+    H5ECLEAR;
+
+    /* Check arguments */
+    if (H5_FILE != H5Aatom_group(file_id) ||
+        NULL == (f = H5Aatom_object(file_id))) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a file");
+    }
+    /* pop */
+    if (H5G_pop(f) < 0) {
+        HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, FAIL,
+                      "stack is empty");
+    }
+    FUNC_LEAVE(SUCCEED);
 }
-   
-
-
 
 /*
  *-------------------------------------------------------------------------
@@ -404,19 +379,17 @@ H5Gpop (hid_t file_id)
  *-------------------------------------------------------------------------
  *------------------------------------------------------------------------- 
  */
-
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_init_interface
+ * Function:    H5G_init_interface
  *
- * Purpose:	Initializes the H5G interface.
+ * Purpose:     Initializes the H5G interface.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, January  5, 1998
  *
  * Modifications:
@@ -424,30 +397,28 @@ H5Gpop (hid_t file_id)
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5G_init_interface (void)
+H5G_init_interface(void)
 {
-   FUNC_ENTER (H5G_init_interface, FAIL);
-
-   /* Initialize the atom group for the group IDs */
-   if (H5Ainit_group (H5_GROUP, H5A_GROUPID_HASHSIZE, H5G_RESERVED_ATOMS,
-		      (herr_t (*)(void*))H5G_close)<0 ||
-       H5_add_exit (H5G_term_interface)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
-		     "unable to initialize interface");
-   }
-    
-   FUNC_LEAVE (SUCCEED);
+    FUNC_ENTER(H5G_init_interface, FAIL);
+
+    /* Initialize the atom group for the group IDs */
+    if (H5Ainit_group(H5_GROUP, H5A_GROUPID_HASHSIZE, H5G_RESERVED_ATOMS,
+                      (herr_t (*)(void *)) H5G_close) < 0 ||
+        H5_add_exit(H5G_term_interface) < 0) {
+        HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, FAIL,
+                      "unable to initialize interface");
+    }
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_term_interface
+ * Function:    H5G_term_interface
  *
- * Purpose:	Terminates the H5G interface
+ * Purpose:     Terminates the H5G interface
  *
- * Return:	void
+ * Return:      void
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, January  5, 1998
  *
  * Modifications:
@@ -455,497 +426,491 @@ H5G_init_interface (void)
  *-------------------------------------------------------------------------
  */
 static void
-H5G_term_interface (void)
+H5G_term_interface(void)
 {
-    H5Adestroy_group (H5_GROUP);
+    H5Adestroy_group(H5_GROUP);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_component
+ * Function:    H5G_component
  *
- * Purpose:	Returns the pointer to the first component of the
- *		specified name by skipping leading slashes.  Returns
- *		the size in characters of the component through SIZE_P not
- *		counting leading slashes or the null terminator.
+ * Purpose:     Returns the pointer to the first component of the
+ *              specified name by skipping leading slashes.  Returns
+ *              the size in characters of the component through SIZE_P not
+ *              counting leading slashes or the null terminator.
  *
  * Errors:
  *
- * Return:	Success:	Ptr into NAME.
+ * Return:      Success:        Ptr into NAME.
  *
- *		Failure:	Ptr to the null terminator of NAME.
+ *              Failure:        Ptr to the null terminator of NAME.
  *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Aug 11 1997
+ * Programmer:  Robb Matzke
+ *              matzke@llnl.gov
+ *              Aug 11 1997
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
-static const char *
-H5G_component (const char *name, size_t *size_p)
+static const char      *
+H5G_component(const char *name, size_t *size_p)
 {
-   assert (name);
-   
-   while ('/'==*name) name++;
-   if (size_p) *size_p = HDstrcspn (name, "/");
-   return name;
-}
+    assert(name);
 
+    while ('/' == *name)
+        name++;
+    if (size_p)
+        *size_p = HDstrcspn(name, "/");
+    return name;
+}
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_namei
- *
- * Purpose:	Translates a name to a symbol table entry.
- *
- *		If the specified name can be fully resolved, then this
- *		function returns the symbol table entry for the named object
- *		through the OBJ_ENT argument. The symbol table entry for the
- *		group containing the named object is returned through the
- *		GRP_ENT argument if it is non-null.  However, if the name
- *		refers to the root object then the GRP_ENT will be
- *		initialized with an undefined object header address.  The
- *		REST argument, if present, will point to the null terminator
- *		of NAME.
- *
- *		If the specified name cannot be fully resolved, then OBJ_ENT
- *		is initialized with the undefined object header address. The
- *		REST argument will point into the NAME argument to the start
- *		of the component that could not be located.  The GRP_ENT will
- *		contain the entry for the symbol table that was being
- *		searched at the time of the failure and will have an
- *		undefined object header address if the search failed at the
- *		root object. For instance, if NAME is `/foo/bar/baz' and the
- *		root directory exists and contains an entry for `foo', and
- *		foo is a group that contains an entry for baz, but baz is not
- *		a group, then the results will be that REST points to `baz',
- *		GRP_ENT has an undefined object header address, and GRP_ENT
- *		is the symbol table entry for `bar' in `/foo'.
- *
- *		If a file contains more than one object, then `/' is the name
- *		of the root object which is a group.  Otherwise, a file can
- *		consist of a single object, not necessarily a group, whose
- *		name is `/foo' where `foo' is the value of the name messsage
- *		in the object header.  A file can also contain no objects in
- *		which case the function returns so REST points to the
- *		beginning of NAME and OBJ_ENT and GRP_ENT contain undefined
- *		header addresses.
- *
- *		Components of a name are separated from one another by one or
- *		more slashes (/).  Slashes at the end of a name are ignored.
- *		If the name begins with a slash then the search begins at the
- *		root object, otherwise it begins at the group CWG, otherwise
- *		it begins at the current working group of file F. The
- *		component `.' is a no-op, but `..' is not understood by this
- *		function (unless it appears as an entry in the symbol table).
- *		
+ * Function:    H5G_namei
+ *
+ * Purpose:     Translates a name to a symbol table entry.
+ *
+ *              If the specified name can be fully resolved, then this
+ *              function returns the symbol table entry for the named object
+ *              through the OBJ_ENT argument. The symbol table entry for the
+ *              group containing the named object is returned through the
+ *              GRP_ENT argument if it is non-null.  However, if the name
+ *              refers to the root object then the GRP_ENT will be
+ *              initialized with an undefined object header address.  The
+ *              REST argument, if present, will point to the null terminator
+ *              of NAME.
+ *
+ *              If the specified name cannot be fully resolved, then OBJ_ENT
+ *              is initialized with the undefined object header address. The
+ *              REST argument will point into the NAME argument to the start
+ *              of the component that could not be located.  The GRP_ENT will
+ *              contain the entry for the symbol table that was being
+ *              searched at the time of the failure and will have an
+ *              undefined object header address if the search failed at the
+ *              root object. For instance, if NAME is `/foo/bar/baz' and the
+ *              root directory exists and contains an entry for `foo', and
+ *              foo is a group that contains an entry for baz, but baz is not
+ *              a group, then the results will be that REST points to `baz',
+ *              GRP_ENT has an undefined object header address, and GRP_ENT
+ *              is the symbol table entry for `bar' in `/foo'.
+ *
+ *              If a file contains more than one object, then `/' is the name
+ *              of the root object which is a group.  Otherwise, a file can
+ *              consist of a single object, not necessarily a group, whose
+ *              name is `/foo' where `foo' is the value of the name messsage
+ *              in the object header.  A file can also contain no objects in
+ *              which case the function returns so REST points to the
+ *              beginning of NAME and OBJ_ENT and GRP_ENT contain undefined
+ *              header addresses.
+ *
+ *              Components of a name are separated from one another by one or
+ *              more slashes (/).  Slashes at the end of a name are ignored.
+ *              If the name begins with a slash then the search begins at the
+ *              root object, otherwise it begins at the group CWG, otherwise
+ *              it begins at the current working group of file F. The
+ *              component `.' is a no-op, but `..' is not understood by this
+ *              function (unless it appears as an entry in the symbol table).
+ *              
  * Errors:
  *
- * Return:	Success:	SUCCEED if name can be fully resolved.  See
- *				above for values of REST, GRP_ENT, and
- *				OBJ_ENT.
+ * Return:      Success:        SUCCEED if name can be fully resolved.  See
+ *                              above for values of REST, GRP_ENT, and
+ *                              OBJ_ENT.
  *
- *		Failure:	FAIL if the name could not be fully resolved.
- *				See above for values of REST, GRP_ENT, and
- *				OBJ_ENT.
+ *              Failure:        FAIL if the name could not be fully resolved.
+ *                              See above for values of REST, GRP_ENT, and
+ *                              OBJ_ENT.
  *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Aug 11 1997
+ * Programmer:  Robb Matzke
+ *              matzke@llnl.gov
+ *              Aug 11 1997
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5G_namei (H5F_t *f, H5G_entry_t *cwg, const char *name,
-	   const char **rest/*out*/, H5G_entry_t *grp_ent/*out*/,
-	   H5G_entry_t *obj_ent/*out*/)
+H5G_namei(H5F_t *f, H5G_entry_t *cwg, const char *name,
+          const char **rest /*out */ , H5G_entry_t *grp_ent /*out */ ,
+          H5G_entry_t *obj_ent /*out */ )
 {
-   H5G_entry_t  _grp_ent;		/*entry for current group	*/
-   H5G_entry_t	_obj_ent;		/*entry found			*/
-   size_t	nchars;			/*component name length		*/
-   char		comp[1024];		/*component name buffer		*/
-   hbool_t	aside = FALSE;		/*did we look at a name message?*/
-
-   /* clear output args before FUNC_ENTER() in case it fails */
-   if (rest) *rest = name;
-   if (!grp_ent) grp_ent = &_grp_ent;
-   if (!obj_ent) obj_ent = &_obj_ent;
-   memset (grp_ent, 0, sizeof(H5G_entry_t));
-   H5F_addr_undef (&(grp_ent->header));
-   memset (obj_ent, 0, sizeof(H5G_entry_t));
-   H5F_addr_undef (&(obj_ent->header));
-   
-   FUNC_ENTER (H5G_namei, FAIL);
-
-   /* check args */
-   assert (f);
-   assert (name && *name);
-
-   /* If the file contains no objects then return failure */
-   if (!f->shared->root_ent) {
-      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "no root group");
-   }
-   
-   /* starting point */
-   if ('/'==*name) {
-      *obj_ent = *(f->shared->root_ent);
-   } else if (cwg) {
-      *obj_ent = *cwg;
-   } else if ((cwg=H5G_getcwg (f))) {
-      *obj_ent = *cwg;
-   } else {
-      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "no current working group");
-   }
-   assert (H5F_addr_defined (&(obj_ent->header)));
-
-   /* traverse the name */
-   while ((name=H5G_component (name, &nchars)) && *name) {
-      if (rest) *rest = name;
-
-      /*
-       * The special name `.' is a no-op.
-       */
-      if ('.'==name[0] && !name[1]) continue;
-
-      /*
-       * Advance to the next component of the name.
-       */
-      *grp_ent = *obj_ent;
-      HDmemset (obj_ent, 0, sizeof(H5G_entry_t));
-      H5F_addr_undef (&(obj_ent->header));
-
-      /*
-       * Copy the component name into a null-terminated buffer so
-       * we can pass it down to the other symbol table functions.
-       */
-      if (nchars+1 > sizeof(comp)) {
-	 HRETURN_ERROR (H5E_SYM, H5E_COMPLEN, FAIL, "component is too long");
-      }
-      HDmemcpy (comp, name, nchars);
-      comp[nchars] = '\0';
-
-      if (H5G_stab_find (grp_ent, comp, obj_ent/*out*/)<0) {
-	 /*
-	  * Component was not found in the current symbol table, possibly
-	  * because GRP_ENT isn't a symbol table.  If it is the root symbol
-	  * then see if it has the appropriate name field.  The ASIDE
-	  * variable prevents us from saying `/foo/foo' where the root object
-	  * has the name `foo'.
-	  */
-	 H5O_name_t mesg={0};
-	 if (!aside &&
-	     H5F_addr_eq (&(grp_ent->header),
-			  &(f->shared->root_ent->header)) &&
-	     H5O_read (grp_ent, H5O_NAME, 0, &mesg) &&
-	     !HDstrcmp (mesg.s, comp)) {
-	    H5O_reset (H5O_NAME, &mesg);
-	    *obj_ent = *grp_ent;
-	    HDmemset (grp_ent, 0, sizeof(H5G_entry_t));
-	    H5F_addr_undef (&(grp_ent->header));
-	    aside = TRUE;
-	 } else {
-	    H5O_reset (H5O_NAME, &mesg);
-	    HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "component not found");
-	 }
-      }
-
-      /* next component */
-      name += nchars;
-   }
-   if (rest) *rest = name; /*final null*/
-
-   FUNC_LEAVE (SUCCEED);
+    H5G_entry_t             _grp_ent;   /*entry for current group       */
+    H5G_entry_t             _obj_ent;   /*entry found                   */
+    size_t                  nchars;     /*component name length         */
+    char                    comp[1024];         /*component name buffer         */
+    hbool_t                 aside = FALSE;      /*did we look at a name message? */
+
+    /* clear output args before FUNC_ENTER() in case it fails */
+    if (rest)
+        *rest = name;
+    if (!grp_ent)
+        grp_ent = &_grp_ent;
+    if (!obj_ent)
+        obj_ent = &_obj_ent;
+    memset(grp_ent, 0, sizeof(H5G_entry_t));
+    H5F_addr_undef(&(grp_ent->header));
+    memset(obj_ent, 0, sizeof(H5G_entry_t));
+    H5F_addr_undef(&(obj_ent->header));
+
+    FUNC_ENTER(H5G_namei, FAIL);
+
+    /* check args */
+    assert(f);
+    assert(name && *name);
+
+    /* If the file contains no objects then return failure */
+    if (!f->shared->root_ent) {
+        HRETURN_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "no root group");
+    }
+    /* starting point */
+    if ('/' == *name) {
+        *obj_ent = *(f->shared->root_ent);
+    } else if (cwg) {
+        *obj_ent = *cwg;
+    } else if ((cwg = H5G_getcwg(f))) {
+        *obj_ent = *cwg;
+    } else {
+        HRETURN_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "no current working group");
+    }
+    assert(H5F_addr_defined(&(obj_ent->header)));
+
+    /* traverse the name */
+    while ((name = H5G_component(name, &nchars)) && *name) {
+        if (rest)
+            *rest = name;
+
+        /*
+         * The special name `.' is a no-op.
+         */
+        if ('.' == name[0] && !name[1])
+            continue;
+
+        /*
+         * Advance to the next component of the name.
+         */
+        *grp_ent = *obj_ent;
+        HDmemset(obj_ent, 0, sizeof(H5G_entry_t));
+        H5F_addr_undef(&(obj_ent->header));
+
+        /*
+         * Copy the component name into a null-terminated buffer so
+         * we can pass it down to the other symbol table functions.
+         */
+        if (nchars + 1 > sizeof(comp)) {
+            HRETURN_ERROR(H5E_SYM, H5E_COMPLEN, FAIL, "component is too long");
+        }
+        HDmemcpy(comp, name, nchars);
+        comp[nchars] = '\0';
+
+        if (H5G_stab_find(grp_ent, comp, obj_ent /*out */ ) < 0) {
+            /*
+             * Component was not found in the current symbol table, possibly
+             * because GRP_ENT isn't a symbol table.  If it is the root symbol
+             * then see if it has the appropriate name field.  The ASIDE
+             * variable prevents us from saying `/foo/foo' where the root object
+             * has the name `foo'.
+             */
+            H5O_name_t              mesg =
+            {0};
+            if (!aside &&
+                H5F_addr_eq(&(grp_ent->header),
+                            &(f->shared->root_ent->header)) &&
+                H5O_read(grp_ent, H5O_NAME, 0, &mesg) &&
+                !HDstrcmp(mesg.s, comp)) {
+                H5O_reset(H5O_NAME, &mesg);
+                *obj_ent = *grp_ent;
+                HDmemset(grp_ent, 0, sizeof(H5G_entry_t));
+                H5F_addr_undef(&(grp_ent->header));
+                aside = TRUE;
+            } else {
+                H5O_reset(H5O_NAME, &mesg);
+                HRETURN_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "component not found");
+            }
+        }
+        /* next component */
+        name += nchars;
+    }
+    if (rest)
+        *rest = name;           /*final null */
+
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_mkroot
+ * Function:    H5G_mkroot
  *
- * Purpose:	Creates the root group if it doesn't exist; otherwise
- *		nothing happens.  If the root symbol table entry previously
- *		pointed to something other than a group, then that object
- *		is made a member of the root group and is given a name
- *		corresponding to the object's name message (the name message
- *		is removed).  If the root object doesn't have a name message
- *		then the name `Root Object' is used.
+ * Purpose:     Creates the root group if it doesn't exist; otherwise
+ *              nothing happens.  If the root symbol table entry previously
+ *              pointed to something other than a group, then that object
+ *              is made a member of the root group and is given a name
+ *              corresponding to the object's name message (the name message
+ *              is removed).  If the root object doesn't have a name message
+ *              then the name `Root Object' is used.
  *
  * Errors:
  * 
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL.  This function returns -2 if the
- *				failure is because a root group already
- *				exists.
+ *              Failure:        FAIL.  This function returns -2 if the
+ *                              failure is because a root group already
+ *                              exists.
  *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Aug 11 1997
+ * Programmer:  Robb Matzke
+ *              matzke@llnl.gov
+ *              Aug 11 1997
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5G_mkroot (H5F_t *f, size_t size_hint)
+H5G_mkroot(H5F_t *f, size_t size_hint)
 {
-   herr_t	ret_value=FAIL;		/*return value			*/
-   H5O_name_t	name={NULL};		/*object name			*/
-   H5O_stab_t	stab;			/*symbol table message		*/
-   H5G_entry_t	new_root;		/*new root object		*/
-   const char	*obj_name=NULL;		/*name of old root object	*/
-   
-   FUNC_ENTER (H5G_mkroot, FAIL);
-
-   /* check args */
-   assert (f);
-
-   /*
-    * If we already have a root object, then get it's name.
-    */
-   if (f->shared->root_ent) {
-      if (H5O_read (f->shared->root_ent, H5O_STAB, 0, &stab)) {
-	 HGOTO_ERROR (H5E_SYM, H5E_EXISTS, -2, "root group already exists");
-      } else if (NULL==H5O_read (f->shared->root_ent, H5O_NAME, 0, &name)) {
-	 obj_name = "Root Object";
-      } else {
-	 obj_name = name.s; /*don't reset message until the end!*/
-      }
-   }
-
-   /*
-    * Create the new root group.  Set the link count to 1.
-    */
-   if (H5G_stab_create (f, size_hint, &new_root/*out*/)<0) {
-      HGOTO_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "cant create root");
-   }
-   if (1!=H5O_link (&new_root, 1)) {
-      HGOTO_ERROR (H5E_SYM, H5E_LINK, FAIL,
-		   "internal error (wrong link count)");
-   }
-
-   /*
-    * If there was a previous root object then insert it into the new root
-    * symbol table with the specified name.  Then make the root object the
-    * new symbol table.
-    */
-   if (f->shared->root_ent) {
-      assert (1==H5O_link (f->shared->root_ent, 0));
-      
-      if (H5G_stab_insert (&new_root, obj_name, f->shared->root_ent)<0) {
-	 HGOTO_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
-		      "can't reinsert old root object");
-      }
-      
-      /*
-       * Remove all `name' messages from the old root object.  The only time
-       * a name message should ever appear is to give the root object a name,
-       * but the old root object is no longer the root object.
-       */
-      H5O_remove (f->shared->root_ent, H5O_NAME, H5O_ALL);
-      H5ECLEAR; /*who really cares?*/
-
-      *(f->shared->root_ent) = new_root;
-      
-   } else {
-      f->shared->root_ent = H5G_ent_calloc (&new_root);
-   }
-
-   H5O_close (&new_root);
-   ret_value = SUCCEED;
-   
- done:
-   H5O_reset (H5O_NAME, &name);
-   FUNC_LEAVE (ret_value);
+    herr_t                  ret_value = FAIL;   /*return value                  */
+    H5O_name_t              name =
+    {NULL};                     /*object name                   */
+    H5O_stab_t              stab;       /*symbol table message          */
+    H5G_entry_t             new_root;   /*new root object               */
+    const char             *obj_name = NULL;    /*name of old root object       */
+
+    FUNC_ENTER(H5G_mkroot, FAIL);
+
+    /* check args */
+    assert(f);
+
+    /*
+     * If we already have a root object, then get it's name.
+     */
+    if (f->shared->root_ent) {
+        if (H5O_read(f->shared->root_ent, H5O_STAB, 0, &stab)) {
+            HGOTO_ERROR(H5E_SYM, H5E_EXISTS, -2, "root group already exists");
+        } else if (NULL == H5O_read(f->shared->root_ent, H5O_NAME, 0, &name)) {
+            obj_name = "Root Object";
+        } else {
+            obj_name = name.s;  /*don't reset message until the end! */
+        }
+    }
+    /*
+     * Create the new root group.  Set the link count to 1.
+     */
+    if (H5G_stab_create(f, size_hint, &new_root /*out */ ) < 0) {
+        HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "cant create root");
+    }
+    if (1 != H5O_link(&new_root, 1)) {
+        HGOTO_ERROR(H5E_SYM, H5E_LINK, FAIL,
+                    "internal error (wrong link count)");
+    }
+    /*
+     * If there was a previous root object then insert it into the new root
+     * symbol table with the specified name.  Then make the root object the
+     * new symbol table.
+     */
+    if (f->shared->root_ent) {
+        assert(1 == H5O_link(f->shared->root_ent, 0));
+
+        if (H5G_stab_insert(&new_root, obj_name, f->shared->root_ent) < 0) {
+            HGOTO_ERROR(H5E_SYM, H5E_CANTINIT, FAIL,
+                        "can't reinsert old root object");
+        }
+        /*
+         * Remove all `name' messages from the old root object.  The only time
+         * a name message should ever appear is to give the root object a name,
+         * but the old root object is no longer the root object.
+         */
+        H5O_remove(f->shared->root_ent, H5O_NAME, H5O_ALL);
+        H5ECLEAR;               /*who really cares? */
+
+        *(f->shared->root_ent) = new_root;
+
+    } else {
+        f->shared->root_ent = H5G_ent_calloc(&new_root);
+    }
+
+    H5O_close(&new_root);
+    ret_value = SUCCEED;
+
+  done:
+    H5O_reset(H5O_NAME, &name);
+    FUNC_LEAVE(ret_value);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_create
+ * Function:    H5G_create
  *
- * Purpose: 	Creates a new empty group with the specified name. The name
- *		is either an absolute name or is relative to the current
- *		working group.
+ * Purpose:     Creates a new empty group with the specified name. The name
+ *              is either an absolute name or is relative to the current
+ *              working group.
  *
- * 		A root group is created implicitly by this function
- *		when necessary.  Calling this function with the name "/"
- *		(or any equivalent name) will result in an H5E_EXISTS
- * 		failure.
+ *              A root group is created implicitly by this function
+ *              when necessary.  Calling this function with the name "/"
+ *              (or any equivalent name) will result in an H5E_EXISTS
+ *              failure.
  *
  * Errors:
  *
- * Return:	Success:	A handle for the group.  The group is opened
- *				and should eventually be close by calling
- *				H5G_close().
+ * Return:      Success:        A handle for the group.  The group is opened
+ *                              and should eventually be close by calling
+ *                              H5G_close().
  *
- *		Failure:	NULL
+ *              Failure:        NULL
  *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Aug 11 1997
+ * Programmer:  Robb Matzke
+ *              matzke@llnl.gov
+ *              Aug 11 1997
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
-H5G_t *
-H5G_create (H5F_t *f, const char *name, size_t size_hint)
+H5G_t                  *
+H5G_create(H5F_t *f, const char *name, size_t size_hint)
 {
-   const char	*rest=NULL;		/*the base name			*/
-   H5G_entry_t	grp_ent;		/*group containing new group	*/
-   char		_comp[1024];		/*name component		*/
-   size_t	nchars;			/*number of characters in compon*/
-   herr_t	status;			/*function return status	*/
-   H5G_t	*grp = NULL;		/*new group			*/
-   
-   FUNC_ENTER (H5G_create, NULL);
-
-   /* check args */
-   assert (f);
-   assert (name && *name);
-
-   /*
-    * Try to create the root group.  Ignore the error if this function
-    * fails because the root group already exists.
-    */
-   if ((status=H5G_mkroot (f, H5G_SIZE_HINT))<0 && -2!=status) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, "can't create root group");
-   }
-   H5ECLEAR;
-
-   /* lookup name */
-   if (0==H5G_namei (f, NULL, name, &rest, &grp_ent, NULL)) {
-      HRETURN_ERROR (H5E_SYM, H5E_EXISTS, NULL, "already exists");
-   }
-   H5ECLEAR; /*it's OK that we didn't find it*/
-   assert (H5F_addr_defined (&(grp_ent.header)));
-
-   /* should be one null-terminated component left */
-   rest = H5G_component (rest, &nchars);
-   assert (rest && *rest);
-   if (rest[nchars]) {
-      if (H5G_component (rest+nchars, NULL)) {
-	 HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "missing component");
-      } else if (nchars+1 > sizeof _comp) {
-	 HRETURN_ERROR (H5E_SYM, H5E_COMPLEN, NULL, "component is too long");
-      } else {
-	 /* null terminate */
-	 HDmemcpy (_comp, rest, nchars);
-	 _comp[nchars] = '\0';
-	 rest = _comp;
-      }
-   }
-   
-   /* create an open group */
-   grp = H5MM_xcalloc (1, sizeof(H5G_t));
-   if (H5G_stab_create (f, size_hint, &(grp->ent)/*out*/)<0) {
-      grp = H5MM_xfree (grp);
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, "can't create grp");
-   }
-
-   /* insert child name into parent */
-   if (H5G_stab_insert (&grp_ent, rest, &(grp->ent))<0) {
-      H5O_close (&(grp->ent));
-      grp = H5MM_xfree (grp);
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, NULL, "can't insert");
-   }
-
-   grp->nref = 1;
-   FUNC_LEAVE (grp);
+    const char             *rest = NULL;        /*the base name                 */
+    H5G_entry_t             grp_ent;    /*group containing new group    */
+    char                    _comp[1024];        /*name component                */
+    size_t                  nchars;     /*number of characters in compon */
+    herr_t                  status;     /*function return status        */
+    H5G_t                  *grp = NULL;         /*new group                     */
+
+    FUNC_ENTER(H5G_create, NULL);
+
+    /* check args */
+    assert(f);
+    assert(name && *name);
+
+    /*
+     * Try to create the root group.  Ignore the error if this function
+     * fails because the root group already exists.
+     */
+    if ((status = H5G_mkroot(f, H5G_SIZE_HINT)) < 0 && -2 != status) {
+        HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, NULL, "can't create root group");
+    }
+    H5ECLEAR;
+
+    /* lookup name */
+    if (0 == H5G_namei(f, NULL, name, &rest, &grp_ent, NULL)) {
+        HRETURN_ERROR(H5E_SYM, H5E_EXISTS, NULL, "already exists");
+    }
+    H5ECLEAR;                   /*it's OK that we didn't find it */
+    assert(H5F_addr_defined(&(grp_ent.header)));
+
+    /* should be one null-terminated component left */
+    rest = H5G_component(rest, &nchars);
+    assert(rest && *rest);
+    if (rest[nchars]) {
+        if (H5G_component(rest + nchars, NULL)) {
+            HRETURN_ERROR(H5E_SYM, H5E_NOTFOUND, NULL, "missing component");
+        } else if (nchars + 1 > sizeof _comp) {
+            HRETURN_ERROR(H5E_SYM, H5E_COMPLEN, NULL, "component is too long");
+        } else {
+            /* null terminate */
+            HDmemcpy(_comp, rest, nchars);
+            _comp[nchars] = '\0';
+            rest = _comp;
+        }
+    }
+    /* create an open group */
+    grp = H5MM_xcalloc(1, sizeof(H5G_t));
+    if (H5G_stab_create(f, size_hint, &(grp->ent) /*out */ ) < 0) {
+        grp = H5MM_xfree(grp);
+        HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, NULL, "can't create grp");
+    }
+    /* insert child name into parent */
+    if (H5G_stab_insert(&grp_ent, rest, &(grp->ent)) < 0) {
+        H5O_close(&(grp->ent));
+        grp = H5MM_xfree(grp);
+        HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, NULL, "can't insert");
+    }
+    grp->nref = 1;
+    FUNC_LEAVE(grp);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_open
+ * Function:    H5G_open
  *
- * Purpose:	Opens an existing group.  The group should eventually be
- *		closed by calling H5G_close().
+ * Purpose:     Opens an existing group.  The group should eventually be
+ *              closed by calling H5G_close().
  *
- * Return:	Success:	Ptr to a new group.
+ * Return:      Success:        Ptr to a new group.
  *
- *		Failure:	NULL
+ *              Failure:        NULL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, January  5, 1998
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
-H5G_t *
-H5G_open (H5F_t *f, const char *name)
+H5G_t                  *
+H5G_open(H5F_t *f, const char *name)
 {
-   H5G_t	*grp = NULL;
-   H5G_t	*ret_value = NULL;
-   
-   FUNC_ENTER (H5G_open, NULL);
-
-   /* Check args */
-   assert (f);
-   assert (name && *name);
-
-   /* Open the group */
-   grp = H5MM_xcalloc (1, sizeof(H5G_t));
-   if (H5G_find (f, name, NULL, &(grp->ent))<0) {
-      HGOTO_ERROR (H5E_SYM, H5E_NOTFOUND, NULL, "group not found");
-   }
-   if (H5O_open (f, &(grp->ent))<0) {
-      HGOTO_ERROR (H5E_SYM, H5E_CANTOPENOBJ, NULL, "unable to open group");
-   }
-   grp->nref = 1;
-   ret_value = grp;
-   
- done:
-   if (!ret_value && grp) {
-      H5MM_xfree (grp);
-   }
-
-   FUNC_LEAVE (ret_value);
+    H5G_t                  *grp = NULL;
+    H5G_t                  *ret_value = NULL;
+
+    FUNC_ENTER(H5G_open, NULL);
+
+    /* Check args */
+    assert(f);
+    assert(name && *name);
+
+    /* Open the group */
+    grp = H5MM_xcalloc(1, sizeof(H5G_t));
+    if (H5G_find(f, name, NULL, &(grp->ent)) < 0) {
+        HGOTO_ERROR(H5E_SYM, H5E_NOTFOUND, NULL, "group not found");
+    }
+    if (H5O_open(f, &(grp->ent)) < 0) {
+        HGOTO_ERROR(H5E_SYM, H5E_CANTOPENOBJ, NULL, "unable to open group");
+    }
+    grp->nref = 1;
+    ret_value = grp;
+
+  done:
+    if (!ret_value && grp) {
+        H5MM_xfree(grp);
+    }
+    FUNC_LEAVE(ret_value);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_reopen
+ * Function:    H5G_reopen
  *
- * Purpose:	Reopens a group by incrementing the open count.
+ * Purpose:     Reopens a group by incrementing the open count.
  *
- * Return:	Success:	The GRP argument.
+ * Return:      Success:        The GRP argument.
  *
- *		Failure:	NULL
+ *              Failure:        NULL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, January  5, 1998
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
-H5G_t *
-H5G_reopen (H5G_t *grp)
+H5G_t                  *
+H5G_reopen(H5G_t *grp)
 {
-   FUNC_ENTER (H5G_reopen, NULL);
+    FUNC_ENTER(H5G_reopen, NULL);
 
-   assert (grp);
-   assert (grp->nref>0);
+    assert(grp);
+    assert(grp->nref > 0);
 
-   grp->nref++;
+    grp->nref++;
 
-   FUNC_LEAVE (grp);
+    FUNC_LEAVE(grp);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_close
+ * Function:    H5G_close
  *
- * Purpose:	Closes the specified group.
+ * Purpose:     Closes the specified group.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, January  5, 1998
  *
  * Modifications:
@@ -953,47 +918,46 @@ H5G_reopen (H5G_t *grp)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5G_close (H5G_t *grp)
+H5G_close(H5G_t *grp)
 {
-   FUNC_ENTER (H5G_close, FAIL);
+    FUNC_ENTER(H5G_close, FAIL);
 
-   /* Check args */
-   assert (grp);
-   assert (grp->nref>0);
+    /* Check args */
+    assert(grp);
+    assert(grp->nref > 0);
 
-   if (1==grp->nref) {
-      if (H5O_close (&(grp->ent))<0) {
-	 HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "unable to close");
-      }
-   }
-   --grp->nref;
+    if (1 == grp->nref) {
+        if (H5O_close(&(grp->ent)) < 0) {
+            HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "unable to close");
+        }
+    }
+    --grp->nref;
 
-   FUNC_LEAVE (SUCCEED);
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_set
+ * Function:    H5G_set
  *
- * Purpose:	Sets the current working group to be the specified group.
- *		This affects only the top item on the group stack for the
- *		specified file as accessed through this file handle.  If the
- *		file is opened multiple times, then the current working group
- *		for this file handle is the only one that is changed.
+ * Purpose:     Sets the current working group to be the specified group.
+ *              This affects only the top item on the group stack for the
+ *              specified file as accessed through this file handle.  If the
+ *              file is opened multiple times, then the current working group
+ *              for this file handle is the only one that is changed.
  *
- * Note:	The group is re-opened and held open until it is removed from
- *		the current working group stack.
+ * Note:        The group is re-opened and held open until it is removed from
+ *              the current working group stack.
  *
  * Errors:
- *		SYM       CWG           Can't open group. 
- *		SYM       CWG           Couldn't close previous c.w.g. 
- *		SYM       CWG           Not a group. 
+ *              SYM       CWG           Can't open group. 
+ *              SYM       CWG           Couldn't close previous c.w.g. 
+ *              SYM       CWG           Not a group. 
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, September 24, 1997
  *
  * Modifications:
@@ -1001,87 +965,85 @@ H5G_close (H5G_t *grp)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5G_set (H5F_t *f, H5G_t *grp)
+H5G_set(H5F_t *f, H5G_t *grp)
 {
-   FUNC_ENTER (H5G_set, FAIL);
-
-   /* check args */
-   assert (f);
-   assert (grp);
-
-   /*
-    * If there is no stack then create one, otherwise close the current
-    * working group.
-    */
-   if (!f->cwg_stack) {
-      f->cwg_stack = H5MM_xcalloc (1, sizeof(H5G_cwgstk_t));
-   } else if (H5G_close (f->cwg_stack->grp)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_CWG, FAIL, "couldn't close previous c.w.g.");
-   }
-   f->cwg_stack->grp = H5G_reopen (grp);
-
-   FUNC_LEAVE (SUCCEED);
+    FUNC_ENTER(H5G_set, FAIL);
+
+    /* check args */
+    assert(f);
+    assert(grp);
+
+    /*
+     * If there is no stack then create one, otherwise close the current
+     * working group.
+     */
+    if (!f->cwg_stack) {
+        f->cwg_stack = H5MM_xcalloc(1, sizeof(H5G_cwgstk_t));
+    } else if (H5G_close(f->cwg_stack->grp) < 0) {
+        HRETURN_ERROR(H5E_SYM, H5E_CWG, FAIL, "couldn't close previous c.w.g.");
+    }
+    f->cwg_stack->grp = H5G_reopen(grp);
+
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_getcwg
+ * Function:    H5G_getcwg
  *
- * Purpose:	Returns a ptr to the symbol table entry for the current
- *		working group.  If there is no current working group then a
- *		pointer to the root symbol is returned.  If there is no root
- *		symbol then the null pointer is returned.
+ * Purpose:     Returns a ptr to the symbol table entry for the current
+ *              working group.  If there is no current working group then a
+ *              pointer to the root symbol is returned.  If there is no root
+ *              symbol then the null pointer is returned.
  *
- * Return:	Success:	Ptr to the current working group or root
- *				object. The pointer is valid only until the
- *				root object changes or the current working
- *				group changes.
+ * Return:      Success:        Ptr to the current working group or root
+ *                              object. The pointer is valid only until the
+ *                              root object changes or the current working
+ *                              group changes.
  *
- *		Failure:	NULL
+ *              Failure:        NULL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, September 24, 1997
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
-static H5G_entry_t *
-H5G_getcwg (H5F_t *f)
+static H5G_entry_t     *
+H5G_getcwg(H5F_t *f)
 {
-   H5G_entry_t	*ret_value=NULL;
-   
-   FUNC_ENTER (H5G_getcwg, NULL);
-
-   /* check args */
-   assert (f);
-   
-   /* return a pointer directly into the stack */
-   if (f->cwg_stack && f->cwg_stack->grp) {
-      ret_value = &(f->cwg_stack->grp->ent);
-   } else {
-      ret_value = f->shared->root_ent;
-   }
-
-   FUNC_LEAVE (ret_value);
-}
+    H5G_entry_t            *ret_value = NULL;
 
+    FUNC_ENTER(H5G_getcwg, NULL);
+
+    /* check args */
+    assert(f);
+
+    /* return a pointer directly into the stack */
+    if (f->cwg_stack && f->cwg_stack->grp) {
+        ret_value = &(f->cwg_stack->grp->ent);
+    } else {
+        ret_value = f->shared->root_ent;
+    }
+
+    FUNC_LEAVE(ret_value);
+}
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_push
+ * Function:    H5G_push
  *
- * Purpose:	Pushes a new current working group onto the stack.  The GRP
- *		is reopened and held open until it is removed from the stack.
+ * Purpose:     Pushes a new current working group onto the stack.  The GRP
+ *              is reopened and held open until it is removed from the stack.
  *
  * Errors:
- *		SYM       CWG           Can't open group. 
- *		SYM       CWG           Not a group. 
+ *              SYM       CWG           Can't open group. 
+ *              SYM       CWG           Not a group. 
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Friday, September 19, 1997
  *
  * Modifications:
@@ -1089,42 +1051,41 @@ H5G_getcwg (H5F_t *f)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5G_push (H5F_t *f, H5G_t *grp)
+H5G_push(H5F_t *f, H5G_t *grp)
 {
-   H5G_cwgstk_t	*stack=NULL;
-   
-   FUNC_ENTER (H5G_push, FAIL);
-
-   /* check args */
-   assert (f);
-   assert (grp);
-   
-   /*
-    * Push a new entry onto the stack.
-    */
-   stack = H5MM_xcalloc (1, sizeof(H5G_cwgstk_t));
-   stack->grp = H5G_reopen (grp);
-   stack->next = f->cwg_stack;
-   f->cwg_stack = stack;
-
-   FUNC_LEAVE (SUCCEED);
-}
+    H5G_cwgstk_t           *stack = NULL;
+
+    FUNC_ENTER(H5G_push, FAIL);
+
+    /* check args */
+    assert(f);
+    assert(grp);
+
+    /*
+     * Push a new entry onto the stack.
+     */
+    stack = H5MM_xcalloc(1, sizeof(H5G_cwgstk_t));
+    stack->grp = H5G_reopen(grp);
+    stack->next = f->cwg_stack;
+    f->cwg_stack = stack;
 
+    FUNC_LEAVE(SUCCEED);
+}
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_pop
+ * Function:    H5G_pop
  *
- * Purpose:	Pops the top current working group off the stack.
+ * Purpose:     Pops the top current working group off the stack.
  *
  * Errors:
- *		SYM       CWG           Can't close current working group. 
- *		SYM       CWG           Stack is empty. 
+ *              SYM       CWG           Can't close current working group. 
+ *              SYM       CWG           Stack is empty. 
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL if the stack is empty.
+ *              Failure:        FAIL if the stack is empty.
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Friday, September 19, 1997
  *
  * Modifications:
@@ -1132,44 +1093,43 @@ H5G_push (H5F_t *f, H5G_t *grp)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5G_pop (H5F_t *f)
+H5G_pop(H5F_t *f)
 {
-   H5G_cwgstk_t	*stack=NULL;
-   
-   FUNC_ENTER (H5G_pop, FAIL);
-
-   /* check args */
-   assert (f);
-   
-   if ((stack=f->cwg_stack)) {
-      if (H5G_close (stack->grp)<0) {
-	 HRETURN_ERROR (H5E_SYM, H5E_CWG, FAIL,
-			"can't close current working group");
-      }
-      f->cwg_stack = stack->next;
-      stack->grp = NULL;
-      H5MM_xfree (stack);
-   } else {
-      HRETURN_ERROR (H5E_SYM, H5E_CWG, FAIL, "stack is empty");
-   }
-
-   FUNC_LEAVE (SUCCEED);
+    H5G_cwgstk_t           *stack = NULL;
+
+    FUNC_ENTER(H5G_pop, FAIL);
+
+    /* check args */
+    assert(f);
+
+    if ((stack = f->cwg_stack)) {
+        if (H5G_close(stack->grp) < 0) {
+            HRETURN_ERROR(H5E_SYM, H5E_CWG, FAIL,
+                          "can't close current working group");
+        }
+        f->cwg_stack = stack->next;
+        stack->grp = NULL;
+        H5MM_xfree(stack);
+    } else {
+        HRETURN_ERROR(H5E_SYM, H5E_CWG, FAIL, "stack is empty");
+    }
+
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_insert
+ * Function:    H5G_insert
  *
- * Purpose:	Inserts a symbol table entry into the group graph.  The file
- *		that is used is contained in the ENT argument.
+ * Purpose:     Inserts a symbol table entry into the group graph.  The file
+ *              that is used is contained in the ENT argument.
  *
  * Errors:
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Friday, September 19, 1997
  *
  * Modifications:
@@ -1177,156 +1137,150 @@ H5G_pop (H5F_t *f)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5G_insert (const char *name, H5G_entry_t *ent)
+H5G_insert(const char *name, H5G_entry_t *ent)
 {
-   const char	*rest = NULL;		/*part of name not existing yet	*/
-   H5G_entry_t	grp;			/*entry for group to contain obj*/
-   size_t	nchars;			/*number of characters in name	*/
-   char		_comp[1024];		/*name component		*/
-   hbool_t	update_grp;
-   herr_t	status;
-   
-   FUNC_ENTER (H5G_insert, FAIL);
-
-   /* Check args. */
-   assert (name && *name);
-   assert (ent);
-
-   /*
-    * Look up the name -- it shouldn't exist yet.
-    */
-   if (H5G_namei (ent->file, NULL, name, &rest, &grp, NULL)>=0) {
-      HRETURN_ERROR (H5E_SYM, H5E_EXISTS, FAIL, "already exists");
-   }
-   H5ECLEAR; /*it's OK that we didn't find it*/
-   rest = H5G_component (rest, &nchars);
-
-   if (!rest || !*rest) {
-      /*
-       * The caller is attempting to insert a root object that either
-       * doesn't have a name or we shouldn't interfere with the name
-       * it already has as a message.
-       */
-      if (ent->file->shared->root_ent) {
-	 HRETURN_ERROR (H5E_SYM, H5E_EXISTS, FAIL, "root exists");
-      }
-      if (1!=H5O_link (ent, 1)) {
-	 HRETURN_ERROR (H5E_SYM, H5E_LINK, FAIL, "bad link count");
-      }
-      ent->name_off = 0;
-      ent->file->shared->root_ent = H5G_ent_calloc (ent);
-      HRETURN (SUCCEED);
-   }
-
-   /*
-    * There should be one component left.  Make sure it's null
-    * terminated.
-    */
-   if (rest[nchars]) {
-      if (H5G_component (rest+nchars, NULL)) {
-	 HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "component not found");
-      } else if (nchars+1 > sizeof _comp) {
-	 HRETURN_ERROR (H5E_SYM, H5E_COMPLEN, FAIL, "component is too long");
-      } else {
-	 /* null terminate */
-	 HDmemcpy (_comp, rest, nchars);
-	 _comp[nchars] = '\0';
-	 rest = _comp;
-      }
-   }
-
-   if (!ent->file->shared->root_ent) {
-      /*
-       * This will be the only object in the file. Insert it as the root
-       * object and add a name messaage to the object header (or modify
-       * the first one we find).
-       */
-      H5O_name_t name_mesg;
-      name_mesg.s = rest;
-      if (H5O_modify (ent, H5O_NAME, 0, 0, &name_mesg)<0) {
-	 HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL,
-			"cannot add/change name message");
-      }
-      if (1!=H5O_link (ent, 1)) {
-	 HRETURN_ERROR (H5E_SYM, H5E_LINK, FAIL, "bad link count");
-      }
-      ent->file->shared->root_ent = H5G_ent_calloc (ent);
-      HRETURN (SUCCEED);
-   }
-
-   /*
-    * Make sure the root group exists.  Ignore the failure if it's
-    * because the group already exists.
-    */
-   update_grp = H5F_addr_eq (&(grp.header),
-			     &(ent->file->shared->root_ent->header));
-   if ((status=H5G_mkroot (ent->file, H5G_SIZE_HINT))<0 && -2!=status) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "can't create root group");
-   }
-   H5ECLEAR;
-   if (update_grp) grp = *(ent->file->shared->root_ent);
-
-   
-   /*
-    * This is the normal case.  The object is just being inserted as a normal
-    * entry into a symbol table.
-    */
-   if (H5O_link (ent, 1)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_LINK, FAIL, "link inc failure");
-   }
-   if (H5G_stab_insert (&grp, rest, ent)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_CANTINIT, FAIL, "can't insert");
-   }
-
-   FUNC_LEAVE (SUCCEED);
+    const char             *rest = NULL;        /*part of name not existing yet */
+    H5G_entry_t             grp;        /*entry for group to contain obj */
+    size_t                  nchars;     /*number of characters in name  */
+    char                    _comp[1024];        /*name component                */
+    hbool_t                 update_grp;
+    herr_t                  status;
+
+    FUNC_ENTER(H5G_insert, FAIL);
+
+    /* Check args. */
+    assert(name && *name);
+    assert(ent);
+
+    /*
+     * Look up the name -- it shouldn't exist yet.
+     */
+    if (H5G_namei(ent->file, NULL, name, &rest, &grp, NULL) >= 0) {
+        HRETURN_ERROR(H5E_SYM, H5E_EXISTS, FAIL, "already exists");
+    }
+    H5ECLEAR;                   /*it's OK that we didn't find it */
+    rest = H5G_component(rest, &nchars);
+
+    if (!rest || !*rest) {
+        /*
+         * The caller is attempting to insert a root object that either
+         * doesn't have a name or we shouldn't interfere with the name
+         * it already has as a message.
+         */
+        if (ent->file->shared->root_ent) {
+            HRETURN_ERROR(H5E_SYM, H5E_EXISTS, FAIL, "root exists");
+        }
+        if (1 != H5O_link(ent, 1)) {
+            HRETURN_ERROR(H5E_SYM, H5E_LINK, FAIL, "bad link count");
+        }
+        ent->name_off = 0;
+        ent->file->shared->root_ent = H5G_ent_calloc(ent);
+        HRETURN(SUCCEED);
+    }
+    /*
+     * There should be one component left.  Make sure it's null
+     * terminated.
+     */
+    if (rest[nchars]) {
+        if (H5G_component(rest + nchars, NULL)) {
+            HRETURN_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "component not found");
+        } else if (nchars + 1 > sizeof _comp) {
+            HRETURN_ERROR(H5E_SYM, H5E_COMPLEN, FAIL, "component is too long");
+        } else {
+            /* null terminate */
+            HDmemcpy(_comp, rest, nchars);
+            _comp[nchars] = '\0';
+            rest = _comp;
+        }
+    }
+    if (!ent->file->shared->root_ent) {
+        /*
+         * This will be the only object in the file. Insert it as the root
+         * object and add a name messaage to the object header (or modify
+         * the first one we find).
+         */
+        H5O_name_t              name_mesg;
+        name_mesg.s = rest;
+        if (H5O_modify(ent, H5O_NAME, 0, 0, &name_mesg) < 0) {
+            HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, FAIL,
+                          "cannot add/change name message");
+        }
+        if (1 != H5O_link(ent, 1)) {
+            HRETURN_ERROR(H5E_SYM, H5E_LINK, FAIL, "bad link count");
+        }
+        ent->file->shared->root_ent = H5G_ent_calloc(ent);
+        HRETURN(SUCCEED);
+    }
+    /*
+     * Make sure the root group exists.  Ignore the failure if it's
+     * because the group already exists.
+     */
+    update_grp = H5F_addr_eq(&(grp.header),
+                             &(ent->file->shared->root_ent->header));
+    if ((status = H5G_mkroot(ent->file, H5G_SIZE_HINT)) < 0 && -2 != status) {
+        HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "can't create root group");
+    }
+    H5ECLEAR;
+    if (update_grp)
+        grp = *(ent->file->shared->root_ent);
+
+    /*
+     * This is the normal case.  The object is just being inserted as a normal
+     * entry into a symbol table.
+     */
+    if (H5O_link(ent, 1) < 0) {
+        HRETURN_ERROR(H5E_SYM, H5E_LINK, FAIL, "link inc failure");
+    }
+    if (H5G_stab_insert(&grp, rest, ent) < 0) {
+        HRETURN_ERROR(H5E_SYM, H5E_CANTINIT, FAIL, "can't insert");
+    }
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5G_find
- *
- * Purpose:	Finds an object with the specified NAME in file F.  If
- *		the name is relative then it is interpretted relative
- *		to the current working group.  On successful return,
- *		GRP_ENT (if non-null) will be initialized with the symbol
- *		table information for the group in which the object
- *		appears (it will have an undefined object header address if
- *		the object is the root object) and OBJ_ENT will be
- *		initialized with the symbol table entry for the object
- *		(OBJ_ENT is optional when the caller is interested only in
- * 		the existence of the object).
- *
- *		This function will fail if the root object is requested and
- *		there is none.
+ * Function:    H5G_find
+ *
+ * Purpose:     Finds an object with the specified NAME in file F.  If
+ *              the name is relative then it is interpretted relative
+ *              to the current working group.  On successful return,
+ *              GRP_ENT (if non-null) will be initialized with the symbol
+ *              table information for the group in which the object
+ *              appears (it will have an undefined object header address if
+ *              the object is the root object) and OBJ_ENT will be
+ *              initialized with the symbol table entry for the object
+ *              (OBJ_ENT is optional when the caller is interested only in
+ *              the existence of the object).
+ *
+ *              This function will fail if the root object is requested and
+ *              there is none.
  *
  * Errors:
  *
- * Return:	Success:	SUCCEED, see above for values of GRP_ENT and
- *				OBJ_ENT.
+ * Return:      Success:        SUCCEED, see above for values of GRP_ENT and
+ *                              OBJ_ENT.
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
- *		matzke@llnl.gov
- *		Aug 12 1997
+ * Programmer:  Robb Matzke
+ *              matzke@llnl.gov
+ *              Aug 12 1997
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
 herr_t
-H5G_find (H5F_t *f, const char *name,
-	  H5G_entry_t *grp_ent/*out*/, H5G_entry_t *obj_ent/*out*/)
+H5G_find(H5F_t *f, const char *name,
+         H5G_entry_t *grp_ent /*out */ , H5G_entry_t *obj_ent /*out */ )
 {
-   FUNC_ENTER (H5G_find, FAIL);
-
-   /* check args */
-   assert (f);
-   assert (name && *name);
+    FUNC_ENTER(H5G_find, FAIL);
 
-   if (H5G_namei (f, NULL, name, NULL, grp_ent, obj_ent)<0) {
-      HRETURN_ERROR (H5E_SYM, H5E_NOTFOUND, FAIL, "object not found");
-   }
+    /* check args */
+    assert(f);
+    assert(name && *name);
 
-   FUNC_LEAVE (SUCCEED);
+    if (H5G_namei(f, NULL, name, NULL, grp_ent, obj_ent) < 0) {
+        HRETURN_ERROR(H5E_SYM, H5E_NOTFOUND, FAIL, "object not found");
+    }
+    FUNC_LEAVE(SUCCEED);
 }