[svn-r6395] Purpose:

    Code cleanup.

Description:
    Break up the ~9350 line H5T.c module into smaller pieces, which contain
    code for a particular feature or support for a datatype class.

    This should make the "main" H5T code (still in H5T.c) easier to support,
    as well as removing some of the "minor" routines from the user applications
    which don't use them (my rough estimates show about 4% reduction (~30K on
    a FreeBSD machine) in optimized, staticly-linked binaries for very simple
    programs)

Platforms tested:
    Tested h5committest {arabica (fortran), eirene (fortran, C++)
	modi4 (parallel, fortran)}

    FreeBSD 4.7 (sleipnir)

Misc. update:
    Update MANIFEST

1 files changed, 761 insertions, 0 deletions

diff --git a/src/H5Tnative.c b/src/H5Tnative.c
new file mode 100644
index 0000000..fab2014
--- /dev/null
+++ b/src/H5Tnative.c
@@ -0,0 +1,761 @@
+/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
+ * Copyright by the Board of Trustees of the University of Illinois.         *
+ * All rights reserved.                                                      *
+ *                                                                           *
+ * This file is part of HDF5.  The full HDF5 copyright notice, including     *
+ * terms governing use, modification, and redistribution, is contained in    *
+ * the files COPYING and Copyright.html.  COPYING can be found at the root   *
+ * of the source code distribution tree; Copyright.html can be found at the  *
+ * root level of an installed copy of the electronic HDF5 document set and   *
+ * is linked from the top-level documents page.  It can also be found at     *
+ * http://hdf.ncsa.uiuc.edu/HDF5/doc/Copyright.html.  If you do not have     *
+ * access to either file, you may request a copy from hdfhelp@ncsa.uiuc.edu. *
+ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
+
+/*
+ * Module Info: This module contains the functionality for querying
+ *      a "native" datatype for the H5T interface.
+ */
+
+#define H5T_PACKAGE		/*suppress error about including H5Tpkg	  */
+
+#include "H5private.h"		/*generic functions			  */
+#include "H5Eprivate.h"		/*error handling			  */
+#include "H5Iprivate.h"		/*ID functions		   		  */
+#include "H5MMprivate.h"	/*memory management			  */
+#include "H5Tpkg.h"		/*data-type functions			  */
+
+#define PABLO_MASK	H5Tnative_mask
+
+/* Interface initialization */
+static int interface_initialize_g = 0;
+#define INTERFACE_INIT H5T_init_native_interface
+static herr_t H5T_init_native_interface(void);
+
+/* Static local functions */
+static H5T_t *H5T_get_native_type(H5T_t *dt, H5T_direction_t direction, 
+                                  size_t *struct_align, size_t *offset, size_t *comp_size);
+static H5T_t *H5T_get_native_integer(size_t size, H5T_sign_t sign, H5T_direction_t direction, 
+                                     size_t *struct_align, size_t *offset, size_t *comp_size);
+static H5T_t *H5T_get_native_float(size_t size, H5T_direction_t direction, 
+                                   size_t *struct_align, size_t *offset, size_t *comp_size);
+static herr_t H5T_cmp_offset(size_t *comp_size, size_t *offset, size_t elem_size,
+                         size_t nelems, size_t align, size_t *struct_align);
+
+
+/*--------------------------------------------------------------------------
+NAME
+   H5T_init_native_interface -- Initialize interface-specific information
+USAGE
+    herr_t H5T_init_native_interface()
+   
+RETURNS
+    Non-negative on success/Negative on failure
+DESCRIPTION
+    Initializes any interface-specific data or routines.  (Just calls
+    H5T_init_iterface currently).
+
+--------------------------------------------------------------------------*/
+static herr_t
+H5T_init_native_interface(void)
+{
+    FUNC_ENTER_NOINIT(H5T_init_native_interface);
+
+    FUNC_LEAVE_NOAPI(H5T_init_interface());
+} /* H5T_init_native_interface() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5Tget_native_type
+ *
+ * Purpose:     High-level API to return the native type of a datatype. 
+ *              The native type is chosen by matching the size and class of 
+ *              querried datatype from the following native premitive 
+ *              datatypes:
+ *                      H5T_NATIVE_CHAR         H5T_NATIVE_UCHAR
+ *                      H5T_NATIVE_SHORT        H5T_NATIVE_USHORT
+ *                      H5T_NATIVE_INT          H5T_NATIVE_UINT
+ *                      H5T_NATIVE_LONG         H5T_NATIVE_ULONG
+ *                      H5T_NATIVE_LLONG        H5T_NATIVE_ULLONG
+ *
+ *                      H5T_NATIVE_FLOAT
+ *                      H5T_NATIVE_DOUBLE
+ *                      H5T_NATIVE_LDOUBLE
+ *
+ *              Compound, array, enum, and VL types all choose among these 
+ *              types for theire members.  Time, Bifield, Opaque, Reference
+ *              types are only copy out.
+ *      
+ * Return:      Success:        Returns the native data type if successful.
+ *
+ *              Failure:        negative
+ *
+ * Programmer:  Raymond Lu
+ *              Oct 3, 2002 
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+hid_t
+H5Tget_native_type(hid_t type_id, H5T_direction_t direction)
+{
+    H5T_t       *dt;                /* Datatype to create native datatype from */
+    H5T_t       *new_dt=NULL;       /* Datatype for native datatype created */
+    size_t      comp_size=0;        /* Compound datatype's size */
+    hid_t       ret_value;          /* Return value */
+
+    FUNC_ENTER_API(H5Tget_native_type, FAIL);
+    H5TRACE1("z","i",type_id);
+
+    /* check argument */
+    if(NULL==(dt=H5I_object_verify(type_id, H5I_DATATYPE)))
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+
+    if(direction!=H5T_DIR_DEFAULT && direction!=H5T_DIR_ASCEND 
+            && direction!=H5T_DIR_DESCEND)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not valid direction value");
+
+    if((new_dt = H5T_get_native_type(dt, direction, NULL, NULL, &comp_size))==NULL)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "cannot retrieve native type");
+
+    if((ret_value=H5I_register(H5I_DATATYPE, new_dt)) < 0)
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTREGISTER, FAIL, "unable to register data type");
+             
+done:
+    /* Error cleanup */
+    if(ret_value<0) {
+        if(new_dt)
+            H5T_close(new_dt);
+    } /* end if */
+    
+    FUNC_LEAVE_API(ret_value);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5T_get_native_type
+ * 
+ * Purpose:     Returns the native type of a datatype.
+ * 
+ * Return:      Success:        Returns the native data type if successful.
+ * 
+ *              Failure:        negative
+ *              
+ * Programmer:  Raymond Lu
+ *              Oct 3, 2002
+ *              
+ * Modifications:
+ * 
+ *-------------------------------------------------------------------------
+ */
+static H5T_t*
+H5T_get_native_type(H5T_t *dtype, H5T_direction_t direction, size_t *struct_align, size_t *offset, size_t *comp_size)
+{   
+    H5T_t       *dt;                /* Datatype to make native */
+    H5T_class_t h5_class;           /* Class of datatype to make native */
+    size_t      size;               /* Size of datatype to make native */
+    int         nmemb;              /* Number of members in compound & enum types */
+    H5T_t       *super_type;        /* Super type of VL, array and enum datatypes */
+    H5T_t       *nat_super_type;    /* Native form of VL, array & enum super datatype */
+    H5T_t       *new_type=NULL;     /* New native datatype */
+    int         i;                  /* Local index variable */
+    H5T_t       *ret_value;         /* Return value */
+
+    FUNC_ENTER_NOAPI(H5T_get_native_type, NULL);
+        
+    assert(dtype); 
+
+    if((h5_class = H5T_get_class(dtype))<0)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a valid class");
+        
+    if((size =  H5T_get_size(dtype))==0)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a valid size");
+        
+    switch(h5_class) {
+        case H5T_INTEGER:
+            {
+                H5T_sign_t  sign;       /* Signedness of integer type */
+
+                if((sign =  H5T_get_sign(dtype))==H5T_SGN_ERROR)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a valid signess");
+            
+                if((ret_value = H5T_get_native_integer(size, sign, direction, struct_align, offset, comp_size))==NULL)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot retrieve integer type");
+            }
+            break;
+            
+        case H5T_FLOAT:
+            if((ret_value = H5T_get_native_float(size, direction, struct_align, offset, comp_size))==NULL)
+                HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot retrieve float type");
+
+            break;
+
+        case H5T_STRING:
+            {
+                size_t align;
+                size_t pointer_size;
+
+                if(H5T_is_variable_str(dtype)) {
+                    if(NULL==(dt=H5I_object(H5T_C_S1)))
+                        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a data type");
+                    if((ret_value=H5T_copy(dt, H5T_COPY_TRANSIENT))==NULL)
+                        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot retrieve float type");
+                    if(H5T_set_size(ret_value, H5T_VARIABLE)<0)
+                        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot set size");
+
+                    /* Update size, offset and compound alignment for parent. */
+                    align = H5T_POINTER_COMP_ALIGN_g; 
+                    pointer_size = sizeof(char*);
+                    
+                    if(H5T_cmp_offset(comp_size, offset, pointer_size, 1, align, struct_align)<0)
+                        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot compute compound offset");
+
+                } else { 
+                    /*size_t          char_size;*/
+
+                    if(NULL==(dt=H5I_object(H5T_NATIVE_UCHAR)))
+                        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a data type");
+                    if((ret_value=H5T_copy(dt, H5T_COPY_TRANSIENT))==NULL)
+                        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot retrieve float type");
+                    if(H5T_set_size(ret_value, size)<0)
+                        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot set size");
+
+                    /* Update size, offset and compound alignment for parent. */
+                    align = H5T_NATIVE_SCHAR_COMP_ALIGN_g; 
+                    
+                    if(H5T_cmp_offset(comp_size, offset, sizeof(char), size, align, struct_align)<0)
+                        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot compute compound offset");
+
+                }
+            }
+            break;
+
+        /* These three types don't need to compute compound field information since they 
+         * can't be used as field. */
+        case H5T_TIME:
+        case H5T_BITFIELD:
+        case H5T_OPAQUE:
+            if((ret_value=H5T_copy(dtype, H5T_COPY_TRANSIENT))==NULL)
+                 HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot retrieve float type");
+
+            break;
+        case H5T_REFERENCE:
+            {
+                size_t align;
+                size_t ref_size;
+                int    not_equal;
+
+                if((ret_value=H5T_copy(dtype, H5T_COPY_TRANSIENT))==NULL)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot retrieve float type");
+               
+                /* Decide if the data type is object or dataset region reference. */
+                if(NULL==(dt=H5I_object(H5T_STD_REF_OBJ_g)))
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a data type");
+                not_equal = H5T_cmp(ret_value, dt);
+
+                /* Update size, offset and compound alignment for parent. */
+                if(!not_equal) {                    
+                    align = H5T_HOBJREF_COMP_ALIGN_g;
+                    ref_size = sizeof(hobj_ref_t);
+                } else {
+                    align = H5T_HDSETREGREF_COMP_ALIGN_g;
+                    ref_size = sizeof(hdset_reg_ref_t);
+                }
+                
+                if(H5T_cmp_offset(comp_size, offset, ref_size, 1, align, struct_align)<0)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot compute compound offset");
+            }
+            break;
+
+        case H5T_COMPOUND:
+            {
+                H5T_t       *memb_type;     /* Datatype of member */
+                H5T_t       **memb_list;    /* List of compound member IDs */
+                size_t      *memb_offset;   /* List of member offsets in compound type, including member size and alignment */
+                size_t      children_size=0;/* Total size of compound members */ 
+                size_t      children_st_align=0;    /* The max alignment among compound members.  This'll be the compound alignment */
+                char        **comp_mname;   /* List of member names in compound type */
+
+                if((nmemb = H5T_get_nmembers(dtype))<=0)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "compound data type doesn't have any member");
+                
+                if((memb_list   = (H5T_t**)H5MM_malloc(nmemb*sizeof(H5T_t*)))==NULL)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot allocate memory"); 
+                if((memb_offset = (size_t*)H5MM_calloc(nmemb*sizeof(size_t)))==NULL)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot allocate memory"); 
+                if((comp_mname = (char**)H5MM_malloc(nmemb*sizeof(char*)))==NULL)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot allocate memory"); 
+
+                /* Construct child compound type and retrieve a list of their IDs, offsets, total size, and alignment for compound type. */  
+                for(i=0; i<nmemb; i++) {
+                    if((memb_type = H5T_get_member_type(dtype, i))==NULL)
+                        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "member type retrieval failed");
+                        
+                    if((comp_mname[i] = H5T_get_member_name(dtype, i))==NULL)
+                        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "member type retrieval failed");
+                        
+                    if((memb_list[i] = H5T_get_native_type(memb_type, direction, &children_st_align, &(memb_offset[i]), &children_size))==NULL)
+                        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "member identifier retrieval failed");
+
+                    if(H5T_close(memb_type)<0)
+                        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot close datatype");
+                }
+               
+                /* The alignment for whole compound type */
+                if(children_st_align && children_size % children_st_align) {
+                    memb_offset[nmemb-1] += children_size % children_st_align;
+                    children_size += children_size % children_st_align;
+                }
+
+                /* Construct new compound type based on native type */   
+                if((new_type=H5T_create(H5T_COMPOUND, children_size))==NULL)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot create a compound type");
+
+                /* Insert members for the new compound type */       
+                for(i=0; i<nmemb; i++) {
+                    if(H5T_insert(new_type, comp_mname[i], memb_offset[i], memb_list[i])<0)
+                        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot insert member to compound datatype");
+                }
+                
+                /* Update size, offset and compound alignment for parent. */
+                if(offset)
+                    *offset = *comp_size;
+                if(struct_align && *struct_align < children_st_align)
+                    *struct_align = children_st_align;
+                *comp_size += children_size;
+                
+                /* Close member data type */ 
+                for(i=0; i<nmemb; i++) {
+                    if(H5T_close(memb_list[i])<0)
+                        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot close datatype");
+
+                    /* Free member names in list */
+                    H5MM_xfree(comp_mname[i]);
+                }
+               
+                /* Free lists for members */
+                H5MM_xfree(memb_list);
+                H5MM_xfree(memb_offset);
+                H5MM_xfree(comp_mname);
+                
+                ret_value = new_type;
+            }
+            break;
+
+        case H5T_ENUM:
+            {
+                char        *memb_name;         /* Enum's member name */
+                void        *memb_value;        /* Enum's member value */
+               
+                /* Don't need to do anything special for alignment, offset since the ENUM type usually is integer. */
+
+                /* Retrieve base type for enumarate type */
+                if((super_type=H5T_get_super(dtype))==NULL)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "unable to get base type for enumarate type");
+                if((nat_super_type = H5T_get_native_type(super_type, direction, struct_align, offset, comp_size))==NULL)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "base native type retrieval failed");
+
+                /* Allocate room for the enum values */
+                if((memb_value = H5MM_malloc(H5T_get_size(super_type)))==NULL)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot allocate memory"); 
+
+                /* Close super type */
+                if(H5T_close(super_type)<0)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot close datatype");
+                 
+                /* Construct new enum type based on native type */   
+                if((new_type=H5T_enum_create(nat_super_type))==NULL)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "unable to create enum type");
+                    
+                /* Retrieve member info and insert members into new enum type */
+                if((nmemb = H5T_get_nmembers(dtype))<=0)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "enumarate data type doesn't have any member");
+                for(i=0; i<nmemb; i++) {
+                    if((memb_name=H5T_get_member_name(dtype, i))==NULL)
+                        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot get member name");
+                    if(H5T_get_member_value(dtype, i, memb_value)<0)
+                        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot get member value");
+                    if(H5T_enum_insert(new_type, memb_name, memb_value)<0)
+                        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot insert member");
+                    H5MM_xfree(memb_name);
+                }
+                H5MM_xfree(memb_value);
+
+                /* Close base type */
+                if(H5T_close(nat_super_type)<0)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot close datatype");
+               
+                ret_value = new_type;
+            }
+            break;
+
+        case H5T_ARRAY:
+            {
+                int         array_rank;         /* Array's rank */
+                hsize_t     *dims = NULL;       /* Dimension sizes for array */
+                hsize_t     nelems = 1;
+                size_t      super_offset=0;       
+                size_t      super_size=0;       
+                size_t      super_align=0;   
+
+                /* Retrieve dimension information for array data type */
+                if((array_rank=H5T_get_array_ndims(dtype))<=0)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot get dimension rank");
+                if((dims = (hsize_t*)H5MM_malloc(array_rank*sizeof(hsize_t)))==NULL)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot allocate memory"); 
+                if(H5T_get_array_dims(dtype, dims, NULL)<0)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot get dimension size");
+
+                /* Retrieve base type for array type */
+                if((super_type=H5T_get_super(dtype))==NULL)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "unable to get parent type for enumarate type");
+                if((nat_super_type = H5T_get_native_type(super_type, direction, &super_align, 
+                                                         &super_offset, &super_size))==NULL)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "parent native type retrieval failed");
+
+                /* Close super type */
+                if(H5T_close(super_type)<0)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot close datatype");
+
+                /* Create a new array type based on native type */
+                if((new_type=H5T_array_create(nat_super_type, array_rank, dims, NULL))==NULL) 
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "unable to create array type");
+
+                /* Close base type */
+                if(H5T_close(nat_super_type)<0)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot close datatype");
+                    
+                for(i=0; i<array_rank; i++)
+                    nelems *= dims[i];                   
+                H5_CHECK_OVERFLOW(nelems,hsize_t,size_t);
+                if(H5T_cmp_offset(comp_size, offset, super_size, (size_t)nelems, super_align, struct_align)<0)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot compute compound offset");
+                        
+                H5MM_xfree(dims);
+                ret_value = new_type;
+            }
+            break;
+
+        case H5T_VLEN:
+            {
+                size_t      vl_align = 0;
+                size_t      vl_size  = 0;
+                size_t      super_size=0;       
+
+                /* Retrieve base type for array type */
+                if((super_type=H5T_get_super(dtype))==NULL)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "unable to get parent type for enumarate type");
+                /* Don't need alignment, offset information if this VL isn't a field of compound type.  If it
+                 * is, go to a few steps below to compute the information directly. */
+                if((nat_super_type = H5T_get_native_type(super_type, direction, NULL, NULL, &super_size))==NULL)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "parent native type retrieval failed");
+
+                /* Close super type */
+                if(H5T_close(super_type)<0)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot close datatype");
+
+                /* Create a new array type based on native type */
+                if((new_type=H5T_vlen_create(nat_super_type))==NULL) 
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "unable to create VL type");
+           
+                /* Close base type */
+                if(H5T_close(nat_super_type)<0)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot close datatype");
+            
+                /* Update size, offset and compound alignment for parent compound type directly. */
+                vl_align = H5T_HVL_COMP_ALIGN_g;
+                vl_size  = sizeof(hvl_t);
+                
+                if(H5T_cmp_offset(comp_size, offset, vl_size, 1, vl_align, struct_align)<0)
+                    HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot compute compound offset");
+                        
+                ret_value = new_type;
+            }
+            break;   
+
+        default:
+            HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "data type doesn't match any native type");
+    }   
+
+done:
+    /* Error cleanup */
+    if(ret_value==NULL) {
+        if(new_type)
+            H5T_close(new_type);
+    } /* end if */
+
+    FUNC_LEAVE_NOAPI(ret_value);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5T_get_native_integer
+ * 
+ * Purpose:     Returns the native integer type of a datatype.
+ * 
+ * Return:      Success:        Returns the native data type if successful.
+ * 
+ *              Failure:        negative
+ *              
+ * Programmer:  Raymond Lu
+ *              Oct 3, 2002
+ *              
+ * Modifications:
+ * 
+ *-------------------------------------------------------------------------
+ */
+static H5T_t*
+H5T_get_native_integer(size_t size, H5T_sign_t sign, H5T_direction_t direction, 
+                              size_t *struct_align, size_t *offset, size_t *comp_size)
+{  
+    H5T_t       *dt;            /* Appropriate native datatype to copy */
+    hid_t       tid=(-1);       /* Datatype ID of appropriate native datatype */
+    size_t      align=0;        /* Alignment necessary for native datatype */
+    enum match_type {           /* The different kinds of integers we can match */
+        H5T_NATIVE_INT_MATCH_CHAR,
+        H5T_NATIVE_INT_MATCH_SHORT,
+        H5T_NATIVE_INT_MATCH_INT,
+        H5T_NATIVE_INT_MATCH_LONG,
+        H5T_NATIVE_INT_MATCH_LLONG,
+        H5T_NATIVE_INT_MATCH_UNKNOWN
+    } match=H5T_NATIVE_INT_MATCH_UNKNOWN;
+    H5T_t       *ret_value;     /* Return value */
+
+    FUNC_ENTER_NOAPI(H5T_get_native_integer, NULL);
+
+    assert(size>0);
+    
+    if(direction == H5T_DIR_DEFAULT || direction == H5T_DIR_ASCEND) {         
+        if(size==sizeof(char))
+            match=H5T_NATIVE_INT_MATCH_CHAR;
+        else if(size==sizeof(short))
+            match=H5T_NATIVE_INT_MATCH_SHORT;
+        else if(size==sizeof(int))
+            match=H5T_NATIVE_INT_MATCH_INT;
+        else if(size==sizeof(long))
+            match=H5T_NATIVE_INT_MATCH_LONG;
+        else if(size==sizeof(long_long))
+            match=H5T_NATIVE_INT_MATCH_LLONG;
+        else   /* If no native type matches the querried datatype, simply choose the type of biggest size. */
+            match=H5T_NATIVE_INT_MATCH_LLONG;
+    } else if(direction == H5T_DIR_DESCEND) {         
+        if(size==sizeof(long_long))
+            match=H5T_NATIVE_INT_MATCH_LLONG;
+        else if(size==sizeof(long))
+            match=H5T_NATIVE_INT_MATCH_LONG;
+        else if(size==sizeof(int))
+            match=H5T_NATIVE_INT_MATCH_INT;
+        else if(size==sizeof(short))
+            match=H5T_NATIVE_INT_MATCH_SHORT;
+        else if(size==sizeof(char))
+            match=H5T_NATIVE_INT_MATCH_CHAR;
+        else   /* If no native type matches the querried datatype, simple choose the type of smallest size. */
+            match=H5T_NATIVE_INT_MATCH_CHAR;
+    }
+
+    /* Set the appropriate native datatype information */
+    switch(match) {
+        case H5T_NATIVE_INT_MATCH_CHAR:
+            if(sign==H5T_SGN_2)
+                tid = H5T_NATIVE_SCHAR;
+            else
+                tid = H5T_NATIVE_UCHAR;
+            
+            align = H5T_NATIVE_SCHAR_COMP_ALIGN_g; 
+            break;
+            
+        case H5T_NATIVE_INT_MATCH_SHORT:
+            if(sign==H5T_SGN_2)
+                tid = H5T_NATIVE_SHORT;
+            else
+                tid = H5T_NATIVE_USHORT;
+
+            align = H5T_NATIVE_SHORT_COMP_ALIGN_g; 
+            break;
+            
+        case H5T_NATIVE_INT_MATCH_INT:
+            if(sign==H5T_SGN_2)
+                tid = H5T_NATIVE_INT;
+            else  
+                tid = H5T_NATIVE_UINT;
+
+            align = H5T_NATIVE_INT_COMP_ALIGN_g; 
+            break;
+            
+        case H5T_NATIVE_INT_MATCH_LONG:
+            if(sign==H5T_SGN_2)
+                tid = H5T_NATIVE_LONG;
+            else  
+                tid = H5T_NATIVE_ULONG;
+
+            align = H5T_NATIVE_LONG_COMP_ALIGN_g;            
+            break;
+            
+        case H5T_NATIVE_INT_MATCH_LLONG:
+            if(sign==H5T_SGN_2)
+                tid = H5T_NATIVE_LLONG;
+            else  
+                tid = H5T_NATIVE_ULLONG;
+
+            align = H5T_NATIVE_LLONG_COMP_ALIGN_g;            
+            break;
+            
+        default:
+            assert(0 && "Unknown native integer match!");
+            break;
+    } /* end switch */
+        
+    /* Create new native type */
+    assert(tid>=0);
+    if(NULL==(dt=H5I_object(tid)))
+         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a data type");
+    if((ret_value=H5T_copy(dt, H5T_COPY_TRANSIENT))==NULL)
+         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot retrieve float type");
+            
+    /* compute size and offset of compound type member. */
+    if(H5T_cmp_offset(comp_size, offset, size, 1, align, struct_align)<0)
+         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot compute compound offset");
+                        
+done:
+    FUNC_LEAVE_NOAPI(ret_value);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5T_get_native_float
+ * 
+ * Purpose:     Returns the native floatt type of a datatype.
+ * 
+ * Return:      Success:        Returns the native data type if successful.
+ * 
+ *              Failure:        negative
+ *              
+ * Programmer:  Raymond Lu
+ *              Oct 3, 2002
+ *              
+ * Modifications:
+ * 
+ *-------------------------------------------------------------------------
+ */
+static H5T_t*
+H5T_get_native_float(size_t size, H5T_direction_t direction, size_t *struct_align, size_t *offset, size_t *comp_size)
+{  
+    H5T_t       *dt=NULL;       /* Appropriate native datatype to copy */
+    hid_t       tid=(-1);       /* Datatype ID of appropriate native datatype */
+    size_t      align=0;        /* Alignment necessary for native datatype */
+    enum match_type {           /* The different kinds of floating point types we can match */
+        H5T_NATIVE_FLOAT_MATCH_FLOAT,
+        H5T_NATIVE_FLOAT_MATCH_DOUBLE,
+        H5T_NATIVE_FLOAT_MATCH_LDOUBLE,
+        H5T_NATIVE_FLOAT_MATCH_UNKNOWN
+    } match=H5T_NATIVE_FLOAT_MATCH_UNKNOWN;
+    H5T_t       *ret_value;     /* Return value */
+
+    FUNC_ENTER_NOAPI(H5T_get_native_integer, NULL);
+
+    assert(size>0);
+    
+    if(direction == H5T_DIR_DEFAULT || direction == H5T_DIR_ASCEND) {        
+        if(size==sizeof(float))
+            match=H5T_NATIVE_FLOAT_MATCH_FLOAT;
+        else if(size==sizeof(double))
+            match=H5T_NATIVE_FLOAT_MATCH_DOUBLE;
+        else if(size==sizeof(long double))
+            match=H5T_NATIVE_FLOAT_MATCH_LDOUBLE;
+        else   /* If not match, return the biggest datatype */
+            match=H5T_NATIVE_FLOAT_MATCH_LDOUBLE;
+    } else {
+        if(size==sizeof(long double))
+            match=H5T_NATIVE_FLOAT_MATCH_LDOUBLE;
+        else if(size==sizeof(double))
+            match=H5T_NATIVE_FLOAT_MATCH_DOUBLE;
+        else if(size==sizeof(float))
+            match=H5T_NATIVE_FLOAT_MATCH_FLOAT;
+        else
+            match=H5T_NATIVE_FLOAT_MATCH_FLOAT;
+    }
+
+    /* Set the appropriate native floating point information */
+    switch(match) {
+        case H5T_NATIVE_FLOAT_MATCH_FLOAT:
+            tid = H5T_NATIVE_FLOAT;
+            align = H5T_NATIVE_FLOAT_COMP_ALIGN_g;
+            break;
+
+        case H5T_NATIVE_FLOAT_MATCH_DOUBLE:
+            tid = H5T_NATIVE_DOUBLE;
+            align = H5T_NATIVE_DOUBLE_COMP_ALIGN_g;
+            break;
+
+        case H5T_NATIVE_FLOAT_MATCH_LDOUBLE:
+            tid = H5T_NATIVE_LDOUBLE;
+            align = H5T_NATIVE_LDOUBLE_COMP_ALIGN_g;
+            break;
+
+        default:
+            assert(0 && "Unknown native floating-point match!");
+            break;
+    } /* end switch */
+   
+    /* Create new native type */
+    assert(tid>=0);
+    if(NULL==(dt=H5I_object(tid)))
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a data type");
+    if((ret_value=H5T_copy(dt, H5T_COPY_TRANSIENT))==NULL)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot retrieve float type");
+      
+    /* compute offset of compound type member. */
+    if(H5T_cmp_offset(comp_size, offset, size, 1, align, struct_align)<0)
+         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "cannot compute compound offset");
+                        
+done:
+    FUNC_LEAVE_NOAPI(ret_value);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5T_cmp_offset
+ *
+ * Purpose:	This function is only for convenience.  It computes the 
+ *              compound type size, offset of the member being considered
+ *              and the alignment for the whole compound type.
+ *
+ * Return:	Success:        Non-negative value.	
+ *
+ *		Failure:        Negative value.	
+ *
+ * Programmer:	Raymond Lu
+ *		December  10, 2002 
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5T_cmp_offset(size_t *comp_size, size_t *offset, size_t elem_size, 
+                      size_t nelems, size_t align, size_t *struct_align)
+{
+    herr_t ret_value = SUCCEED;
+
+    FUNC_ENTER_NOAPI(H5T_cmp_offset, FAIL);
+
+    if(offset && comp_size) {
+        if(align>1 && *comp_size%align) {
+            /* Add alignment value */
+            *offset = *comp_size +  (align - *comp_size%align);
+            *comp_size += (align - *comp_size%align);
+        } else
+            *offset = *comp_size;
+
+        /* compute size of compound type member. */ 
+        *comp_size += nelems*elem_size;
+    }
+
+    if(struct_align && *struct_align < align)
+        *struct_align = align;
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value);
+}
+