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

1 files changed, 409 insertions, 445 deletions

diff --git a/src/H5A.c b/src/H5A.c
index b0d9965..8e20c02 100644
--- a/src/H5A.c
+++ b/src/H5A.c
@@ -11,85 +11,87 @@
  ****************************************************************************/
 
 #ifdef RCSID
-static char RcsId[] = "@(#)$Revision$";
+static char             RcsId[] = "@(#)$Revision$";
 #endif
 
 /* $Id$ */
 
 /*
-FILE
-    atom.c - Internal storage routines for handling "atoms"
-
-REMARKS
-    Atoms are just ID's which allow objects (void *'s currently) to be
-    bundled into "groups" for more general storage.
-
-DESIGN
-    The groups are stored in an array of pointers to store each group in an
-    element. Each "atomic group" node contains a link to a hash table to
-    manage the atoms in each group.  The allowed "atomic groups" are stored
-    in an enum (called group_t) in atom.h.
-
-BUGS/LIMITATIONS
-    Can't interate over the atoms in a group.
-
-LOCAL ROUTINES
-  H5A_find_atom      - Returns a pointer to an atom_info_t from a atom ID
-  H5A_get_atom_node  - Gets an atom node (uses the atom free list)
-  H5A_release_atom_node - Releases an atom node (uses the atom free list)
-EXPORTED ROUTINES
- Atom Functions:
-  H5Aregister_atom   - Register an object in a group and get an atom for it
-  H5Aatom_object     - Get the object for an atom
-  H5Aatom_group      - Get the group for an atom
-  H5Aremove_atom     - Remove an atom from a group
-  H5Asearch_atom     - Search a group for a particular object
-  H5Ais_reserved     - Check whether an atom is a reserved atom in a group
- Atom Group Functions:
-  H5Ainit_group      - Initialize a group to store atoms in
-  H5Adestroy_group   - Destroy an atomic group
- Atom Group Cleanup:
-  H5Ashutdown        - Terminate various static buffers.
-
-AUTHOR
+   FILE
+   atom.c - Internal storage routines for handling "atoms"
+
+   REMARKS
+   Atoms are just ID's which allow objects (void *'s currently) to be
+   bundled into "groups" for more general storage.
+
+   DESIGN
+   The groups are stored in an array of pointers to store each group in an
+   element. Each "atomic group" node contains a link to a hash table to
+   manage the atoms in each group.  The allowed "atomic groups" are stored
+   in an enum (called group_t) in atom.h.
+
+   BUGS/LIMITATIONS
+   Can't interate over the atoms in a group.
+
+   LOCAL ROUTINES
+   H5A_find_atom      - Returns a pointer to an atom_info_t from a atom ID
+   H5A_get_atom_node  - Gets an atom node (uses the atom free list)
+   H5A_release_atom_node - Releases an atom node (uses the atom free list)
+   EXPORTED ROUTINES
+   Atom Functions:
+   H5Aregister_atom   - Register an object in a group and get an atom for it
+   H5Aatom_object     - Get the object for an atom
+   H5Aatom_group      - Get the group for an atom
+   H5Aremove_atom     - Remove an atom from a group
+   H5Asearch_atom     - Search a group for a particular object
+   H5Ais_reserved     - Check whether an atom is a reserved atom in a group
+   Atom Group Functions:
+   H5Ainit_group      - Initialize a group to store atoms in
+   H5Adestroy_group   - Destroy an atomic group
+   Atom Group Cleanup:
+   H5Ashutdown        - Terminate various static buffers.
+
+   AUTHOR
    Quincey Koziol
 
-MODIFICATION HISTORY
+   MODIFICATION HISTORY
    1/3/96  - Starting writing specs & coding prototype
    1/7/96  - Finished coding prototype
    6/10/97 - Moved into HDF5 library
-*/
+ */
 
 #include <H5private.h>
 #include <H5Aprivate.h>
 #include <H5Eprivate.h>
 
-#define PABLO_MASK	H5A_mask
-
+#define PABLO_MASK      H5A_mask
 
 /*-------------------- Locally scoped variables -----------------------------*/
 
 #ifdef ATOMS_ARE_CACHED
 /* Array of pointers to atomic groups */
-static hid_t atom_id_cache[ATOM_CACHE_SIZE]={-1,-1,-1,-1};
-static VOIDP atom_obj_cache[ATOM_CACHE_SIZE]={NULL};
+static hid_t            atom_id_cache[ATOM_CACHE_SIZE] =
+{-1, -1, -1, -1};
+static VOIDP            atom_obj_cache[ATOM_CACHE_SIZE] =
+{NULL};
 #endif
 
 /* Array of pointers to atomic groups */
-static atom_group_t *atom_group_list[MAXGROUP]={NULL};
+static atom_group_t    *atom_group_list[MAXGROUP] =
+{NULL};
 
 /* Pointer to the atom node free list */
-static atom_info_t *atom_free_list=NULL;
+static atom_info_t     *atom_free_list = NULL;
 
 /* Interface initialialization? */
-static hbool_t interface_initialize_g = FALSE;
+static hbool_t          interface_initialize_g = FALSE;
 #define INTERFACE_INIT H5A_init_interface
-static herr_t H5A_init_interface(void);
+static herr_t           H5A_init_interface(void);
 
 /*--------------------- Local function prototypes ---------------------------*/
-static atom_info_t *H5A_find_atom(hid_t atm);
-static atom_info_t *H5A_get_atom_node(void);
-static herr_t H5A_release_atom_node(atom_info_t *atm);
+static atom_info_t     *H5A_find_atom(hid_t atm);
+static atom_info_t     *H5A_get_atom_node(void);
+static herr_t           H5A_release_atom_node(atom_info_t *atm);
 
 /*--------------------------------------------------------------------------
 NAME
@@ -101,16 +103,17 @@ RETURNS
 DESCRIPTION
     Initializes any interface-specific data or routines.
 --------------------------------------------------------------------------*/
-static herr_t H5A_init_interface(void)
+static herr_t 
+H5A_init_interface(void)
 {
-    herr_t ret_value = SUCCEED;
-    FUNC_ENTER (H5A_init_interface, FAIL);
+    herr_t                  ret_value = SUCCEED;
+    FUNC_ENTER(H5A_init_interface, FAIL);
 
     /* Registers the cleanup routine with the exit chain */
-    ret_value=H5_add_exit(&H5A_term_interface);
+    ret_value = H5_add_exit(&H5A_term_interface);
 
     FUNC_LEAVE(ret_value);
-}	/* H5E_init_interface */
+}                               /* H5E_init_interface */
 
 /******************************************************************************
  NAME
@@ -129,76 +132,72 @@ static herr_t H5A_init_interface(void)
     Returns SUCCEED if successful and FAIL otherwise
 
 *******************************************************************************/
-intn H5Ainit_group(group_t grp,      /* IN: Group to initialize */
-    intn hash_size,                 /* IN: Minimum hash table size to use for group */
-    uintn reserved,                 /* IN: Number of hash table entries to reserve */
-    herr_t (*free_func)(void *)            /* IN: Function to call when releasing ref counted objects */
+intn 
+H5Ainit_group(group_t grp,      /* IN: Group to initialize */
+              intn hash_size,   /* IN: Minimum hash table size to use for group */
+              uintn reserved,   /* IN: Number of hash table entries to reserve */
+              herr_t                  (*free_func) (void *)     /* IN: Function to call when releasing ref counted objects */
 )
 {
-    atom_group_t *grp_ptr=NULL;     /* ptr to the atomic group */
-    intn ret_value=SUCCEED;
+    atom_group_t           *grp_ptr = NULL;     /* ptr to the atomic group */
+    intn                    ret_value = SUCCEED;
 
-    FUNC_ENTER (H5Ainit_group, FAIL);
+    FUNC_ENTER(H5Ainit_group, FAIL);
 
-    if((grp<=BADGROUP || grp>=MAXGROUP) && hash_size>0)
+    if ((grp <= BADGROUP || grp >= MAXGROUP) && hash_size > 0)
         HGOTO_DONE(FAIL);
 
 #ifdef HASH_SIZE_POWER_2
     /* If anyone knows a faster test for a power of two, please change this silly code -QAK */
-    if(!(hash_size==2 || hash_size==4 || hash_size==8 || hash_size==16
-            || hash_size==32 || hash_size==64 || hash_size==128 || hash_size==256
-            || hash_size==512 || hash_size==1024 || hash_size==2048
-            || hash_size==4096 || hash_size==8192 || hash_size==16374
-            || hash_size==32768 || hash_size==65536 || hash_size==131072
-            || hash_size==262144 || hash_size==524288 || hash_size==1048576
-            || hash_size==2097152 || hash_size==4194304 || hash_size==8388608
-            || hash_size==16777216 || hash_size==33554432 || hash_size==67108864
-            || hash_size==134217728 || hash_size==268435456))
+    if (!(hash_size == 2 || hash_size == 4 || hash_size == 8 || hash_size == 16
+          || hash_size == 32 || hash_size == 64 || hash_size == 128 || hash_size == 256
+          || hash_size == 512 || hash_size == 1024 || hash_size == 2048
+          || hash_size == 4096 || hash_size == 8192 || hash_size == 16374
+          || hash_size == 32768 || hash_size == 65536 || hash_size == 131072
+       || hash_size == 262144 || hash_size == 524288 || hash_size == 1048576
+     || hash_size == 2097152 || hash_size == 4194304 || hash_size == 8388608
+          || hash_size == 16777216 || hash_size == 33554432 || hash_size == 67108864
+          || hash_size == 134217728 || hash_size == 268435456))
         HGOTO_DONE(FAIL);
 #endif /* HASH_SIZE_POWER_2 */
 
-    if(atom_group_list[grp]==NULL)
-      {     /* Allocate the group information */
-          grp_ptr=(atom_group_t *)HDcalloc(1,sizeof(atom_group_t));
-          if(grp_ptr==NULL)
-              HGOTO_DONE(FAIL);
-          atom_group_list[grp]=grp_ptr;
-      } /* end if */
-    else /* Get the pointer to the existing group */
-        grp_ptr=atom_group_list[grp];
-
-    if(grp_ptr->count==0)
-      {     /* Initialize the atom group structure */
-        grp_ptr->hash_size=hash_size;
-        grp_ptr->reserved=reserved;
-        grp_ptr->wrapped=0;
-        grp_ptr->atoms=0;
-        grp_ptr->nextid=reserved;
-        grp_ptr->free_func=free_func;
-        if((grp_ptr->atom_list=(atom_info_t **)HDcalloc(hash_size,sizeof(atom_info_t *)))==NULL)
+    if (atom_group_list[grp] == NULL) {         /* Allocate the group information */
+        grp_ptr = (atom_group_t *) HDcalloc(1, sizeof(atom_group_t));
+        if (grp_ptr == NULL)
             HGOTO_DONE(FAIL);
-      } /* end if */
-
+        atom_group_list[grp] = grp_ptr;
+    }
+    /* end if */ 
+    else                        /* Get the pointer to the existing group */
+        grp_ptr = atom_group_list[grp];
+
+    if (grp_ptr->count == 0) {  /* Initialize the atom group structure */
+        grp_ptr->hash_size = hash_size;
+        grp_ptr->reserved = reserved;
+        grp_ptr->wrapped = 0;
+        grp_ptr->atoms = 0;
+        grp_ptr->nextid = reserved;
+        grp_ptr->free_func = free_func;
+        if ((grp_ptr->atom_list = (atom_info_t **) HDcalloc(hash_size, sizeof(atom_info_t *))) == NULL)
+                                    HGOTO_DONE(FAIL);
+    }                           /* end if */
     /* Increment the count of the times this group has been initialized */
     grp_ptr->count++;
 
 #ifdef QAK
-printf("%s: group ID=%d, count=%d, current # of active atoms=%d\n",FUNC,grp,grp_ptr->count,grp_ptr->atoms);
+    printf("%s: group ID=%d, count=%d, current # of active atoms=%d\n", FUNC, grp, grp_ptr->count, grp_ptr->atoms);
 #endif /* QAK */
-done:
-  if(ret_value == FAIL)   
-    { /* Error condition cleanup */
-        if(grp_ptr!=NULL)
-          {
-            if(grp_ptr->atom_list!=NULL)
+  done:
+    if (ret_value == FAIL) {    /* Error condition cleanup */
+        if (grp_ptr != NULL) {
+            if (grp_ptr->atom_list != NULL)
                 HDfree(grp_ptr->atom_list);
             HDfree(grp_ptr);
-          } /* end if */
-    } /* end if */
-
+        }                       /* end if */
+    }                           /* end if */
     /* Normal function cleanup */
     FUNC_LEAVE(ret_value);
-}   /* end H5Ainit_group() */
+}                               /* end H5Ainit_group() */
 
 /******************************************************************************
  NAME
@@ -214,51 +213,47 @@ done:
     Returns SUCCEED if successful and FAIL otherwise
 
 *******************************************************************************/
-intn H5Adestroy_group(group_t grp       /* IN: Group to destroy */
+intn 
+H5Adestroy_group(group_t grp    /* IN: Group to destroy */
 )
 {
-    atom_group_t *grp_ptr=NULL;     /* ptr to the atomic group */
-    intn ret_value=SUCCEED;
+    atom_group_t           *grp_ptr = NULL;     /* ptr to the atomic group */
+    intn                    ret_value = SUCCEED;
 
-    FUNC_ENTER (H5Adestroy_group, FAIL);
+    FUNC_ENTER(H5Adestroy_group, FAIL);
 
-    if(grp<=BADGROUP || grp>=MAXGROUP)
+    if (grp <= BADGROUP || grp >= MAXGROUP)
         HGOTO_DONE(FAIL);
 
-    grp_ptr=atom_group_list[grp];
-    if(grp_ptr==NULL || grp_ptr->count<=0)
+    grp_ptr = atom_group_list[grp];
+    if (grp_ptr == NULL || grp_ptr->count <= 0)
         HGOTO_DONE(FAIL);
 
 #ifdef QAK
-printf("%s: group ID=%d, count=%d, current # of active atoms=%d\n",FUNC,grp,grp_ptr->count,grp_ptr->atoms);
+    printf("%s: group ID=%d, count=%d, current # of active atoms=%d\n", FUNC, grp, grp_ptr->count, grp_ptr->atoms);
 #endif /* QAK */
     /* Decrement the number of users of the atomic group */
-    if((--(grp_ptr->count))==0)
-      {
+    if ((--(grp_ptr->count)) == 0) {
 #ifdef ATOMS_ARE_CACHED
-      {
-        uintn i;
-
-        for(i=0; i<ATOM_CACHE_SIZE; i++)
-            if(ATOM_TO_GROUP(atom_id_cache[i])==grp)
-              {
-                atom_id_cache[i]=(-1);
-                atom_obj_cache[i]=NULL;
-              } /* end if */
-      } /* end block */
+        {
+            uintn                   i;
+
+            for (i = 0; i < ATOM_CACHE_SIZE; i++)
+                if (ATOM_TO_GROUP(atom_id_cache[i]) == grp) {
+                    atom_id_cache[i] = (-1);
+                    atom_obj_cache[i] = NULL;
+                }               /* end if */
+        }                       /* end block */
 #endif /* ATOMS_ARE_CACHED */
         HDfree(grp_ptr->atom_list);
-      } /* end if */
-
-done:
-  if(ret_value == FAIL)   
-    { /* Error condition cleanup */
-
-    } /* end if */
+    }                           /* end if */
+  done:
+    if (ret_value == FAIL) {    /* Error condition cleanup */
 
+    }                           /* end if */
     /* Normal function cleanup */
     FUNC_LEAVE(ret_value);
-}   /* end H5Adestroy_group() */
+}                               /* end H5Adestroy_group() */
 
 /******************************************************************************
  NAME
@@ -276,42 +271,43 @@ done:
     Returns atom if successful and FAIL otherwise
 
 *******************************************************************************/
-hid_t H5Aregister_atom(group_t grp,     /* IN: Group to register the object in */
-    const void *object                    /* IN: Object to attach to atom */
+hid_t 
+H5Aregister_atom(group_t grp,   /* IN: Group to register the object in */
+                 const void *object     /* IN: Object to attach to atom */
 )
 {
-    atom_group_t *grp_ptr=NULL;     /* ptr to the atomic group */
-    atom_info_t *atm_ptr=NULL;      /* ptr to the new atom */
-    hid_t atm_id;                  /* new atom ID */
-    uintn hash_loc;                 /* new item's hash table location */
-    hid_t ret_value=SUCCEED;
+    atom_group_t           *grp_ptr = NULL;     /* ptr to the atomic group */
+    atom_info_t            *atm_ptr = NULL;     /* ptr to the new atom */
+    hid_t                   atm_id;     /* new atom ID */
+    uintn                   hash_loc;   /* new item's hash table location */
+    hid_t                   ret_value = SUCCEED;
 
-    FUNC_ENTER (H5Aregister_atom, FAIL);
+    FUNC_ENTER(H5Aregister_atom, FAIL);
 
-    if(grp<=BADGROUP || grp>=MAXGROUP)
+    if (grp <= BADGROUP || grp >= MAXGROUP)
         HGOTO_DONE(FAIL);
 
-    grp_ptr=atom_group_list[grp];
-    if(grp_ptr==NULL || grp_ptr->count<=0)
+    grp_ptr = atom_group_list[grp];
+    if (grp_ptr == NULL || grp_ptr->count <= 0)
         HGOTO_DONE(FAIL);
 
-    if((atm_ptr=H5A_get_atom_node())==NULL)
+    if ((atm_ptr = H5A_get_atom_node()) == NULL)
         HGOTO_DONE(FAIL);
 
     /* Create the atom & it's ID */
-    atm_id=MAKE_ATOM(grp,grp_ptr->nextid);
-    atm_ptr->id=atm_id;
-    atm_ptr->count=1;   /* reference count all objects (even if no 'free' function defined */
-    atm_ptr->obj_ptr=object;
-    atm_ptr->next=NULL;
+    atm_id = MAKE_ATOM(grp, grp_ptr->nextid);
+    atm_ptr->id = atm_id;
+    atm_ptr->count = 1;         /* reference count all objects (even if no 'free' function defined */
+    atm_ptr->obj_ptr = object;
+    atm_ptr->next = NULL;
 
     /* hash bucket already full, prepend to front of chain */
-    hash_loc=grp_ptr->nextid%(uintn)grp_ptr->hash_size;
-    if(grp_ptr->atom_list[hash_loc]!=NULL)
-        atm_ptr->next=grp_ptr->atom_list[hash_loc];
+    hash_loc = grp_ptr->nextid % (uintn) grp_ptr->hash_size;
+    if (grp_ptr->atom_list[hash_loc] != NULL)
+        atm_ptr->next = grp_ptr->atom_list[hash_loc];
 
     /* Insert into the group */
-    grp_ptr->atom_list[hash_loc]=atm_ptr;
+    grp_ptr->atom_list[hash_loc] = atm_ptr;
     grp_ptr->atoms++;
     grp_ptr->nextid++;
 
@@ -320,51 +316,45 @@ hid_t H5Aregister_atom(group_t grp,     /* IN: Group to register the object in *
      * wrapping around, thus necessitating checking for duplicate atoms being
      * handed out.
      */
-    if(grp_ptr->nextid>(uintn)ATOM_MASK || grp_ptr->wrapped!=0)
-      {
-        if(grp_ptr->wrapped==0)
-          {
-            grp_ptr->wrapped=1;       /* set the "wrapped around" flag if it isn't already */
-            grp_ptr->nextid=grp_ptr->reserved;    /* re-start the ID counter */
-          } /* end if */
+    if (grp_ptr->nextid > (uintn) ATOM_MASK || grp_ptr->wrapped != 0) {
+        if (grp_ptr->wrapped == 0) {
+            grp_ptr->wrapped = 1;       /* set the "wrapped around" flag if it isn't already */
+            grp_ptr->nextid = grp_ptr->reserved;        /* re-start the ID counter */
+        }                       /* end if */
         do {
-            hid_t next_atom=MAKE_ATOM(grp,grp_ptr->nextid);      /* new atom to check for */
-            atom_info_t *curr_atm;  /* ptr to the current atom */
+            hid_t                   next_atom = MAKE_ATOM(grp, grp_ptr->nextid);        /* new atom to check for */
+            atom_info_t            *curr_atm;   /* ptr to the current atom */
 
-            curr_atm=grp_ptr->atom_list[(uintn)ATOM_TO_LOC(grp_ptr->nextid,grp_ptr->hash_size)];
-            if(curr_atm==NULL)    /* Ha! this is not likely... */
+            curr_atm = grp_ptr->atom_list[(uintn) ATOM_TO_LOC(grp_ptr->nextid, grp_ptr->hash_size)];
+            if (curr_atm == NULL)       /* Ha! this is not likely... */
                 break;
 
-            while(curr_atm!=NULL)
-              {
-                  if(curr_atm->id==next_atom)
-                      break;
-                  curr_atm=curr_atm->next;
-              } /* end while */
-            if(curr_atm==NULL)    /* must not have found a match */
+            while (curr_atm != NULL) {
+                if (curr_atm->id == next_atom)
+                    break;
+                curr_atm = curr_atm->next;
+            }                   /* end while */
+            if (curr_atm == NULL)       /* must not have found a match */
                 break;
             grp_ptr->nextid++;
-         } while(grp_ptr->nextid<=(uintn)ATOM_MASK);
-        if(grp_ptr->nextid>(uintn)ATOM_MASK)  /* All the atoms are gone! */
+        } while (grp_ptr->nextid <= (uintn) ATOM_MASK);
+        if (grp_ptr->nextid > (uintn) ATOM_MASK)        /* All the atoms are gone! */
             HGOTO_DONE(FAIL);
-      } /* end if */
+    }                           /* end if */
+    ret_value = atm_id;
 
-    ret_value=atm_id;
-
-done:
-  if(ret_value == FAIL)   
-    { /* Error condition cleanup */
-
-    } /* end if */
+  done:
+    if (ret_value == FAIL) {    /* Error condition cleanup */
 
+    }                           /* end if */
     /* Normal function cleanup */
     FUNC_LEAVE(ret_value);
-}   /* end H5Aregister_atom() */
+}                               /* end H5Aregister_atom() */
 
 /******************************************************************************
  NAME
      H5A_inc_ref - Adds a reference to a reference counted atom.
-    	IN: Atom to increment reference count for
+        IN: Atom to increment reference count for
  DESCRIPTION
     Increments the number of references outstanding for an atom.  This will
     fail if the group is not a reference counted group.
@@ -374,27 +364,25 @@ done:
 
 *******************************************************************************/
 hid_t
-H5A_inc_ref (hid_t atm)
+H5A_inc_ref(hid_t atm)
 {
-   group_t	grp = ATOM_TO_GROUP (atm); 	/* Group the object is in */
-   atom_group_t *grp_ptr = NULL;		/* ptr to the atomic group */
-   atom_info_t	*atm_ptr = NULL;      		/* ptr to the new atom */
-   hid_t	ret_value=FAIL;
-
-   FUNC_ENTER (H5A_inc_ref, FAIL);
-
-   grp_ptr = atom_group_list[grp];
-   if (grp_ptr==NULL || grp_ptr->count<=0 || grp_ptr->free_func==NULL) {
-      HRETURN (FAIL);
-   }
+    group_t                 grp = ATOM_TO_GROUP(atm);   /* Group the object is in */
+    atom_group_t           *grp_ptr = NULL;     /* ptr to the atomic group */
+    atom_info_t            *atm_ptr = NULL;     /* ptr to the new atom */
+    hid_t                   ret_value = FAIL;
 
-   /* General lookup of the atom */
-   if ((atm_ptr=H5A_find_atom(atm))!=NULL) {
-      atm_ptr->count++;
-      ret_value=atm;
-   }
+    FUNC_ENTER(H5A_inc_ref, FAIL);
 
-   FUNC_LEAVE (ret_value);
+    grp_ptr = atom_group_list[grp];
+    if (grp_ptr == NULL || grp_ptr->count <= 0 || grp_ptr->free_func == NULL) {
+        HRETURN(FAIL);
+    }
+    /* General lookup of the atom */
+    if ((atm_ptr = H5A_find_atom(atm)) != NULL) {
+        atm_ptr->count++;
+        ret_value = atm;
+    }
+    FUNC_LEAVE(ret_value);
 }
 
 /******************************************************************************
@@ -408,54 +396,51 @@ H5A_inc_ref (hid_t atm)
     Returns object ptr if successful and NULL otherwise
 
 *******************************************************************************/
-VOIDP H5Aatom_object(hid_t atm   /* IN: Atom to retrieve object for */
+VOIDP 
+H5Aatom_object(hid_t atm        /* IN: Atom to retrieve object for */
 )
 {
 #ifdef ATOMS_ARE_CACHED
-    uintn i;                        /* local counter */
+    uintn                   i;  /* local counter */
 #endif /* ATOMS_ARE_CACHED */
-    atom_info_t *atm_ptr=NULL;      /* ptr to the new atom */
-    VOIDP ret_value=NULL;
+    atom_info_t            *atm_ptr = NULL;     /* ptr to the new atom */
+    VOIDP                   ret_value = NULL;
 
-    FUNC_ENTER (H5Aatom_object, NULL);
+    FUNC_ENTER(H5Aatom_object, NULL);
 
 #ifdef ATOMS_ARE_CACHED
     /* Look for the atom in the cache first */
-    for(i=0; i<ATOM_CACHE_SIZE; i++)
-        if(atom_id_cache[i]==atm)
-          {
-            ret_value=atom_obj_cache[i];
-            if(i>0)
-              { /* Implement a simple "move forward" caching scheme */
-                hid_t t_atom=atom_id_cache[i-1];
-                VOIDP  t_obj=atom_obj_cache[i-1];
-
-                atom_id_cache[i-1]=atom_id_cache[i];
-                atom_obj_cache[i-1]=atom_obj_cache[i];
-                atom_id_cache[i]=t_atom;
-                atom_obj_cache[i]=t_obj;
-              } /* end if */
+    for (i = 0; i < ATOM_CACHE_SIZE; i++)
+        if (atom_id_cache[i] == atm) {
+            ret_value = atom_obj_cache[i];
+            if (i > 0) {        /* Implement a simple "move forward" caching scheme */
+                hid_t                   t_atom = atom_id_cache[i - 1];
+                VOIDP                   t_obj = atom_obj_cache[i - 1];
+
+                atom_id_cache[i - 1] = atom_id_cache[i];
+                atom_obj_cache[i - 1] = atom_obj_cache[i];
+                atom_id_cache[i] = t_atom;
+                atom_obj_cache[i] = t_obj;
+            }                   /* end if */
             HGOTO_DONE(ret_value);
-          } /* end if */
-#endif /* ATOMS_ARE_CACHED */
+        }                       /* end if */
+#endif                       /* ATOMS_ARE_CACHED */
 
     /* General lookup of the atom */
-    if((atm_ptr=H5A_find_atom(atm))==NULL)
+    if ((atm_ptr = H5A_find_atom(atm)) == NULL)
         HGOTO_DONE(NULL);
 
     /* Check if we've found the correct atom */
-    if(atm_ptr!=NULL)
-        ret_value=atm_ptr->obj_ptr;
-
-done:
-  if(ret_value == NULL)   
-    { /* Error condition cleanup */
+    if (atm_ptr != NULL)
+        ret_value = atm_ptr->obj_ptr;
 
-    } /* end if */
+  done:
+    if (ret_value == NULL) {    /* Error condition cleanup */
 
+    }                           /* end if */
     /* Normal function cleanup */
     FUNC_LEAVE(ret_value);
-}   /* end H5Aatom_object() */
+}                               /* end H5Aatom_object() */
 
 /******************************************************************************
  NAME
@@ -468,26 +453,25 @@ done:
     Returns group if successful and BADGROUP otherwise
 
 *******************************************************************************/
-group_t H5Aatom_group(hid_t atm   /* IN: Atom to retrieve group for */
+group_t 
+H5Aatom_group(hid_t atm         /* IN: Atom to retrieve group for */
 )
 {
-    group_t ret_value=BADGROUP;
+    group_t                 ret_value = BADGROUP;
 
-    FUNC_ENTER (H5Aatom_group, FAIL);
+    FUNC_ENTER(H5Aatom_group, FAIL);
 
-    ret_value=ATOM_TO_GROUP(atm);
-    if(ret_value<=BADGROUP || ret_value>=MAXGROUP)
+    ret_value = ATOM_TO_GROUP(atm);
+    if (ret_value <= BADGROUP || ret_value >= MAXGROUP)
         HGOTO_DONE(BADGROUP);
 
-done:
-  if(ret_value == BADGROUP)   
-    { /* Error condition cleanup */
-
-    } /* end if */
+  done:
+    if (ret_value == BADGROUP) {        /* Error condition cleanup */
 
+    }                           /* end if */
     /* Normal function cleanup */
     FUNC_LEAVE(ret_value);
-}   /* end H5Aatom_group() */
+}                               /* end H5Aatom_group() */
 
 /******************************************************************************
  NAME
@@ -500,79 +484,76 @@ done:
     Returns atom's object if successful and NULL otherwise
 
 *******************************************************************************/
-VOIDP H5Aremove_atom(hid_t atm   /* IN: Atom to remove */
+VOIDP 
+H5Aremove_atom(hid_t atm        /* IN: Atom to remove */
 )
 {
-    atom_group_t *grp_ptr=NULL;     /* ptr to the atomic group */
-    atom_info_t *curr_atm,          /* ptr to the current atom */
-        *last_atm;                  /* ptr to the last atom */
-    group_t grp;                    /* atom's atomic group */
-    uintn hash_loc;                 /* atom's hash table location */
+    atom_group_t           *grp_ptr = NULL;     /* ptr to the atomic group */
+    atom_info_t            *curr_atm,   /* ptr to the current atom */
+                           *last_atm;   /* ptr to the last atom */
+    group_t                 grp;        /* atom's atomic group */
+    uintn                   hash_loc;   /* atom's hash table location */
 #ifdef ATOMS_ARE_CACHED
-    uintn i;                        /* local counting variable */
+    uintn                   i;  /* local counting variable */
 #endif /* ATOMS_ARE_CACHED */
-    VOIDP ret_value=NULL;
+    VOIDP                   ret_value = NULL;
 
-    FUNC_ENTER (H5Aremove_atom, NULL);
+    FUNC_ENTER(H5Aremove_atom, NULL);
 
-    grp=ATOM_TO_GROUP(atm);
-    if(grp<=BADGROUP || grp>=MAXGROUP)
+    grp = ATOM_TO_GROUP(atm);
+    if (grp <= BADGROUP || grp >= MAXGROUP)
         HGOTO_DONE(NULL);
 
-    grp_ptr=atom_group_list[grp];
-    if(grp_ptr==NULL || grp_ptr->count<=0)
+    grp_ptr = atom_group_list[grp];
+    if (grp_ptr == NULL || grp_ptr->count <= 0)
         HGOTO_DONE(NULL);
 
     /* Get the location in which the atom is located */
-    hash_loc=(uintn)ATOM_TO_LOC(atm,grp_ptr->hash_size);
-    curr_atm=grp_ptr->atom_list[hash_loc];
-    if(curr_atm==NULL)
+    hash_loc = (uintn) ATOM_TO_LOC(atm, grp_ptr->hash_size);
+    curr_atm = grp_ptr->atom_list[hash_loc];
+    if (curr_atm == NULL)
         HGOTO_DONE(NULL);
 
-    last_atm=NULL;
-    while(curr_atm!=NULL)
-      {
-          if(curr_atm->id==atm)
-              break;
-          last_atm=curr_atm;
-          curr_atm=curr_atm->next;
-      } /* end while */
-
-    if(curr_atm!=NULL)
-      {
-          if(last_atm==NULL)    /* atom is the first the chain */
-              grp_ptr->atom_list[hash_loc]=curr_atm->next;
-          else
-              last_atm->next=curr_atm->next;
-          ret_value=curr_atm->obj_ptr;
-          H5A_release_atom_node(curr_atm);
-      } /* end if */
-    else    /* couldn't find the atom in the proper place */
+    last_atm = NULL;
+    while (curr_atm != NULL) {
+        if (curr_atm->id == atm)
+            break;
+        last_atm = curr_atm;
+        curr_atm = curr_atm->next;
+    }                           /* end while */
+
+    if (curr_atm != NULL) {
+        if (last_atm == NULL)   /* atom is the first the chain */
+            grp_ptr->atom_list[hash_loc] = curr_atm->next;
+        else
+            last_atm->next = curr_atm->next;
+        ret_value = curr_atm->obj_ptr;
+        H5A_release_atom_node(curr_atm);
+    }
+    /* end if */ 
+    else                        /* couldn't find the atom in the proper place */
         HGOTO_DONE(NULL);
-    
+
 #ifdef ATOMS_ARE_CACHED
     /* Delete object from cache */
-    for(i=0; i<ATOM_CACHE_SIZE; i++)
-        if(atom_id_cache[i]==atm)
-          {
-            atom_id_cache[i]=(-1);
-            atom_obj_cache[i]=NULL;
-            break;  /* we assume there is only one instance in the cache */
-          } /* end if */
-#endif /* ATOMS_ARE_CACHED */
+    for (i = 0; i < ATOM_CACHE_SIZE; i++)
+        if (atom_id_cache[i] == atm) {
+            atom_id_cache[i] = (-1);
+            atom_obj_cache[i] = NULL;
+            break;              /* we assume there is only one instance in the cache */
+        }                       /* end if */
+#endif                      /* ATOMS_ARE_CACHED */
 
     /* Decrement the number of atoms in the group */
     (grp_ptr->atoms)--;
 
-done:
-  if(ret_value == NULL)   
-    { /* Error condition cleanup */
-
-    } /* end if */
+  done:
+    if (ret_value == NULL) {    /* Error condition cleanup */
 
+    }                           /* end if */
     /* Normal function cleanup */
     FUNC_LEAVE(ret_value);
-}   /* end H5Aremove_atom() */
+}                               /* end H5Aremove_atom() */
 
 /******************************************************************************
  NAME
@@ -589,35 +570,33 @@ done:
 
 *******************************************************************************/
 intn
-H5A_dec_ref (hid_t atm)
+H5A_dec_ref(hid_t atm)
 {
-   group_t	grp = ATOM_TO_GROUP(atm); /* Group the object is in */
-   atom_group_t *grp_ptr=NULL;     /* ptr to the atomic group */
-   atom_info_t	*atm_ptr=NULL;      /* ptr to the new atom */
-   VOIDP 	obj;                /* object to call 'free' function with */
-   intn		ret_value=FAIL;
-
-   FUNC_ENTER (H5A_dec_ref, FAIL);
-
-   grp_ptr = atom_group_list[grp];
-   if (grp_ptr==NULL || grp_ptr->count<=0 || grp_ptr->free_func==NULL) {
-      HRETURN (FAIL);
-   }
-   
-   /* General lookup of the atom */
-   if ((atm_ptr=H5A_find_atom(atm))!=NULL) {
-      /* Decrement the reference count */
-      atm_ptr->count--;
-
-      /* If the reference count is zero, remove the object from the group */
-      if (0==atm_ptr->count && (obj=H5Aremove_atom(atm))!=NULL) {
-	 /* call the user's 'free' function for the atom's information */
-	 (*grp_ptr->free_func)(obj);
-      }
-      ret_value=SUCCEED;
-   }
-
-   FUNC_LEAVE (ret_value);
+    group_t                 grp = ATOM_TO_GROUP(atm);   /* Group the object is in */
+    atom_group_t           *grp_ptr = NULL;     /* ptr to the atomic group */
+    atom_info_t            *atm_ptr = NULL;     /* ptr to the new atom */
+    VOIDP                   obj;        /* object to call 'free' function with */
+    intn                    ret_value = FAIL;
+
+    FUNC_ENTER(H5A_dec_ref, FAIL);
+
+    grp_ptr = atom_group_list[grp];
+    if (grp_ptr == NULL || grp_ptr->count <= 0 || grp_ptr->free_func == NULL) {
+        HRETURN(FAIL);
+    }
+    /* General lookup of the atom */
+    if ((atm_ptr = H5A_find_atom(atm)) != NULL) {
+        /* Decrement the reference count */
+        atm_ptr->count--;
+
+        /* If the reference count is zero, remove the object from the group */
+        if (0 == atm_ptr->count && (obj = H5Aremove_atom(atm)) != NULL) {
+            /* call the user's 'free' function for the atom's information */
+            (*grp_ptr->free_func) (obj);
+        }
+        ret_value = SUCCEED;
+    }
+    FUNC_LEAVE(ret_value);
 }
 
 /******************************************************************************
@@ -634,46 +613,43 @@ H5A_dec_ref (hid_t atm)
     Returns pointer an atom's object if successful and NULL otherwise
 
 *******************************************************************************/
-VOIDP H5Asearch_atom(group_t grp,        /* IN: Group to search for the object in */
-    H5Asearch_func_t func,               /* IN: Ptr to the comparison function */
-    const VOIDP key                     /* IN: pointer to key to compare against */
+VOIDP 
+H5Asearch_atom(group_t grp,     /* IN: Group to search for the object in */
+               H5Asearch_func_t func,   /* IN: Ptr to the comparison function */
+               const VOIDP key  /* IN: pointer to key to compare against */
 )
 {
-    atom_group_t *grp_ptr=NULL;     /* ptr to the atomic group */
-    atom_info_t *atm_ptr=NULL;      /* ptr to the new atom */
-    intn i;                         /* local counting variable */
-    VOIDP ret_value=NULL;
+    atom_group_t           *grp_ptr = NULL;     /* ptr to the atomic group */
+    atom_info_t            *atm_ptr = NULL;     /* ptr to the new atom */
+    intn                    i;  /* local counting variable */
+    VOIDP                   ret_value = NULL;
 
-    FUNC_ENTER (H5Asearch_atom, NULL);
+    FUNC_ENTER(H5Asearch_atom, NULL);
 
-    if(grp<=BADGROUP || grp>=MAXGROUP)
+    if (grp <= BADGROUP || grp >= MAXGROUP)
         HGOTO_DONE(NULL);
 
-    grp_ptr=atom_group_list[grp];
-    if(grp_ptr==NULL || grp_ptr->count<=0)
+    grp_ptr = atom_group_list[grp];
+    if (grp_ptr == NULL || grp_ptr->count <= 0)
         HGOTO_DONE(NULL);
 
     /* Start at the beginning of the array */
-    for(i=0; i<grp_ptr->hash_size; i++)
-      {
-        atm_ptr=grp_ptr->atom_list[i];
-        while(atm_ptr!=NULL)
-          {
-              if((*func)(atm_ptr->obj_ptr,key))
-                  HGOTO_DONE(atm_ptr->obj_ptr); /* found the item we are looking for */
-              atm_ptr=atm_ptr->next;
-          } /* end while */
-      } /* end for */
-
-done:
-  if(ret_value == NULL)
-    { /* Error condition cleanup */
-
-    } /* end if */
-
+    for (i = 0; i < grp_ptr->hash_size; i++) {
+        atm_ptr = grp_ptr->atom_list[i];
+        while (atm_ptr != NULL) {
+            if ((*func) (atm_ptr->obj_ptr, key))
+                HGOTO_DONE(atm_ptr->obj_ptr);   /* found the item we are looking for */
+            atm_ptr = atm_ptr->next;
+        }                       /* end while */
+    }                           /* end for */
+
+  done:
+    if (ret_value == NULL) {    /* Error condition cleanup */
+
+    }                           /* end if */
     /* Normal function cleanup */
     FUNC_LEAVE(ret_value);
-}   /* end H5Asearch_atom() */
+}                               /* end H5Asearch_atom() */
 
 /******************************************************************************
  NAME
@@ -687,38 +663,37 @@ done:
     Returns BTRUE/BFALSE/BFAIL
 
 *******************************************************************************/
-intn H5Ais_reserved(hid_t atm      /* IN: Group to search for the object in */
+intn 
+H5Ais_reserved(hid_t atm        /* IN: Group to search for the object in */
 )
 {
-    atom_group_t *grp_ptr=NULL;     /* ptr to the atomic group */
-    group_t grp;                    /* atom's atomic group */
-    hbool_t ret_value=BFAIL;
+    atom_group_t           *grp_ptr = NULL;     /* ptr to the atomic group */
+    group_t                 grp;        /* atom's atomic group */
+    hbool_t                 ret_value = BFAIL;
 
-    FUNC_ENTER (H5Ais_reserved, FAIL);
+    FUNC_ENTER(H5Ais_reserved, FAIL);
 
-    grp=ATOM_TO_GROUP(atm);
-    if(grp<=BADGROUP || grp>=MAXGROUP)
+    grp = ATOM_TO_GROUP(atm);
+    if (grp <= BADGROUP || grp >= MAXGROUP)
         HGOTO_DONE(BFAIL);
 
-    grp_ptr=atom_group_list[grp];
-    if(grp_ptr==NULL)
+    grp_ptr = atom_group_list[grp];
+    if (grp_ptr == NULL)
         HGOTO_DONE(BFAIL);
 
     /* Get the location in which the atom is located */
-    if((atm&ATOM_MASK)<grp_ptr->reserved)
-        ret_value=BTRUE;
+    if ((atm & ATOM_MASK) < grp_ptr->reserved)
+        ret_value = BTRUE;
     else
-        ret_value=BFALSE;
-
-done:
-  if(ret_value == BFAIL)
-    { /* Error condition cleanup */
+        ret_value = BFALSE;
 
-    } /* end if */
+  done:
+    if (ret_value == BFAIL) {   /* Error condition cleanup */
 
+    }                           /* end if */
     /* Normal function cleanup */
     FUNC_LEAVE(ret_value);
-}   /* end H5Ais_reserved() */
+}                               /* end H5Ais_reserved() */
 
 /******************************************************************************
  NAME
@@ -731,54 +706,51 @@ done:
     Returns atom ptr if successful and NULL otherwise
 
 *******************************************************************************/
-static atom_info_t *H5A_find_atom(hid_t atm   /* IN: Atom to retrieve atom for */
+static atom_info_t     *
+H5A_find_atom(hid_t atm         /* IN: Atom to retrieve atom for */
 )
 {
-    atom_group_t *grp_ptr=NULL;     /* ptr to the atomic group */
-    atom_info_t *atm_ptr=NULL;      /* ptr to the new atom */
-    group_t grp;                    /* atom's atomic group */
-    uintn hash_loc;                 /* atom's hash table location */
-    atom_info_t *ret_value=NULL;
+    atom_group_t           *grp_ptr = NULL;     /* ptr to the atomic group */
+    atom_info_t            *atm_ptr = NULL;     /* ptr to the new atom */
+    group_t                 grp;        /* atom's atomic group */
+    uintn                   hash_loc;   /* atom's hash table location */
+    atom_info_t            *ret_value = NULL;
 
-    FUNC_ENTER (H5A_find_atom, NULL);
+    FUNC_ENTER(H5A_find_atom, NULL);
 
-    grp=ATOM_TO_GROUP(atm);
-    if(grp<=BADGROUP || grp>=MAXGROUP)
+    grp = ATOM_TO_GROUP(atm);
+    if (grp <= BADGROUP || grp >= MAXGROUP)
         HGOTO_DONE(NULL);
 
-    grp_ptr=atom_group_list[grp];
-    if(grp_ptr==NULL || grp_ptr->count<=0)
+    grp_ptr = atom_group_list[grp];
+    if (grp_ptr == NULL || grp_ptr->count <= 0)
         HGOTO_DONE(NULL);
 
     /* Get the location in which the atom is located */
-    hash_loc=(uintn)ATOM_TO_LOC(atm,grp_ptr->hash_size);
-    atm_ptr=grp_ptr->atom_list[hash_loc];
-    if(atm_ptr==NULL)
+    hash_loc = (uintn) ATOM_TO_LOC(atm, grp_ptr->hash_size);
+    atm_ptr = grp_ptr->atom_list[hash_loc];
+    if (atm_ptr == NULL)
         HGOTO_DONE(NULL);
 
-    while(atm_ptr!=NULL)
-      {
-          if(atm_ptr->id==atm)
-              break;
-          atm_ptr=atm_ptr->next;
-      } /* end while */
-    ret_value=atm_ptr;
+    while (atm_ptr != NULL) {
+        if (atm_ptr->id == atm)
+            break;
+        atm_ptr = atm_ptr->next;
+    }                           /* end while */
+    ret_value = atm_ptr;
 
 #ifdef ATOMS_ARE_CACHED
-    atom_id_cache[ATOM_CACHE_SIZE-1]=atm;
-    atom_obj_cache[ATOM_CACHE_SIZE-1]=atm_ptr->obj_ptr;
+    atom_id_cache[ATOM_CACHE_SIZE - 1] = atm;
+    atom_obj_cache[ATOM_CACHE_SIZE - 1] = atm_ptr->obj_ptr;
 #endif /* ATOMS_ARE_CACHED */
 
-done:
-  if(ret_value == NULL)   
-    { /* Error condition cleanup */
+  done:
+    if (ret_value == NULL) {    /* Error condition cleanup */
 
-    } /* end if */
-
-  /* Normal function cleanup */
-
-  FUNC_LEAVE (ret_value);
-}   /* end H5A_find_atom() */
+    }                           /* end if */
+    /* Normal function cleanup */
+    FUNC_LEAVE(ret_value);
+}                               /* end H5A_find_atom() */
 
 /******************************************************************************
  NAME
@@ -792,33 +764,30 @@ done:
     Returns atom ptr if successful and NULL otherwise
 
 *******************************************************************************/
-static atom_info_t *H5A_get_atom_node(void)
+static atom_info_t     *
+H5A_get_atom_node(void)
 {
-    atom_info_t *ret_value=NULL;
+    atom_info_t            *ret_value = NULL;
 
-    FUNC_ENTER (H5A_get_atom_node, NULL);
+    FUNC_ENTER(H5A_get_atom_node, NULL);
 
-    if(atom_free_list!=NULL)
-      {
-        ret_value=atom_free_list;
-        atom_free_list=atom_free_list->next;
-      } /* end if */
-    else
-      {
-        if((ret_value=(atom_info_t *)HDmalloc(sizeof(atom_info_t)))==NULL)
-            HGOTO_DONE(NULL);
-      } /* end else */
-
-done:
-  if(ret_value == NULL)   
-    { /* Error condition cleanup */
+    if (atom_free_list != NULL) {
+        ret_value = atom_free_list;
+        atom_free_list = atom_free_list->next;
+    }
+    /* end if */ 
+    else {
+        if ((ret_value = (atom_info_t *) HDmalloc(sizeof(atom_info_t))) == NULL)
+                                    HGOTO_DONE(NULL);
+    }                           /* end else */
 
-    } /* end if */
+  done:
+    if (ret_value == NULL) {    /* Error condition cleanup */
 
-  /* Normal function cleanup */
-
-  FUNC_LEAVE (ret_value);
-}   /* end H5A_get_atom_node() */
+    }                           /* end if */
+    /* Normal function cleanup */
+    FUNC_LEAVE(ret_value);
+}                               /* end H5A_get_atom_node() */
 
 /******************************************************************************
  NAME
@@ -834,14 +803,14 @@ done:
 static herr_t
 H5A_release_atom_node(atom_info_t *atm)
 {
-    FUNC_ENTER (H5A_release_atom_node, FAIL);
+    FUNC_ENTER(H5A_release_atom_node, FAIL);
 
     /* Insert the atom at the beginning of the free list */
-    atm->next=atom_free_list;
-    atom_free_list=atm;
+    atm->next = atom_free_list;
+    atom_free_list = atm;
 
-    FUNC_LEAVE (SUCCEED);
-}   /* end H5A_release_atom_node() */
+    FUNC_LEAVE(SUCCEED);
+}                               /* end H5A_release_atom_node() */
 
 /*--------------------------------------------------------------------------
  NAME
@@ -860,28 +829,23 @@ H5A_release_atom_node(atom_info_t *atm)
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
-void H5A_term_interface(void)
+void 
+H5A_term_interface(void)
 {
-    atom_info_t *curr;
-    intn i;
+    atom_info_t            *curr;
+    intn                    i;
 
     /* Release the free-list if it exists */
-    if(atom_free_list!=NULL)
-      {
-        while(atom_free_list!=NULL)
-          {
-            curr=atom_free_list;
-            atom_free_list=atom_free_list->next;
+    if (atom_free_list != NULL) {
+        while (atom_free_list != NULL) {
+            curr = atom_free_list;
+            atom_free_list = atom_free_list->next;
             HDfree(curr);
-          } /* end while */
-      } /* end if */
-
-    for(i=0; i<(intn)MAXGROUP; i++)
-        if(atom_group_list[i]!=NULL)
-          {
+        }                       /* end while */
+    }                           /* end if */
+    for (i = 0; i < (intn) MAXGROUP; i++)
+        if (atom_group_list[i] != NULL) {
             HDfree(atom_group_list[i]);
-            atom_group_list[i]=NULL;
-          } /* end if */
-
-}	/* end H5A_term_interface() */
-
+            atom_group_list[i] = NULL;
+        }                       /* end if */
+}                               /* end H5A_term_interface() */