[svn-r108] Changed all hatom_t types to hid_t. (Isn't 'sed' nifty.. :-)

21 files changed, 231 insertions, 231 deletions

diff --git a/src/H5A.c b/src/H5A.c
index 897d3c2..e12d9cd 100644
--- a/src/H5A.c
+++ b/src/H5A.c
@@ -74,7 +74,7 @@ static int interface_initialize_g = FALSE;
 
 #ifdef ATOMS_ARE_CACHED
 /* Array of pointers to atomic groups */
-static hatom_t atom_id_cache[ATOM_CACHE_SIZE]={-1,-1,-1,-1};
+static hid_t atom_id_cache[ATOM_CACHE_SIZE]={-1,-1,-1,-1};
 static VOIDP atom_obj_cache[ATOM_CACHE_SIZE]={NULL};
 #endif
 
@@ -85,7 +85,7 @@ static atom_group_t *atom_group_list[MAXGROUP]={NULL};
 static atom_info_t *atom_free_list=NULL;
 
 /*--------------------- Local function prototypes ---------------------------*/
-static atom_info_t *H5A_find_atom(hatom_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);
 static herr_t H5A_init_interface(void);
@@ -273,15 +273,15 @@ done:
     Returns atom if successful and FAIL otherwise
 
 *******************************************************************************/
-hatom_t H5Aregister_atom(group_t grp,     /* IN: Group to register the object in */
+hid_t H5Aregister_atom(group_t grp,     /* IN: Group to register the object in */
     const VOIDP 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 */
-    hatom_t atm_id;                  /* new atom ID */
+    hid_t atm_id;                  /* new atom ID */
     uintn hash_loc;                 /* new item's hash table location */
-    hatom_t ret_value=SUCCEED;
+    hid_t ret_value=SUCCEED;
 
     FUNC_ENTER (H5Aregister_atom, H5A_init_interface, FAIL);
 
@@ -324,7 +324,7 @@ hatom_t H5Aregister_atom(group_t grp,     /* IN: Group to register the object in
             grp_ptr->nextid=grp_ptr->reserved;    /* re-start the ID counter */
           } /* end if */
         do {
-            hatom_t next_atom=MAKE_ATOM(grp,grp_ptr->nextid);      /* new atom to check for */
+            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)];
@@ -368,7 +368,7 @@ done:
     Returns object ptr if successful and NULL otherwise
 
 *******************************************************************************/
-VOIDP H5Aatom_object(hatom_t atm   /* IN: Atom to retrieve object for */
+VOIDP H5Aatom_object(hid_t atm   /* IN: Atom to retrieve object for */
 )
 {
 #ifdef ATOMS_ARE_CACHED
@@ -387,7 +387,7 @@ VOIDP H5Aatom_object(hatom_t atm   /* IN: Atom to retrieve object for */
             ret_value=atom_obj_cache[i];
             if(i>0)
               { /* Implement a simple "move forward" caching scheme */
-                hatom_t t_atom=atom_id_cache[i-1];
+                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];
@@ -428,7 +428,7 @@ done:
     Returns group if successful and BADGROUP otherwise
 
 *******************************************************************************/
-group_t H5Aatom_group(hatom_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;
@@ -460,7 +460,7 @@ done:
     Returns atom's object if successful and NULL otherwise
 
 *******************************************************************************/
-VOIDP H5Aremove_atom(hatom_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 */
@@ -601,7 +601,7 @@ done:
     Returns BTRUE/BFALSE/BFAIL
 
 *******************************************************************************/
-intn H5Ais_reserved(hatom_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 */
@@ -645,7 +645,7 @@ done:
     Returns atom ptr if successful and NULL otherwise
 
 *******************************************************************************/
-static atom_info_t *H5A_find_atom(hatom_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 */
diff --git a/src/H5Aprivate.h b/src/H5Aprivate.h
index 09371d1..97b8688 100644
--- a/src/H5Aprivate.h
+++ b/src/H5Aprivate.h
@@ -41,19 +41,19 @@
 #endif
 
 /* Map an atom to a Group number */
-#define ATOM_TO_GROUP(a)    ((group_t)((((hatom_t)(a))>>((sizeof(hatom_t)*8)-GROUP_BITS))&GROUP_MASK))
+#define ATOM_TO_GROUP(a)    ((group_t)((((hid_t)(a))>>((sizeof(hid_t)*8)-GROUP_BITS))&GROUP_MASK))
 
 #ifdef HASH_SIZE_POWER_2
 /*
  * Map an atom to a hash location (assumes s is a power of 2 and smaller
  * than the ATOM_MASK constant).
  */
-#  define ATOM_TO_LOC(a,s)    ((hatom_t)(a)&((s)-1))
+#  define ATOM_TO_LOC(a,s)    ((hid_t)(a)&((s)-1))
 #else
 /*
  * Map an atom to a hash location.
  */
-#  define ATOM_TO_LOC(a,s)    (((hatom_t)(a)&ATOM_MASK)%(s))
+#  define ATOM_TO_LOC(a,s)    (((hid_t)(a)&ATOM_MASK)%(s))
 #endif
 
 /* Default sizes of the hash-tables for various atom groups */
@@ -67,7 +67,7 @@
 
 /* Atom information structure used */
 typedef struct atom_info_struct_tag {
-    hatom_t id;              /* atom ID for this info */
+    hid_t id;              /* atom ID for this info */
     VOIDP *obj_ptr;         /* pointer associated with the atom */
     struct atom_info_struct_tag *next;   /* link to next atom (in case of hash-clash) */
   }atom_info_t;
diff --git a/src/H5Apublic.h b/src/H5Apublic.h
index d9f79ef..8bc5b7f 100644
--- a/src/H5Apublic.h
+++ b/src/H5Apublic.h
@@ -36,7 +36,7 @@ typedef enum {
 } group_t;
 
 /* Type of atoms to return to users */
-typedef int32 hatom_t;
+typedef int32 hid_t;
 
 /* Type of the function to compare objects & keys */
 typedef intn (*H5Asearch_func_t)(const VOIDP obj, const VOIDP key);
@@ -46,11 +46,11 @@ typedef intn (*H5Asearch_func_t)(const VOIDP obj, const VOIDP key);
 #define GROUP_MASK  0x0F
 
 /* # of bits to use for the Atom index in each atom (assumes 8-bit bytes) */
-#define ATOM_BITS   ((sizeof(hatom_t)*8)-GROUP_BITS)
+#define ATOM_BITS   ((sizeof(hid_t)*8)-GROUP_BITS)
 #define ATOM_MASK   0x0FFFFFFF
 
 /* Combine a Group number and an atom index into an atom */
-#define MAKE_ATOM(g,i)      ((((hatom_t)(g)&GROUP_MASK)<<((sizeof(hatom_t)*8)-GROUP_BITS))|((hatom_t)(i)&ATOM_MASK))
+#define MAKE_ATOM(g,i)      ((((hid_t)(g)&GROUP_MASK)<<((sizeof(hid_t)*8)-GROUP_BITS))|((hid_t)(i)&ATOM_MASK))
 
 #ifdef __cplusplus
 extern "C" {
@@ -108,7 +108,7 @@ intn H5Adestroy_group(group_t grp       /* IN: Group to destroy */
     Returns atom if successful and FAIL otherwise
 
 *******************************************************************************/
-hatom_t H5Aregister_atom(group_t grp,     /* IN: Group to register the object in */
+hid_t H5Aregister_atom(group_t grp,     /* IN: Group to register the object in */
     const VOIDP object                    /* IN: Object to attach to atom */
 );
 
@@ -123,7 +123,7 @@ hatom_t H5Aregister_atom(group_t grp,     /* IN: Group to register the object in
     Returns object ptr if successful and NULL otherwise
 
 *******************************************************************************/
-VOIDP H5Aatom_object(hatom_t atm   /* IN: Atom to retrieve object for */
+VOIDP H5Aatom_object(hid_t atm   /* IN: Atom to retrieve object for */
 );
 
 /******************************************************************************
@@ -137,7 +137,7 @@ VOIDP H5Aatom_object(hatom_t atm   /* IN: Atom to retrieve object for */
     Returns group if successful and FAIL otherwise
 
 *******************************************************************************/
-group_t H5Aatom_group(hatom_t atm   /* IN: Atom to retrieve group for */
+group_t H5Aatom_group(hid_t atm   /* IN: Atom to retrieve group for */
 );
 
 /******************************************************************************
@@ -151,7 +151,7 @@ group_t H5Aatom_group(hatom_t atm   /* IN: Atom to retrieve group for */
     Returns atom's object if successful and FAIL otherwise
 
 *******************************************************************************/
-VOIDP H5Aremove_atom(hatom_t atm   /* IN: Atom to remove */
+VOIDP H5Aremove_atom(hid_t atm   /* IN: Atom to remove */
 );
 
 /******************************************************************************
@@ -185,7 +185,7 @@ VOIDP H5Asearch_atom(group_t grp,        /* IN: Group to search for the object i
     Returns BTRUE/BFALSE/BFAIL
 
 *******************************************************************************/
-intn H5Ais_reserved(hatom_t atm      /* IN: Group to search for the object in */
+intn H5Ais_reserved(hid_t atm      /* IN: Group to search for the object in */
 );
 
 /******************************************************************************
diff --git a/src/H5C.c b/src/H5C.c
index d19298c..5e904a1 100644
--- a/src/H5C.c
+++ b/src/H5C.c
@@ -59,7 +59,7 @@ const file_create_temp_t default_file_create={
     HDF5_OBJECTDIR_VERSION,     /* Current Object Directory info version # */
     HDF5_SHAREDHEADER_VERSION   /* Current Shared-Header format version # */
 };
-static hatom_t default_file_id=FAIL;   /* Atom for the default file-creation template */
+static hid_t default_file_id=FAIL;   /* Atom for the default file-creation template */
 
 /*--------------------- Local function prototypes ----------------------------*/
 static herr_t H5C_init_interface(void);
@@ -118,7 +118,7 @@ void H5C_term_interface (void)
  PURPOSE
     Retrive an atom for a default HDF5 template.
  USAGE
-    hatom_t H5C_create(type)
+    hid_t H5C_create(type)
         hobjtype_t type;        IN: Type of object to retrieve default template of
  RETURNS
     Returns template ID (atom) of the default object for a template type on
@@ -132,9 +132,9 @@ void H5C_term_interface (void)
     The `FUNC' auto variable was changed from `H5C_create' to
     `H5C_get_default_atom'.
 --------------------------------------------------------------------------*/
-hatom_t H5C_get_default_atom(hobjtype_t type)
+hid_t H5C_get_default_atom(hobjtype_t type)
 {
-    hatom_t        ret_value = FAIL;
+    hid_t        ret_value = FAIL;
 
     FUNC_ENTER(H5C_get_default_atom, H5C_init_interface, FAIL);
 
@@ -174,7 +174,7 @@ done:
     Initialize a new HDF5 template with a copy of an existing template.
  USAGE
     herr_t H5C_init(dst_atm, src)
-        hatom_t dst_atm;               IN: Atom for the template to initialize
+        hid_t dst_atm;               IN: Atom for the template to initialize
         file_create_temp_t *src;       IN: Template to use to initialize with
  RETURNS
     SUCCEED/FAIL
@@ -182,7 +182,7 @@ done:
         This function copies the contents of the source template into the
     newly created destination template.
 --------------------------------------------------------------------------*/
-herr_t H5C_init(hatom_t dst_atm, const file_create_temp_t *src)
+herr_t H5C_init(hid_t dst_atm, const file_create_temp_t *src)
 {
     file_create_temp_t *dst;    /* destination template */
     herr_t ret_value = SUCCEED;   /* return value */
@@ -218,8 +218,8 @@ done:
  PURPOSE
     Create a new HDF5 template.
  USAGE
-    hatom_t H5C_create(owner_id, type, name)
-        hatom_t owner_id;       IN: Group/file which owns this template
+    hid_t H5C_create(owner_id, type, name)
+        hid_t owner_id;       IN: Group/file which owns this template
         hobjtype_t type;        IN: Type of template to create
         const char *name;       IN: Name of the template to create
  RETURNS
@@ -228,9 +228,9 @@ done:
         This is the primary function for creating different HDF5 templates.
     Currently the name of template is not used and may be NULL.
 --------------------------------------------------------------------------*/
-hatom_t H5C_create(hatom_t owner_id, hobjtype_t type, const char *name)
+hid_t H5C_create(hid_t owner_id, hobjtype_t type, const char *name)
 {
-    hatom_t ret_value = FAIL;   /* atom for template object to return */
+    hid_t ret_value = FAIL;   /* atom for template object to return */
 
     FUNC_ENTER(H5C_create, H5C_init_interface, FAIL);
 
@@ -272,13 +272,13 @@ done:
     Release access to a template object.
  USAGE
     herr_t H5C_release(oid)
-        hatom_t oid;       IN: Template object to release access to
+        hid_t oid;       IN: Template object to release access to
  RETURNS
     SUCCEED/FAIL
  DESCRIPTION
         This function releases access to a template object
 --------------------------------------------------------------------------*/
-herr_t H5C_release(hatom_t oid)
+herr_t H5C_release(hid_t oid)
 {
     file_create_temp_t *template;     /* template to destroy */
     herr_t        ret_value = SUCCEED;
@@ -311,7 +311,7 @@ done:
     Get a parameter from a template
  USAGE
     herr_t H5Cgetparm(tid, parm, buf)
-        hatom_t tid;        IN: Template object to retrieve parameter from
+        hid_t tid;        IN: Template object to retrieve parameter from
         file_create_param_t parm;   IN: Paramter to retrieve
         VOIDP buf;          OUT: Pointer to buffer to store parameter in
  RETURNS
@@ -325,7 +325,7 @@ done:
 	Removed H5_BTREE_SIZE and replaced it with H5_SYM_LEAF_K and
 	H5_SYM_INTERN_K.
 --------------------------------------------------------------------------*/
-herr_t H5Cgetparm(hatom_t tid, file_create_param_t parm, VOIDP buf)
+herr_t H5Cgetparm(hid_t tid, file_create_param_t parm, VOIDP buf)
 {
     file_create_temp_t *template;    /* template to query */
     herr_t ret_value = SUCCEED;
@@ -408,7 +408,7 @@ done:
     Set a parameter from a template
  USAGE
     herr_t H5Csetparm(tid, parm, buf)
-        hatom_t tid;        IN: Template object to store parameter in
+        hid_t tid;        IN: Template object to store parameter in
         file_create_param_t parm;   IN: Parameter to store
         const VOIDP buf;    IN: Pointer to parameter buffer
  RETURNS
@@ -431,7 +431,7 @@ done:
 	Robb Matzke, 15 Sep 1997
 	Fixed the power-of-two test to work with any size integer.
 --------------------------------------------------------------------------*/
-herr_t H5Csetparm(hatom_t tid, file_create_param_t parm, const VOIDP buf)
+herr_t H5Csetparm(hid_t tid, file_create_param_t parm, const VOIDP buf)
 {
     file_create_temp_t *template;    /* template to query */
     herr_t ret_value = SUCCEED;
@@ -537,15 +537,15 @@ done:
  PURPOSE
     Copy a template
  USAGE
-    hatom_t H5C_copy(tid)
-        hatom_t tid;        IN: Template object to copy
+    hid_t H5C_copy(tid)
+        hid_t tid;        IN: Template object to copy
  RETURNS
     Returns template ID (atom) on success, FAIL on failure
  DESCRIPTION
     This function creates a new copy of a template with all the same parameter
     settings.
 --------------------------------------------------------------------------*/
-hatom_t H5C_copy(hatom_t tid)
+hid_t H5C_copy(hid_t tid)
 {
     file_create_temp_t *template, *new_template;    /* template to query */
     herr_t ret_value = SUCCEED;
diff --git a/src/H5Cprivate.h b/src/H5Cprivate.h
index 6551d10..675fba6 100644
--- a/src/H5Cprivate.h
+++ b/src/H5Cprivate.h
@@ -43,10 +43,10 @@
     0					/* unused			*/    \
 }
 
-hatom_t H5C_create(hatom_t owner_id, hobjtype_t type, const char *name);
-hatom_t H5C_copy(hatom_t tid);
-herr_t H5C_release(hatom_t oid);
-hatom_t H5C_get_default_atom(hobjtype_t type);
-herr_t H5C_init(hatom_t dst_atm, const file_create_temp_t *src);
+hid_t H5C_create(hid_t owner_id, hobjtype_t type, const char *name);
+hid_t H5C_copy(hid_t tid);
+herr_t H5C_release(hid_t oid);
+hid_t H5C_get_default_atom(hobjtype_t type);
+herr_t H5C_init(hid_t dst_atm, const file_create_temp_t *src);
 
 #endif
diff --git a/src/H5Cpublic.h b/src/H5Cpublic.h
index ed7c777..0a8c8c0 100644
--- a/src/H5Cpublic.h
+++ b/src/H5Cpublic.h
@@ -45,8 +45,8 @@ typedef enum {
 typedef group_t hobjtype_t;     /* Map the object in the "meta" interface to atom groups */
 
 /* Functions in H5C.c */
-herr_t H5Cgetparm(hatom_t tid, file_create_param_t parm, VOIDP buf);
-herr_t H5Csetparm(hatom_t tid, file_create_param_t parm, const VOIDP buf);
+herr_t H5Cgetparm(hid_t tid, file_create_param_t parm, VOIDP buf);
+herr_t H5Csetparm(hid_t tid, file_create_param_t parm, const VOIDP buf);
 void H5C_term_interface (void);
 
 #ifdef __cplusplus
diff --git a/src/H5D.c b/src/H5D.c
index 08dfd81..4ed1fa6 100644
--- a/src/H5D.c
+++ b/src/H5D.c
@@ -115,8 +115,8 @@ void H5D_term_interface (void)
  PURPOSE
     Create a new HDF5 dataset object
  USAGE
-    hatom_t H5D_create(owner_id, type, name)
-        hatom_t owner_id;       IN: Group/file which owns this object
+    hid_t H5D_create(owner_id, type, name)
+        hid_t owner_id;       IN: Group/file which owns this object
         hobjtype_t type;        IN: Type of object to create
         const char *name;       IN: Name of the object
  RETURNS
@@ -125,10 +125,10 @@ void H5D_term_interface (void)
     This function actually creates a dataset object in a file (of course,
     output might not happen for some time).
 --------------------------------------------------------------------------*/
-hatom_t H5D_create(hatom_t owner_id, hobjtype_t type, const char *name)
+hid_t H5D_create(hid_t owner_id, hobjtype_t type, const char *name)
 {
     H5D_t *new_dset;        /* new dataset object to create */
-    hatom_t ret_value = SUCCEED;
+    hid_t ret_value = SUCCEED;
     hdf5_file_t *file = NULL;
     
     FUNC_ENTER(H5D_create, H5D_init_interface, FAIL);
@@ -179,7 +179,7 @@ done:
     Get the OID for accessing an existing HDF5 dataset object
  USAGE
     hoid_t H5D_find_name(grp_id, type, name)
-        hatom_t grp_id;         IN: Atom for directory to search for dataset
+        hid_t grp_id;         IN: Atom for directory to search for dataset
         hobjtype_t type;        IN: Type of object to search for (dataset in
  	                        this case)
         const char *name;       IN: Name of the object to search for
@@ -188,11 +188,11 @@ done:
  DESCRIPTION
         This function finds for a dataset by name in a directory.
 --------------------------------------------------------------------------*/
-hatom_t H5D_find_name(hatom_t grp_id, hobjtype_t type, const char *name)
+hid_t H5D_find_name(hid_t grp_id, hobjtype_t type, const char *name)
 {
     hdf5_file_t *file;          /* Pointer to the file-store of this object */
     H5D_t	*dset = NULL;	/* The dataset				    */
-    hatom_t ret_value = SUCCEED;
+    hid_t ret_value = SUCCEED;
     H5O_std_store_t store;
 
     FUNC_ENTER(H5D_find_name, H5D_init_interface, FAIL);
@@ -266,15 +266,15 @@ done:
     Set the type and dimensionality of a dataset.
  USAGE
     herr_t H5Dset_info(oid)
-        hatom_t oid;       IN: Dataset object to modify
-        hatom_t tid;       IN: Datatype object to use as node element
-        hatom_t did;       IN: Dimensionality object to use as dataspace
+        hid_t oid;       IN: Dataset object to modify
+        hid_t tid;       IN: Datatype object to use as node element
+        hid_t did;       IN: Dimensionality object to use as dataspace
  RETURNS
     SUCCEED/FAIL
  DESCRIPTION
         This function sets the datatype and dataspace of a dataset.
 --------------------------------------------------------------------------*/
-herr_t H5Dset_info(hatom_t oid, hatom_t tid, hatom_t did)
+herr_t H5Dset_info(hid_t oid, hid_t tid, hid_t did)
 {
     H5D_t	*dataset = NULL;         /* dataset object to modify */
     herr_t      ret_value = SUCCEED;
@@ -318,9 +318,9 @@ done:
     Get the type and dimensionality of a dataset.
  USAGE
     herr_t H5Dget_info(oid, tid, sid)
-        hatom_t oid;       IN: Dataset object to query
-        hatom_t *tid;      OUT: Datatype object to use as node element
-        hatom_t *sid;      OUT: Dimensionality object to use as dataspace
+        hid_t oid;       IN: Dataset object to query
+        hid_t *tid;      OUT: Datatype object to use as node element
+        hid_t *sid;      OUT: Dimensionality object to use as dataspace
  RETURNS
     SUCCEED/FAIL
  DESCRIPTION
@@ -328,7 +328,7 @@ done:
     existing dataset.  H5Mendaccess must be called to release the datatype and
     dataspace returned from this function.
 --------------------------------------------------------------------------*/
-herr_t H5Dget_info(hatom_t oid, hatom_t *tid, hatom_t *sid)
+herr_t H5Dget_info(hid_t oid, hid_t *tid, hid_t *sid)
 {
     H5D_t 	  *dataset;         /* dataset object to query */
     herr_t        ret_value = SUCCEED;
@@ -372,8 +372,8 @@ done:
     Read data from a dataset
  USAGE
     herr_t H5Dread(oid)
-        hatom_t oid;       IN: Dataset to read
-        hatom_t did;       IN: Dimensionality object to use as dataspace for I/O
+        hid_t oid;       IN: Dataset to read
+        hid_t did;       IN: Dimensionality object to use as dataspace for I/O
         VOIDP buf;         IN: Buffer to fill with data from the file
  RETURNS
     SUCCEED/FAIL
@@ -384,7 +384,7 @@ done:
     to be written out.  (For datasets which have a scalar dataspace for the
     entire dataset, this is somewhat redundant.... :-)
 --------------------------------------------------------------------------*/
-herr_t H5Dread(hatom_t oid, hatom_t did, VOIDP buf)
+herr_t H5Dread(hid_t oid, hid_t did, VOIDP buf)
 {
     H5D_t *dataset; /* dataset object to do I/O on */
     void *readbuf=NULL;     /* pointer to buffer to write out */
@@ -456,8 +456,8 @@ done:
     Write data for a dataset
  USAGE
     herr_t H5Dwrite(oid)
-        hatom_t oid;       IN: Dataset object to modify
-        hatom_t did;       IN: Dimensionality object to use as dataspace for I/O
+        hid_t oid;       IN: Dataset object to modify
+        hid_t did;       IN: Dimensionality object to use as dataspace for I/O
         VOIDP buf;         IN: Buffer with data to write to the file
  RETURNS
     SUCCEED/FAIL
@@ -468,7 +468,7 @@ done:
     to be written out.  (For datasets which have a scalar dataspace for the
     entire dataset, this is somewhat redundant.... :-)
 --------------------------------------------------------------------------*/
-herr_t H5Dwrite(hatom_t oid, hatom_t did, VOIDP buf)
+herr_t H5Dwrite(hid_t oid, hid_t did, VOIDP buf)
 {
     H5D_t *dataset;         /* dataset object to do I/O on */
     uintn   towrite;        /* number of bytes to write out */
@@ -544,7 +544,7 @@ done:
     Flush an an HDF5 dataset object to disk.
  USAGE
     herr_t H5D_flush(oid)
-        hatom_t oid;       IN: Object to flush to disk
+        hid_t oid;       IN: Object to flush to disk
  RETURNS
     SUCCEED/FAIL
  DESCRIPTION
@@ -553,7 +553,7 @@ done:
     any changes on disk)  This function is primarily called from H5Mflush, but
     internal library routines may call it also.
 --------------------------------------------------------------------------*/
-herr_t H5D_flush(hatom_t oid)
+herr_t H5D_flush(hid_t oid)
 {
     H5D_t 	*dataset;         /* dataset object to release */
     herr_t	ret_value = SUCCEED;
@@ -635,13 +635,13 @@ done:
     Release access to an HDF5 dataset object.
  USAGE
     herr_t H5D_release(oid)
-        hatom_t oid;       IN: Object to release access to
+        hid_t oid;       IN: Object to release access to
  RETURNS
     SUCCEED/FAIL
  DESCRIPTION
         This function releases a dataset from active use by a user.
 --------------------------------------------------------------------------*/
-herr_t H5D_release(hatom_t oid)
+herr_t H5D_release(hid_t oid)
 {
     H5D_t 	*dataset;         /* dataset object to release */
     herr_t      ret_value = SUCCEED;
diff --git a/src/H5Dprivate.h b/src/H5Dprivate.h
index 149de5e..917e001 100644
--- a/src/H5Dprivate.h
+++ b/src/H5Dprivate.h
@@ -34,11 +34,11 @@
 #define H5D_MINHDR_SIZE 512
 
 /*-----------------_-- Local function prototypes ----------------------------*/
-hatom_t H5D_create(hatom_t owner_id, hobjtype_t type, const char *name);
-hatom_t H5D_access_by_name (hatom_t owner_id,  const char *name); 
-hatom_t H5D_find_name(hatom_t owner_id, hobjtype_t type, const char *name);
-herr_t H5D_flush(hatom_t oid);
-herr_t H5D_release(hatom_t oid);
+hid_t H5D_create(hid_t owner_id, hobjtype_t type, const char *name);
+hid_t H5D_access_by_name (hid_t owner_id,  const char *name); 
+hid_t H5D_find_name(hid_t owner_id, hobjtype_t type, const char *name);
+herr_t H5D_flush(hid_t oid);
+herr_t H5D_release(hid_t oid);
 /* in H5Dconv.c */
 herr_t H5D_convert_buf(void *dst,const void *src,uintn len,uintn size);
 
diff --git a/src/H5Dpublic.h b/src/H5Dpublic.h
index 6603d55..ba10161 100644
--- a/src/H5Dpublic.h
+++ b/src/H5Dpublic.h
@@ -28,10 +28,10 @@ extern "C" {
 #endif
 
 /* Functions in H5D.c */
-herr_t H5Dset_info(hatom_t oid, hatom_t tid, hatom_t did);
-herr_t H5Dget_info(hatom_t oid, hatom_t *tid, hatom_t *sid);
-herr_t H5Dwrite(hatom_t oid, hatom_t did, VOIDP buf);
-herr_t H5Dread(hatom_t oid, hatom_t did, VOIDP buf);
+herr_t H5Dset_info(hid_t oid, hid_t tid, hid_t did);
+herr_t H5Dget_info(hid_t oid, hid_t *tid, hid_t *sid);
+herr_t H5Dwrite(hid_t oid, hid_t did, VOIDP buf);
+herr_t H5Dread(hid_t oid, hid_t did, VOIDP buf);
 void H5D_term_interface (void);
 
 #ifdef __cplusplus
diff --git a/src/H5F.c b/src/H5F.c
index c3f0a66..d2979fa 100644
--- a/src/H5F.c
+++ b/src/H5F.c
@@ -234,8 +234,8 @@ H5F_compare_filename (const VOIDP _obj, const VOIDP _key)
     Get an atom for a copy of the file-creation template for this file
 
  USAGE
-    hatom_t H5Fget_create_template(fid)
-        hatom_t fid;    IN: File ID
+    hid_t H5Fget_create_template(fid)
+        hid_t fid;    IN: File ID
 
  ERRORS
     ATOM      BADATOM       Can't get file struct. 
@@ -249,10 +249,10 @@ H5F_compare_filename (const VOIDP _obj, const VOIDP _key)
         This function returns an atom with a copy of the template parameters
     used to create a file.
 --------------------------------------------------------------------------*/
-hatom_t H5Fget_create_template(hatom_t fid)
+hid_t H5Fget_create_template(hid_t fid)
 {
     hdf5_file_t *file=NULL;         /* file struct for file to close */
-    hatom_t ret_value = FAIL;
+    hid_t ret_value = FAIL;
 
     FUNC_ENTER(H5Fget_create_template, H5F_init_interface, FAIL);
 
@@ -456,8 +456,8 @@ H5F_dest (hdf5_file_t *f)
     int32 H5Fcreate(filename, flags, create_temp, access_temp)
         const char *filename;   IN: Name of the file to create
         uintn flags;            IN: Flags to indicate various options.
-        hatom_t create_temp;    IN: File-creation template ID
-        hatom_t access_temp;    IN: File-access template ID
+        hid_t create_temp;    IN: File-creation template ID
+        hid_t access_temp;    IN: File-access template ID
 
  ERRORS
     ARGS      BADVALUE      Invalid file name. 
@@ -500,13 +500,13 @@ H5F_dest (hdf5_file_t *f)
     Robb Matzke, 29 Aug 1997
     Moved creation of the boot block to H5F_flush().
 --------------------------------------------------------------------------*/
-hatom_t H5Fcreate(const char *filename, uintn flags, hatom_t create_temp, hatom_t access_temp)
+hid_t H5Fcreate(const char *filename, uintn flags, hid_t create_temp, hid_t access_temp)
 {
     hdf5_file_t *new_file=NULL;     /* file struct for new file */
     hdf_file_t f_handle=H5F_INVALID_FILE;  /* file handle */
     const file_create_temp_t *f_create_parms;    /* pointer to the parameters to use when creating the file */
     intn file_exists=0;             /* flag to indicate that file exists already */
-    hatom_t ret_value = FAIL;
+    hid_t ret_value = FAIL;
 
     FUNC_ENTER(H5Fcreate, H5F_init_interface, FAIL);
 
@@ -607,10 +607,10 @@ done:
     Open an existing HDF5 file.
 
  USAGE
-    hatom_t H5Fopen(filename, flags, access_temp)
+    hid_t H5Fopen(filename, flags, access_temp)
         const char *filename;   IN: Name of the file to create
         uintn flags;            IN: Flags to indicate various options.
-        hatom_t access_temp;    IN: File-access template
+        hid_t access_temp;    IN: File-access template
 
  ERRORS
     ARGS      BADRANGE      Invalid file name. 
@@ -647,16 +647,16 @@ done:
     File struct creation and destruction is through H5F_new() H5F_dest().
     Reading the root symbol table entry is done with H5G_decode().
 --------------------------------------------------------------------------*/
-hatom_t H5Fopen(const char *filename, uintn flags, hatom_t access_temp)
+hid_t H5Fopen(const char *filename, uintn flags, hid_t access_temp)
 {
     hdf5_file_t *new_file=NULL;     /* file struct for new file */
     hdf_file_t f_handle=H5F_INVALID_FILE;  /* file handle */
-    hatom_t create_temp;            /* file-creation template ID */
+    hid_t create_temp;            /* file-creation template ID */
     const file_create_temp_t *f_create_parms;    /* pointer to the parameters to use when creating the file */
     uint8 temp_buf[2048], *p;       /* temporary buffer for encoding header */
     haddr_t curr_off=0;          /* The current offset to check in the file */
     size_t file_len=0;          /* The length of the file we are checking */
-    hatom_t ret_value = FAIL;
+    hid_t ret_value = FAIL;
     size_t	variable_size;	/*size of the variable part of the bb */
 
     FUNC_ENTER(H5Fopen, H5F_init_interface, FAIL);
@@ -819,7 +819,7 @@ done:
 
  USAGE
     herr_t H5Fclose(fid, invalidate)
-        hatom_t fid;      	IN: File ID of file to close.
+        hid_t fid;      	IN: File ID of file to close.
         hbool_t invalidate;	IN: Invalidate all of the cache?
 
  ERRORS
@@ -838,7 +838,7 @@ done:
  MODIFICATIONS:
 --------------------------------------------------------------------------*/
 herr_t
-H5Fflush (hatom_t fid, hbool_t invalidate)
+H5Fflush (hid_t fid, hbool_t invalidate)
 {
    hdf5_file_t	*file = NULL;
 
@@ -978,7 +978,7 @@ H5F_flush (hdf5_file_t *f, hbool_t invalidate)
     The file boot block is flushed to disk since it's contents may have
     changed.
 --------------------------------------------------------------------------*/
-herr_t H5Fclose(hatom_t fid)
+herr_t H5Fclose(hid_t fid)
 {
     hdf5_file_t *file=NULL;         /* file struct for file to close */
     herr_t        ret_value = SUCCEED;
diff --git a/src/H5Fpublic.h b/src/H5Fpublic.h
index b999b2d..c100239 100644
--- a/src/H5Fpublic.h
+++ b/src/H5Fpublic.h
@@ -33,11 +33,11 @@ extern "C" {
 
 /* Functions in H5F.c */
 hbool_t H5Fis_hdf5(const char *filename);
-hatom_t H5Fcreate(const char *filename, uintn flags, hatom_t create_template, hatom_t access_template);
-hatom_t H5Fopen(const char *filename, uintn flags, hatom_t access_template);
-herr_t H5Fclose(hatom_t fid);
-herr_t H5Fflush (hatom_t fid, hbool_t invalidate);
-hatom_t H5Fget_create_template(hatom_t fid);
+hid_t H5Fcreate(const char *filename, uintn flags, hid_t create_template, hid_t access_template);
+hid_t H5Fopen(const char *filename, uintn flags, hid_t access_template);
+herr_t H5Fclose(hid_t fid);
+herr_t H5Fflush (hid_t fid, hbool_t invalidate);
+hid_t H5Fget_create_template(hid_t fid);
 void H5F_term_interface (void);
 
 #ifdef __cplusplus
diff --git a/src/H5M.c b/src/H5M.c
index da9268b..750fe17 100644
--- a/src/H5M.c
+++ b/src/H5M.c
@@ -208,8 +208,8 @@ done:
  PURPOSE
     Create a new HDF5 object.
  USAGE
-    hatom_t H5Mcreate(owner_id, type, name)
-        hatom_t owner_id;       IN: Group/file which owns this object
+    hid_t H5Mcreate(owner_id, type, name)
+        hid_t owner_id;       IN: Group/file which owns this object
         hobjtype_t type;        IN: Type of object to create
         const char *name;       IN: Name of the object
  RETURNS
@@ -218,10 +218,10 @@ done:
         This function re-directs the object's creation into the appropriate
     interface, as defined by the function pointers in hdf5fptr.h
 --------------------------------------------------------------------------*/
-hatom_t H5Mcreate(hatom_t owner_id, hobjtype_t type, const char *name)
+hid_t H5Mcreate(hid_t owner_id, hobjtype_t type, const char *name)
 {
     intn i;         /* local counting variable */
-    hatom_t        ret_value = SUCCEED;
+    hid_t        ret_value = SUCCEED;
 
     FUNC_ENTER(H5Mcreate, H5M_init_interface, FAIL);
 
@@ -252,19 +252,19 @@ done:
  PURPOSE
     Start access to an existing HDF5 object.
  USAGE
-    hatom_t H5Maccess(owner_id)
-        hatom_t oid;       IN: OID of the object to access.
+    hid_t H5Maccess(owner_id)
+        hid_t oid;       IN: OID of the object to access.
  RETURNS
     Returns ID (atom) on success, FAIL on failure
  DESCRIPTION
         This function re-directs the object's access into the appropriate
     interface, as defined by the function pointers in hdf5fptr.h
 --------------------------------------------------------------------------*/
-hatom_t H5Maccess(hatom_t oid)
+hid_t H5Maccess(hid_t oid)
 {
     group_t 	   group;
     intn i;         /* local counting variable */
-    hatom_t        ret_value = SUCCEED;
+    hid_t        ret_value = SUCCEED;
 
     FUNC_ENTER(H5Maccess, H5M_init_interface, FAIL);
 
@@ -298,15 +298,15 @@ done:
  PURPOSE
     Copy an HDF5 object.
  USAGE
-    hatom_t H5Mcopy(oid)
-        hatom_t oid;       IN: Object to copy
+    hid_t H5Mcopy(oid)
+        hid_t oid;       IN: Object to copy
  RETURNS
     SUCCEED/FAIL
  DESCRIPTION
         This function re-directs the object's copy into the appropriate
     interface, as defined by the function pointers in hdf5fptr.h
 --------------------------------------------------------------------------*/
-hatom_t H5Mcopy(hatom_t oid)
+hid_t H5Mcopy(hid_t oid)
 {
     group_t group=H5Aatom_group(oid);   /* Atom group for incoming object */
     intn i;         /* local counting variable */
@@ -341,8 +341,8 @@ done:
  PURPOSE
     Find an HDF5 object by name.
  USAGE
-    hatom_t H5Mfind_name(owner_id, type, name)
-        hatom_t owner_id;       IN: Group/file in which to search
+    hid_t H5Mfind_name(owner_id, type, name)
+        hid_t owner_id;       IN: Group/file in which to search
         hobjtype_t type;        IN: Type of object to search names of
         const char *name;       IN: Name of the object to search for
  RETURNS
@@ -351,13 +351,13 @@ done:
         This function re-directs the object's "find name" into the appropriate
     interface, as defined by the function pointers in hdf5fptr.h
 --------------------------------------------------------------------------*/
-hatom_t H5Mfind_name(hatom_t owner_id, hobjtype_t type, const char *name)
+hid_t H5Mfind_name(hid_t owner_id, hobjtype_t type, const char *name)
 {
 #ifdef OLD_WAY
     group_t group=H5Aatom_group(owner_id);   /* Atom group for incoming object */
 #endif /* OLD_WAY */
     intn i;         /* local counting variable */
-    hatom_t        ret_value = SUCCEED;
+    hid_t        ret_value = SUCCEED;
 
     FUNC_ENTER(H5Mfind_name, H5M_init_interface, FAIL);
 
@@ -396,14 +396,14 @@ done:
     Determine the length of the name of an HDF5 object.
  USAGE
     uint32 H5Mname_len(oid)
-        hatom_t oid;       IN: Object to get name's length
+        hid_t oid;       IN: Object to get name's length
  RETURNS
     SUCCEED/FAIL
  DESCRIPTION
         This function re-directs the object's "name length" into the appropriate
     interface, as defined by the function pointers in hdf5fptr.h
 --------------------------------------------------------------------------*/
-uint32 H5Mname_len(hatom_t oid)
+uint32 H5Mname_len(hid_t oid)
 {
     group_t group=H5Aatom_group(oid);   /* Atom group for incoming object */
     intn i;         /* local counting variable */
@@ -439,7 +439,7 @@ done:
     Get the name of an HDF5 object.
  USAGE
     herr_t H5Mget_name(oid, name)
-        hatom_t oid;            IN: Object to retreive name of
+        hid_t oid;            IN: Object to retreive name of
         char *name;             OUT: Buffer to place object's name in
  RETURNS
     SUCCEED/FAIL
@@ -447,11 +447,11 @@ done:
         This function re-directs the object's "get name" into the appropriate
     interface, as defined by the function pointers in hdf5fptr.h
 --------------------------------------------------------------------------*/
-herr_t H5Mget_name(hatom_t oid, char *name)
+herr_t H5Mget_name(hid_t oid, char *name)
 {
     group_t group=H5Aatom_group(oid);   /* Atom group for incoming object */
     intn i;         /* local counting variable */
-    hatom_t        ret_value = SUCCEED;
+    hid_t        ret_value = SUCCEED;
 
     FUNC_ENTER(H5Mget_name, H5M_init_interface, FAIL);
 
@@ -483,7 +483,7 @@ done:
     Set the name of an HDF5 object.
  USAGE
     herr_t H5Mget_name(oid, name)
-        hatom_t oid;            IN: Object to set name of
+        hid_t oid;            IN: Object to set name of
         const char *name;       IN: Name to use for object
  RETURNS
     SUCCEED/FAIL
@@ -491,11 +491,11 @@ done:
         This function re-directs the object's "set name" into the appropriate
     interface, as defined by the function pointers in hdf5fptr.h
 --------------------------------------------------------------------------*/
-herr_t H5Mset_name(hatom_t oid, const char *name)
+herr_t H5Mset_name(hid_t oid, const char *name)
 {
     group_t group=H5Aatom_group(oid);   /* Atom group for incoming object */
     intn i;         /* local counting variable */
-    hatom_t        ret_value = SUCCEED;
+    hid_t        ret_value = SUCCEED;
 
     FUNC_ENTER(H5Mset_name, H5M_init_interface, FAIL);
 
@@ -526,8 +526,8 @@ done:
  PURPOSE
     Wildcard search for an HDF5 object by name.
  USAGE
-    hatom_t H5Mfind_name(owner_id, type, name)
-        hatom_t owner_id;       IN: Group/file in which to search
+    hid_t H5Mfind_name(owner_id, type, name)
+        hid_t owner_id;       IN: Group/file in which to search
         hobjtype_t type;        IN: Type of object to search names of
         const char *name;       IN: Name of the object to search for
  RETURNS
@@ -536,11 +536,11 @@ done:
         This function re-directs the object's "search" into the appropriate
     interface, as defined by the function pointers in hdf5fptr.h
 --------------------------------------------------------------------------*/
-hatom_t H5Msearch(hatom_t oid, hobjtype_t type, const char *name)
+hid_t H5Msearch(hid_t oid, hobjtype_t type, const char *name)
 {
     group_t group=H5Aatom_group(oid);   /* Atom group for incoming object */
     intn i;         /* local counting variable */
-    hatom_t        ret_value = SUCCEED;
+    hid_t        ret_value = SUCCEED;
 
     FUNC_ENTER(H5Msearch, H5M_init_interface, FAIL);
 
@@ -571,8 +571,8 @@ done:
  PURPOSE
     Get an HDF5 object by index.
  USAGE
-    hatom_t H5Mindex(oid, type, idx)
-        hatom_t oid;            IN: Group/file in which to find items
+    hid_t H5Mindex(oid, type, idx)
+        hid_t oid;            IN: Group/file in which to find items
         hobjtype_t type;        IN: Type of object to get
         uint32 idx;             IN: Index of the object to get
  RETURNS
@@ -581,11 +581,11 @@ done:
         This function re-directs the object's "index" into the appropriate
     interface, as defined by the function pointers in hdf5fptr.h
 --------------------------------------------------------------------------*/
-hatom_t H5Mindex(hatom_t oid, hobjtype_t type, uint32 idx)
+hid_t H5Mindex(hid_t oid, hobjtype_t type, uint32 idx)
 {
     group_t group=H5Aatom_group(oid);   /* Atom group for incoming object */
     intn i;         /* local counting variable */
-    hatom_t        ret_value = SUCCEED;
+    hid_t        ret_value = SUCCEED;
 
     FUNC_ENTER(H5Mindex, H5M_init_interface, FAIL);
 
@@ -616,15 +616,15 @@ done:
  PURPOSE
     Flush an HDF5 object out to a file.
  USAGE
-    hatom_t H5Mflush(oid)
-        hatom_t oid;       IN: Object to flush
+    hid_t H5Mflush(oid)
+        hid_t oid;       IN: Object to flush
  RETURNS
     SUCCEED/FAIL
  DESCRIPTION
         This function re-directs the object's flush into the appropriate
     interface, as defined by the function pointers in hdf5fptr.h
 --------------------------------------------------------------------------*/
-hatom_t H5Mflush(hatom_t oid)
+hid_t H5Mflush(hid_t oid)
 {
     group_t group;   /* Atom group for incoming object */
     intn i;         /* local counting variable */
@@ -662,7 +662,7 @@ done:
     Delete an HDF5 object from a file.
  USAGE
     herr_t H5Mdelete(oid)
-        hatom_t oid;       IN: Object to delete
+        hid_t oid;       IN: Object to delete
  RETURNS
     SUCCEED/FAIL
  DESCRIPTION
@@ -670,7 +670,7 @@ done:
     interface, as defined by the function pointers in hdf5fptr.h.  Deleting
     an object implicitly ends access to it.
 --------------------------------------------------------------------------*/
-herr_t H5Mdelete(hatom_t oid)
+herr_t H5Mdelete(hid_t oid)
 {
     group_t group=H5Aatom_group(oid);   /* Atom group for incoming object */
     intn i;         /* local counting variable */
@@ -705,15 +705,15 @@ done:
  PURPOSE
     Get the parent ID an HDF5 object.
  USAGE
-    hatom_t H5Mget_parent(oid)
-        hatom_t oid;       IN: Object to query
+    hid_t H5Mget_parent(oid)
+        hid_t oid;       IN: Object to query
  RETURNS
     SUCCEED/FAIL
  DESCRIPTION
         This function re-directs the object's query into the appropriate
     interface, as defined by the function pointers in hdf5fptr.h
 --------------------------------------------------------------------------*/
-hatom_t H5Mget_parent(hatom_t oid)
+hid_t H5Mget_parent(hid_t oid)
 {
     group_t group=H5Aatom_group(oid);   /* Atom group for incoming object */
     intn i;         /* local counting variable */
@@ -748,15 +748,15 @@ done:
  PURPOSE
     Get the file ID an HDF5 object.
  USAGE
-    hatom_t H5Mget_file(oid)
-        hatom_t oid;       IN: Object to query
+    hid_t H5Mget_file(oid)
+        hid_t oid;       IN: Object to query
  RETURNS
     SUCCEED/FAIL
  DESCRIPTION
         This function re-directs the object's query into the appropriate
     interface, as defined by the function pointers in hdf5fptr.h
 --------------------------------------------------------------------------*/
-hatom_t H5Mget_file(hatom_t oid)
+hid_t H5Mget_file(hid_t oid)
 {
     group_t group=H5Aatom_group(oid);   /* Atom group for incoming object */
     intn i;         /* local counting variable */
@@ -792,14 +792,14 @@ done:
     Release access to an HDF5 object.
  USAGE
     herr_t H5Mrelease(oid)
-        hatom_t oid;       IN: Object to release access to
+        hid_t oid;       IN: Object to release access to
  RETURNS
     SUCCEED/FAIL
  DESCRIPTION
         This function re-directs the object's release into the appropriate
     interface, as defined by the function pointers in hdf5fptr.h
 --------------------------------------------------------------------------*/
-herr_t H5Mrelease(hatom_t oid)
+herr_t H5Mrelease(hid_t oid)
 {
     group_t group=H5Aatom_group(oid);   /* Atom group for incoming object */
     intn i;         /* local counting variable */
diff --git a/src/H5Mprivate.h b/src/H5Mprivate.h
index 8455dc7..8f48a8c 100644
--- a/src/H5Mprivate.h
+++ b/src/H5Mprivate.h
@@ -30,20 +30,20 @@
 typedef struct meta_func_t
   {
     hobjtype_t type;            /* Object type this interface is for */
-    hatom_t (*create) (hatom_t , hobjtype_t, const char *);   /* Object creation function */
-    hatom_t (*access) (hatom_t );   /* Object access function */
-    hatom_t (*copy) (hatom_t );     /* Object copy function */
-    hatom_t (*find_name) (hatom_t , hobjtype_t, const char *); /* Find first object */
-    uint32  (*name_len) (hatom_t );     /* Get length of object name */
-    herr_t  (*get_name) (hatom_t , char *);     /* Get object name */
-    herr_t  (*set_name) (hatom_t , const char *);   /* Set object name */
-    hatom_t (*search) (hatom_t , hobjtype_t, const char *); /* Search for list of objects */
-    hatom_t (*index) (hatom_t , hobjtype_t, uint32);    /* Get the OID for the n'th object */
-    herr_t  (*flush) (hatom_t );    /* Flush the object to disk */
-    herr_t  (*delete) (hatom_t );   /* Delete an object from file */
-    hatom_t (*get_parent) (hatom_t );   /* Get the parent object of an object */
-    hatom_t (*get_file) (hatom_t ); /* Get the file ID of an object */
-    herr_t  (*release) (hatom_t );  /* End access to an object */
+    hid_t (*create) (hid_t , hobjtype_t, const char *);   /* Object creation function */
+    hid_t (*access) (hid_t );   /* Object access function */
+    hid_t (*copy) (hid_t );     /* Object copy function */
+    hid_t (*find_name) (hid_t , hobjtype_t, const char *); /* Find first object */
+    uint32  (*name_len) (hid_t );     /* Get length of object name */
+    herr_t  (*get_name) (hid_t , char *);     /* Get object name */
+    herr_t  (*set_name) (hid_t , const char *);   /* Set object name */
+    hid_t (*search) (hid_t , hobjtype_t, const char *); /* Search for list of objects */
+    hid_t (*index) (hid_t , hobjtype_t, uint32);    /* Get the OID for the n'th object */
+    herr_t  (*flush) (hid_t );    /* Flush the object to disk */
+    herr_t  (*delete) (hid_t );   /* Delete an object from file */
+    hid_t (*get_parent) (hid_t );   /* Get the parent object of an object */
+    hid_t (*get_file) (hid_t ); /* Get the file ID of an object */
+    herr_t  (*release) (hid_t );  /* End access to an object */
   }
 meta_func_t;
 
diff --git a/src/H5Mpublic.h b/src/H5Mpublic.h
index 466236d..6bb3eb3 100644
--- a/src/H5Mpublic.h
+++ b/src/H5Mpublic.h
@@ -29,20 +29,20 @@ extern "C" {
 #endif
 
 /* Functions in H5M.c */
-hatom_t H5Mcreate(hatom_t owner_id, hobjtype_t type, const char *name);
-hatom_t H5Maccess(hatom_t oid);
-hatom_t H5Mcopy(hatom_t oid);
-hatom_t H5Mfind_name(hatom_t oid, hobjtype_t type, const char *name);
-uint32 H5Mname_len(hatom_t oid);
-herr_t H5Mget_name(hatom_t oid, char *name);
-herr_t H5Mset_name(hatom_t oid, const char *name);
-hatom_t H5Msearch(hatom_t oid, hobjtype_t type, const char *name);
-hatom_t H5Mindex(hatom_t oid, hobjtype_t type, uint32 idx);
-hatom_t H5Mflush(hatom_t oid);
-herr_t H5Mdelete(hatom_t oid);
-hatom_t H5Mget_file(hatom_t oid);
-hatom_t H5Mget_parent(hatom_t oid);
-herr_t H5Mrelease(hatom_t oid);
+hid_t H5Mcreate(hid_t owner_id, hobjtype_t type, const char *name);
+hid_t H5Maccess(hid_t oid);
+hid_t H5Mcopy(hid_t oid);
+hid_t H5Mfind_name(hid_t oid, hobjtype_t type, const char *name);
+uint32 H5Mname_len(hid_t oid);
+herr_t H5Mget_name(hid_t oid, char *name);
+herr_t H5Mset_name(hid_t oid, const char *name);
+hid_t H5Msearch(hid_t oid, hobjtype_t type, const char *name);
+hid_t H5Mindex(hid_t oid, hobjtype_t type, uint32 idx);
+hid_t H5Mflush(hid_t oid);
+herr_t H5Mdelete(hid_t oid);
+hid_t H5Mget_file(hid_t oid);
+hid_t H5Mget_parent(hid_t oid);
+herr_t H5Mrelease(hid_t oid);
 
 #ifdef __cplusplus
 }
diff --git a/src/H5P.c b/src/H5P.c
index f643022..d91b5b8 100644
--- a/src/H5P.c
+++ b/src/H5P.c
@@ -97,8 +97,8 @@ void H5P_term_interface (void)
  PURPOSE
     Create a new HDF5 dimensionality object
  USAGE
-    hatom_t H5P_create(owner_id, type, name)
-        hatom_t owner_id;       IN: Group/file which owns this object
+    hid_t H5P_create(owner_id, type, name)
+        hid_t owner_id;       IN: Group/file which owns this object
         hobjtype_t type;        IN: Type of object to create
         const char *name;       IN: Name of the object
  RETURNS
@@ -106,10 +106,10 @@ void H5P_term_interface (void)
  DESCRIPTION
         This function actually creates the dimensionality object.
 --------------------------------------------------------------------------*/
-hatom_t H5P_create(hatom_t owner_id, hobjtype_t type, const char *name)
+hid_t H5P_create(hid_t owner_id, hobjtype_t type, const char *name)
 {
     H5P_dim_t *new_dim;               /* new dimensionality object to create */
-    hatom_t ret_value = SUCCEED;
+    hid_t ret_value = SUCCEED;
 
     FUNC_ENTER(H5P_create, H5P_init_interface, FAIL);
 
@@ -229,7 +229,7 @@ done:
     Determine the size of a dataspace
  USAGE
     herr_t H5Pset_space(sid, rank, dims)
-        hatom_t sid;            IN: Dataspace object to query
+        hid_t sid;            IN: Dataspace object to query
         uint32 rank;            IN: # of dimensions for the dataspace
         uint32 *dims;           IN: Size of each dimension for the dataspace
  RETURNS
@@ -243,7 +243,7 @@ done:
     expand.  Currently, only the first dimension in the array (the slowest) may
     be unlimited in size.
 --------------------------------------------------------------------------*/
-herr_t H5Pset_space(hatom_t sid, uint32 rank, uint32 *dims)
+herr_t H5Pset_space(hid_t sid, uint32 rank, uint32 *dims)
 {
     H5P_dim_t *space=NULL;      /* dataspace to modify */
     uintn u;                    /* local counting variable */
@@ -395,7 +395,7 @@ done:
     Return the number of elements in a dataspace
  USAGE
     uintn H5Pnelem(sid)
-        hatom_t sid;            IN: Dataspace object to query
+        hid_t sid;            IN: Dataspace object to query
  RETURNS
     The number of elements in a dataspace on success, UFAIL on failure
  DESCRIPTION
@@ -404,7 +404,7 @@ done:
     2, 3 and 4 would have 24 elements.
     UFAIL is returned on an error, otherwise the number of elements is returned.
 --------------------------------------------------------------------------*/
-uintn H5Pnelem(hatom_t sid)
+uintn H5Pnelem(hid_t sid)
 {
     H5P_dim_t *space=NULL;      /* dataspace to modify */
     uintn        ret_value = UFAIL;
@@ -442,13 +442,13 @@ done:
     Release access to an HDF5 dimensionality object.
  USAGE
     herr_t H5P_release(oid)
-        hatom_t oid;       IN: Object to release access to
+        hid_t oid;       IN: Object to release access to
  RETURNS
     SUCCEED/FAIL
  DESCRIPTION
         This function releases a dimensionality from active use by a user.
 --------------------------------------------------------------------------*/
-herr_t H5P_release(hatom_t oid)
+herr_t H5P_release(hid_t oid)
 {
     H5P_dim_t *dim;         /* dimensionality object to release */
     herr_t        ret_value = SUCCEED;
diff --git a/src/H5Pprivate.h b/src/H5Pprivate.h
index eaecb21..207e3e7 100644
--- a/src/H5Pprivate.h
+++ b/src/H5Pprivate.h
@@ -39,10 +39,10 @@ typedef struct H5P_sdim_t {
 #define H5P_RESERVED_ATOMS  1
 
 /* Private functions */
-hatom_t H5P_create(hatom_t owner_id, hobjtype_t type, const char *name);
+hid_t H5P_create(hid_t owner_id, hobjtype_t type, const char *name);
 uint32 H5P_get_lrank(H5P_sdim_t *sdim);
 hbool_t H5P_is_simple(H5P_dim_t *sdim);
 uintn H5P_nelem(H5P_dim_t *space);
-herr_t H5P_release(hatom_t oid);
+herr_t H5P_release(hid_t oid);
 
 #endif
diff --git a/src/H5Ppublic.h b/src/H5Ppublic.h
index 076b52c..e898bdd 100644
--- a/src/H5Ppublic.h
+++ b/src/H5Ppublic.h
@@ -41,8 +41,8 @@ extern "C" {
 #endif
 
 /* Functions in H5P.c */
-uintn H5Pnelem(hatom_t dim_id);
-herr_t H5Pset_space(hatom_t sid, uint32 rank, uint32 *dims);
+uintn H5Pnelem(hid_t dim_id);
+herr_t H5Pset_space(hid_t sid, uint32 rank, uint32 *dims);
 void H5P_term_interface (void);
 
 #ifdef __cplusplus
diff --git a/src/H5T.c b/src/H5T.c
index 840a08a..e06cbea 100644
--- a/src/H5T.c
+++ b/src/H5T.c
@@ -108,8 +108,8 @@ void H5T_term_interface (void)
  PURPOSE
     Create a new HDF5 data-type object
  USAGE
-    hatom_t H5T_create(owner_id, type, name)
-        hatom_t owner_id;       IN: Group/file which owns this object
+    hid_t H5T_create(owner_id, type, name)
+        hid_t owner_id;       IN: Group/file which owns this object
         hobjtype_t type;        IN: Type of object to create
         const char *name;       IN: Name of the object
  RETURNS
@@ -117,10 +117,10 @@ void H5T_term_interface (void)
  DESCRIPTION
         This function actually creates the data-type object.
 --------------------------------------------------------------------------*/
-hatom_t H5T_create(hatom_t owner_id, hobjtype_t type, const char *name)
+hid_t H5T_create(hid_t owner_id, hobjtype_t type, const char *name)
 {
     h5_datatype_t *new_dt;            /* new data-type object to create */
-    hatom_t ret_value = SUCCEED;
+    hid_t ret_value = SUCCEED;
 
     FUNC_ENTER(H5T_create, H5T_init_interface, FAIL);
 
@@ -158,7 +158,7 @@ done:
     Return the number of fields in a compound datatype
  USAGE
     uint32 H5Tget_num_fields(tid)
-        hatom_t tid;            IN: Datatype object to query
+        hid_t tid;            IN: Datatype object to query
  RETURNS
     The number of fields in a compound datatype on success, UFAIL on failure
  DESCRIPTION
@@ -166,7 +166,7 @@ done:
     datatype.  UFAIL is returned on an error or if an atomic datatype is
     queried, otherwise the number of fields is returned.
 --------------------------------------------------------------------------*/
-uint32 H5Tget_num_fields(hatom_t tid)
+uint32 H5Tget_num_fields(hid_t tid)
 {
     h5_datatype_t *dt;         /* new data-type object to create */
     uint32        ret_value = UFAIL;
@@ -209,7 +209,7 @@ done:
     Check if a field in a compound datatype is atomic
  USAGE
     hbool_t H5Tis_field_atomic(tid, fidx)
-        hatom_t tid;            IN: Datatype object to query
+        hid_t tid;            IN: Datatype object to query
         uintn fidx;             IN: Index of the field to query
  RETURNS
     BFAIL/BTRUE/BFALSE
@@ -218,7 +218,7 @@ done:
     BTRUE is returned if the datatype is atomic (i.e. not compound), BFALSE is
     returned if the datatype is compound, BFAIL on error.
 --------------------------------------------------------------------------*/
-hbool_t H5Tis_field_atomic(hatom_t tid, uintn fidx)
+hbool_t H5Tis_field_atomic(hid_t tid, uintn fidx)
 {
     h5_datatype_t *dt;         /* new data-type object to create */
     hbool_t        ret_value = BTRUE;
@@ -308,7 +308,7 @@ done:
     Check if a datatype is atomic (API)
  USAGE
     hbool_t H5Tis_atomic(tid)
-        hatom_t tid;            IN: Datatype object to query
+        hid_t tid;            IN: Datatype object to query
  RETURNS
     BFAIL/BTRUE/BFALSE
  DESCRIPTION
@@ -316,7 +316,7 @@ done:
     is returned if the datatype is atomic (i.e. not compound), BFALSE is
     returned if the datatype is compound, BFAIL on error.
 --------------------------------------------------------------------------*/
-hbool_t H5Tis_atomic(hatom_t tid)
+hbool_t H5Tis_atomic(hid_t tid)
 {
     h5_datatype_t *dt;         /* new data-type object to create */
     hbool_t        ret_value = BTRUE;
@@ -353,8 +353,8 @@ done:
     Set the base type of a user-defined datatype 
  USAGE
     herr_t H5Tset_type(tid, base, len, arch)
-        hatom_t tid;            IN: Datatype object to modify
-        hatom_t base;           IN: Base type to set the datatype to
+        hid_t tid;            IN: Datatype object to modify
+        hid_t base;           IN: Base type to set the datatype to
         uint8 len;              IN: Length of the object in bytes
         uint8 arch;             IN: Architecture format to store type with
  RETURNS
@@ -365,7 +365,7 @@ done:
     type) or is a compound type (like a C structure).  If the datatype is set
     to a compound type, the 'len' argument is not used.
 --------------------------------------------------------------------------*/
-herr_t H5Tset_type(hatom_t tid,hatom_t base,uint8 len,uint8 arch)
+herr_t H5Tset_type(hid_t tid,hid_t base,uint8 len,uint8 arch)
 {
     h5_datatype_t *dt;         /* new data-type object to create */
     herr_t        ret_value = SUCCEED;
@@ -406,8 +406,8 @@ done:
     Get the base type of a datatype 
  USAGE
     herr_t H5Tget_type(tid, base, len, arch)
-        hatom_t tid;            IN: Datatype object to modify
-        hatom_t *base;          IN: Base type of the datatype
+        hid_t tid;            IN: Datatype object to modify
+        hid_t *base;          IN: Base type of the datatype
         uint8 *len;             IN: Length of the object in bytes
         uint8 *arch;            IN: Architecture format type stored with
  RETURNS
@@ -418,7 +418,7 @@ done:
     type) or is a compound type (like a C structure).  If the datatype is 
     to a compound type, the 'len' argument is not used.
 --------------------------------------------------------------------------*/
-herr_t H5Tget_type(hatom_t tid,hatom_t *base,uint8 *len,uint8 *arch)
+herr_t H5Tget_type(hid_t tid,hid_t *base,uint8 *len,uint8 *arch)
 {
     h5_datatype_t *dt;         /* new data-type object to create */
     herr_t        ret_value = SUCCEED;
@@ -462,14 +462,14 @@ done:
     Add a field to a compound datatype
  USAGE
     herr_t H5Tadd_field(tid, name, base, len, arch, space)
-        hatom_t tid;            IN: Datatype object to query
+        hid_t tid;            IN: Datatype object to query
         const char *fidx;       IN: Field name
-        hatom_t base;           IN: Field's base type, either an atom ID for
+        hid_t base;           IN: Field's base type, either an atom ID for
                                     an existing compound type, or an atomic
                                     base type
         uint8 len;              IN: Length of an atomic base type
         uint8 arch;             IN: Architecture format of an atomic base type
-        hatom_t space;          IN: The dimensionality of the field to add
+        hid_t space;          IN: The dimensionality of the field to add
  RETURNS
     SUCCEED/FAIL
  DESCRIPTION
@@ -479,7 +479,7 @@ done:
     (to indicate a scalar field) or the atom of a datatype for more complex
     dimensionality fields.
 --------------------------------------------------------------------------*/
-herr_t H5Tadd_field(hatom_t tid, const char *name, hatom_t base, uint8 len, uint8 arch, hatom_t space)
+herr_t H5Tadd_field(hid_t tid, const char *name, hid_t base, uint8 len, uint8 arch, hid_t space)
 {
     h5_field_info_t *new_field; /* pointer to new field to add */
     h5_datatype_t *dt;          /* data-type object to manipulate */
@@ -636,7 +636,7 @@ done:
     Determine the size of a datatype
  USAGE
     uintn H5Tsize(tid, mem_flag)
-        hatom_t tid;            IN: Datatype object to query
+        hid_t tid;            IN: Datatype object to query
         hbool_t mem_flag;       IN: Whether the memory or disk size is desired
  RETURNS
     The size of the datatype on success or UFAIL on failure.
@@ -645,7 +645,7 @@ done:
     on disk or in memory, depending on the mem_flag.  Setting the mem_flag to
     BTRUE returns the size in memory, BFALSE returns the size on disk.
 --------------------------------------------------------------------------*/
-uintn H5Tsize(hatom_t tid, uint8 len, uint8 arch, hbool_t mem_flag)
+uintn H5Tsize(hid_t tid, uint8 len, uint8 arch, hbool_t mem_flag)
 {
     uintn ret_value = UFAIL;
 
@@ -713,7 +713,7 @@ done:
     Determine the size of a datatype
  USAGE
     herr_t H5Tget_fields(tid, field_list)
-        hatom_t tid;            IN: Datatype object to query
+        hid_t tid;            IN: Datatype object to query
         hoid_t *field_list;     IN: Array to store list of fields
  RETURNS
     SUCCEED/FAIL
@@ -722,7 +722,7 @@ done:
     datatype.  Atomic fields are returned in the list of OIDs, but have special
     OID values which cannot be further dereferenced.
 --------------------------------------------------------------------------*/
-herr_t H5Tget_fields(hatom_t tid, hatom_t *field_list)
+herr_t H5Tget_fields(hid_t tid, hid_t *field_list)
 {
     herr_t ret_value = FAIL;
 
@@ -753,13 +753,13 @@ done:
     Release access to an HDF5 datatype object.
  USAGE
     herr_t H5T_release(oid)
-        hatom_t oid;       IN: Object to release access to
+        hid_t oid;       IN: Object to release access to
  RETURNS
     SUCCEED/FAIL
  DESCRIPTION
         This function releases a datatype from active use by a user.
 --------------------------------------------------------------------------*/
-herr_t H5T_release(hatom_t oid)
+herr_t H5T_release(hid_t oid)
 {
     h5_datatype_t *dt;         /* new data-type object to create */
     herr_t        ret_value = SUCCEED;
diff --git a/src/H5Tprivate.h b/src/H5Tprivate.h
index 63d96c4..1578d47 100644
--- a/src/H5Tprivate.h
+++ b/src/H5Tprivate.h
@@ -32,7 +32,7 @@ typedef struct {
     uintn name_off;     /* Offset of name in global small-data heap */
     uintn struct_off;   /* Offset of field within structure */
     h5_atomic_type_t dt;  /* Datatype of the field */
-    hatom_t dim_id;     /* dimensionality ID of the field */
+    hid_t dim_id;     /* dimensionality ID of the field */
   } h5_field_info_t;
 
 /* Structure for storing information about a compound datatype */
@@ -51,9 +51,9 @@ typedef struct {
   } h5_datatype_t;
 
 /* Private functions */
-hatom_t H5T_create(hatom_t owner_id, hobjtype_t type, const char *name);
+hid_t H5T_create(hid_t owner_id, hobjtype_t type, const char *name);
 hbool_t H5T_is_atomic(h5_datatype_t *type);
 uintn H5T_size(h5_datatype_t *dt, hbool_t mem_flag);
-herr_t H5T_release(hatom_t oid);
+herr_t H5T_release(hid_t oid);
 
 #endif
diff --git a/src/H5Tpublic.h b/src/H5Tpublic.h
index 3404115..d74404b 100644
--- a/src/H5Tpublic.h
+++ b/src/H5Tpublic.h
@@ -55,7 +55,7 @@ WARNING!
 #endif /* WORDS_BIGENDIAN */
 
 typedef struct {
-    hatom_t base;           /* Basic datatype */
+    hid_t base;           /* Basic datatype */
     uint8 len;              /* Length of base-type, in bytes */
     uint8 arch;             /* Architecture of the base-type */
  } h5_atomic_type_t;
@@ -65,15 +65,15 @@ extern "C" {
 #endif
 
 /* Functions in H5T.c */
-uint32 H5Tget_num_fields(hatom_t tid);
-hbool_t H5Tis_field_atomic(hatom_t tid,uintn fidx);
-hbool_t H5Tis_atomic(hatom_t tid);
-herr_t H5Tset_type(hatom_t tid,hatom_t base,uint8 len,uint8 arch);
-herr_t H5Tget_type(hatom_t tid,hatom_t *base,uint8 *len,uint8 *arch);
-uintn H5Tsize(hatom_t tid, uint8 len, uint8 arch, hbool_t mem_flag);
-herr_t H5Tadd_field (hatom_t tid, const char *name, hatom_t base, uint8 len,
-		     uint8 arch, hatom_t space);
-herr_t H5Tget_fields(hatom_t tid, hatom_t *field_list);
+uint32 H5Tget_num_fields(hid_t tid);
+hbool_t H5Tis_field_atomic(hid_t tid,uintn fidx);
+hbool_t H5Tis_atomic(hid_t tid);
+herr_t H5Tset_type(hid_t tid,hid_t base,uint8 len,uint8 arch);
+herr_t H5Tget_type(hid_t tid,hid_t *base,uint8 *len,uint8 *arch);
+uintn H5Tsize(hid_t tid, uint8 len, uint8 arch, hbool_t mem_flag);
+herr_t H5Tadd_field (hid_t tid, const char *name, hid_t base, uint8 len,
+		     uint8 arch, hid_t space);
+herr_t H5Tget_fields(hid_t tid, hid_t *field_list);
 void H5T_term_interface (void);
 
 #ifdef __cplusplus
diff --git a/src/debug.c b/src/debug.c
index e6a0740..48e423c 100644
--- a/src/debug.c
+++ b/src/debug.c
@@ -45,7 +45,7 @@
 int
 main (int argc, char *argv[])
 {
-   hatom_t	fid;
+   hid_t	fid;
    hdf5_file_t	*f;
    haddr_t	addr = 0;
    uint8	sig[16];