[svn-r22748] Description:

    H5FD_FLMAP_SINGLE changed to H5FD_FLMAP_DICHOTOMY in the MPI-POSIX VFD.

Tested on:
    jam w/ parallel and fortran enabled (minor change)

11 files changed, 761 insertions, 890 deletions

diff --git a/src/H5FDmpiposix.c b/src/H5FDmpiposix.c
index 261f427..0d0b839 100644
--- a/src/H5FDmpiposix.c
+++ b/src/H5FDmpiposix.c
@@ -14,10 +14,10 @@
  * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
 /*
- * Programmer:  Quincey Koziol <koziol@ncsa.uiuc.ed>
+ * Programmer:  Quincey Koziol <koziol@hdfgroup.org>
  *              Thursday, July 11, 2002
  *
- * Purpose:  This is a "combination" MPI-2 and posix I/O driver.
+ * Purpose:     This is a "combination" MPI-2 and posix I/O driver.
  *              It uses MPI for coordinating the actions of several processes
  *              and posix I/O calls to do the actual I/O to the disk.
  *
@@ -230,7 +230,7 @@ static const H5FD_class_mpi_t H5FD_mpiposix_g = {
     H5FD_mpiposix_truncate,         /* truncate         */
     NULL,                           /* lock             */
     NULL,                           /* unlock           */
-    H5FD_FLMAP_SINGLE               /* fl_map           */
+    H5FD_FLMAP_DICHOTOMY            /* fl_map           */
     },  /* End of superclass information */
     H5FD_mpiposix_mpi_rank,         /* get_rank         */
     H5FD_mpiposix_mpi_size,         /* get_size         */
diff --git a/src/H5T.c b/src/H5T.c
index 5a3c17b..f0baa54 100644
--- a/src/H5T.c
+++ b/src/H5T.c
@@ -1040,13 +1040,13 @@ H5T_init_interface(void)
     fixedpt = native_int;
     floatpt = native_float;
     if (NULL == (compound = H5T__create(H5T_COMPOUND, (size_t)1)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype")
     if (NULL == (enum_type = H5T__create(H5T_ENUM, (size_t)1)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype")
     if (NULL == (vlen = H5T__vlen_create(native_int)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype")
     if (NULL == (array = H5T__array_create(native_int, 1, dim)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype")
     status = 0;
 
     status |= H5T_register(H5T_PERS_SOFT, "i_i", fixedpt, fixedpt, H5T__conv_i_i, H5AC_dxpl_id, FALSE);
@@ -1971,31 +1971,22 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5T_detect_class
+ * Function:    H5T_detect_class
  *
- * Purpose:	Check whether a datatype contains (or is) a certain type of
- *		datatype.
+ * Purpose:     Check whether a datatype contains (or is) a certain type of
+ *              datatype.
  *
- * Return:	TRUE (1) or FALSE (0) on success/Negative on failure
+ * Return:      TRUE (1) or FALSE (0) on success/Negative on failure
  *
- * Programmer:	Quincey Koziol
- *		Wednesday, November 29, 2000
+ * Programmer:  Quincey Koziol
+ *              Wednesday, November 29, 2000
  *
- * Modifications:
- *              Raymond Lu
- *              4 December 2009
- *              Added a flag as a parameter to indicate whether the caller is
- *              H5Tdetect_class.  I also added the check for VL string type
- *              just like the public function.  Because we want to tell users
- *              VL string is a string type but we treat it as a VL type
- *              internally, H5T_detect_class needs to know where the caller
- *              is from.
  *-------------------------------------------------------------------------
  */
 htri_t
 H5T_detect_class(const H5T_t *dt, H5T_class_t cls, hbool_t from_api)
 {
-    unsigned	i;
+    unsigned    i;
     htri_t      ret_value = FALSE;        /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
@@ -2148,33 +2139,33 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tset_size
+ * Function:    H5Tset_size
  *
- * Purpose:	Sets the total size in bytes for a datatype (this operation
- *		is not permitted on reference datatypes).  If the size is
- *		decreased so that the significant bits of the datatype
- *		extend beyond the edge of the new size, then the `offset'
- *		property is decreased toward zero.  If the `offset' becomes
- *		zero and the significant bits of the datatype still hang
- *		over the edge of the new size, then the number of significant
- *		bits is decreased.
+ * Purpose:     Sets the total size in bytes for a datatype (this operation
+ *              is not permitted on reference datatypes).  If the size is
+ *              decreased so that the significant bits of the datatype
+ *              extend beyond the edge of the new size, then the `offset'
+ *              property is decreased toward zero.  If the `offset' becomes
+ *              zero and the significant bits of the datatype still hang
+ *              over the edge of the new size, then the number of significant
+ *              bits is decreased.
  *
- *		Adjusting the size of an H5T_STRING automatically sets the
- *		precision to 8*size.
+ *              Adjusting the size of an H5T_STRING automatically sets the
+ *              precision to 8*size.
  *
- *		All datatypes have a positive size.
+ *              All datatypes have a positive size.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
- * Programmer:	Robb Matzke
- *		Wednesday, January  7, 1998
+ * Programmer:  Robb Matzke
+ *              Wednesday, January  7, 1998
  *
  *-------------------------------------------------------------------------
  */
 herr_t
 H5Tset_size(hid_t type_id, size_t size)
 {
-    H5T_t	*dt;                    /* Datatype to modify */
+    H5T_t       *dt;                    /* Datatype to modify */
     herr_t      ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_API(FAIL)
@@ -2182,21 +2173,21 @@ H5Tset_size(hid_t type_id, size_t size)
 
     /* Check args */
     if(NULL == (dt = (H5T_t *)H5I_object_verify(type_id, H5I_DATATYPE)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype")
     if(H5T_STATE_TRANSIENT!=dt->shared->state)
-	HGOTO_ERROR(H5E_ARGS, H5E_CANTINIT, FAIL, "datatype is read-only")
+        HGOTO_ERROR(H5E_ARGS, H5E_CANTINIT, FAIL, "datatype is read-only")
     if(size <= 0 && size != H5T_VARIABLE)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "size must be positive")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "size must be positive")
     if(size == H5T_VARIABLE && !H5T_IS_STRING(dt->shared))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "only strings may be variable length")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "only strings may be variable length")
     if(H5T_ENUM == dt->shared->type && dt->shared->u.enumer.nmembs > 0)
-	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "operation not allowed after members are defined")
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "operation not allowed after members are defined")
     if(H5T_REFERENCE == dt->shared->type)
-	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "operation not defined for this datatype")
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "operation not defined for this datatype")
 
     /* Modify the datatype */
     if(H5T_set_size(dt, size) < 0)
-	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to set size for datatype")
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to set size for datatype")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -3131,27 +3122,6 @@ done:
  * Programmer:	Robb Matzke
  *		Thursday, December  4, 1997
  *
- * Modifications:
- *
- * 	Robb Matzke, 4 Jun 1998
- *	Added the METHOD argument.  If it's H5T_COPY_TRANSIENT then the
- *	result will be an unlocked transient type.  Otherwise if it's
- *	H5T_COPY_ALL then the result is a named type if the original is a
- *	named type, but the result is not opened.  Finally, if it's
- *	H5T_COPY_REOPEN and the original type is a named type then the result
- *	is a named type and the type object header is opened again.  The
- *	H5T_COPY_REOPEN method is used when returning a named type to the
- *	application.
- *
- * 	Robb Matzke, 22 Dec 1998
- *	Now able to copy enumeration data types.
- *
- *      Robb Matzke, 20 May 1999
- *	Now able to copy opaque types.
- *
- *      Pedro Vicente, <pvn@ncsa.uiuc.edu> 21 Sep 2002
- *      Added a deep copy of the symbol table entry
- *
  *-------------------------------------------------------------------------
  */
 H5T_t *
@@ -3504,23 +3474,23 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5T__free
+ * Function:    H5T__free
  *
- * Purpose:	Frees all memory associated with a datatype, but does not
+ * Purpose:     Frees all memory associated with a datatype, but does not
  *              free the H5T_t or H5T_shared_t structures (which should
  *              be done in H5T_close).
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
- * Programmer:	Quincey Koziol
- *		Monday, January  6, 2003
+ * Programmer:  Quincey Koziol
+ *              Monday, January  6, 2003
  *
  *-------------------------------------------------------------------------
  */
 herr_t
 H5T__free(H5T_t *dt)
 {
-    unsigned	i;
+    unsigned    i;
     herr_t      ret_value = SUCCEED;       /* Return value */
 
     FUNC_ENTER_PACKAGE
@@ -3552,8 +3522,8 @@ H5T__free(H5T_t *dt)
     /*
      * Don't free locked datatypes.
      */
-    if(H5T_STATE_IMMUTABLE==dt->shared->state)
-	HGOTO_ERROR(H5E_DATATYPE, H5E_CLOSEERROR, FAIL, "unable to close immutable datatype")
+    if(H5T_STATE_IMMUTABLE == dt->shared->state)
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CLOSEERROR, FAIL, "unable to close immutable datatype")
 
     /* Close the datatype */
     switch(dt->shared->type) {
@@ -3583,7 +3553,7 @@ H5T__free(H5T_t *dt)
     /* Close the parent */
     HDassert(dt->shared->parent != dt);
     if(dt->shared->parent && H5T_close(dt->shared->parent) < 0)
-	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTCLOSEOBJ, FAIL, "unable to close parent data type")
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTCLOSEOBJ, FAIL, "unable to close parent data type")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -3591,28 +3561,15 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5T_close
+ * Function:    H5T_close
  *
- * Purpose:	Frees a data type and all associated memory.  If the data
- *		type is locked then nothing happens.
+ * Purpose:     Frees a data type and all associated memory.  If the data
+ *              type is locked then nothing happens.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
- * Programmer:	Robb Matzke
- *		Monday, December  8, 1997
- *
- * Modifications:
- *      Robb Matzke, 1999-04-27
- *      This function fails if the datatype state is IMMUTABLE.
- *
- *      Robb Matzke, 1999-05-20
- *      Closes opaque types also.
- *
- *      Pedro Vicente, <pvn@ncsa.uiuc.edu> 22 Aug 2002
- *      Added "ID to name" support
- *
- *      Quincey Koziol, 2003-01-06
- *      Moved "guts" of function to H5T__free()
+ * Programmer:  Robb Matzke
+ *              Monday, December  8, 1997
  *
  *-------------------------------------------------------------------------
  */
@@ -3671,76 +3628,70 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5T_set_size
+ * Function:    H5T_set_size
  *
- * Purpose:	Sets the total size in bytes for a data type (this operation
- *		is not permitted on reference data types).  If the size is
- *		decreased so that the significant bits of the data type
- *		extend beyond the edge of the new size, then the `offset'
- *		property is decreased toward zero.  If the `offset' becomes
- *		zero and the significant bits of the data type still hang
- *		over the edge of the new size, then the number of significant
- *		bits is decreased.
+ * Purpose:     Sets the total size in bytes for a data type (this operation
+ *              is not permitted on reference data types).  If the size is
+ *              decreased so that the significant bits of the data type
+ *              extend beyond the edge of the new size, then the 'offset'
+ *              property is decreased toward zero.  If the 'offset' becomes
+ *              zero and the significant bits of the data type still hang
+ *              over the edge of the new size, then the number of significant
+ *              bits is decreased.
  *
- *		Adjusting the size of an H5T_STRING automatically sets the
- *		precision to 8*size.
+ *              Adjusting the size of an H5T_STRING automatically sets the
+ *              precision to 8 * size.
  *
- *		All data types have a positive size.
- *
- * Return:	Success:	non-negative
+ *              All data types have a positive size.
  *
- *		Failure:	nagative
+ * Return:      SUCCEED/FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Tuesday, December 22, 1998
  *
- * Modifications:
- * 	Robb Matzke, 22 Dec 1998
- *	Also works with derived data types.
- *
  *-------------------------------------------------------------------------
  */
 static herr_t
 H5T_set_size(H5T_t *dt, size_t size)
 {
-    size_t	prec, offset;
-    herr_t      ret_value=SUCCEED;       /* Return value */
+    size_t      prec, offset;
+    herr_t      ret_value = SUCCEED;        /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
     /* Check args */
-    assert(dt);
-    assert(size!=0);
-    assert(H5T_REFERENCE!=dt->shared->type);
-    assert(!(H5T_ENUM==dt->shared->type && 0==dt->shared->u.enumer.nmembs));
+    HDassert(dt);
+    HDassert(size != 0);
+    HDassert(H5T_REFERENCE != dt->shared->type);
+    HDassert(!(H5T_ENUM == dt->shared->type && 0 == dt->shared->u.enumer.nmembs));
 
-    if (dt->shared->parent) {
-        if (H5T_set_size(dt->shared->parent, size)<0)
+    if(dt->shared->parent) {
+        if(H5T_set_size(dt->shared->parent, size) < 0)
             HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to set size for parent data type");
 
         /* Adjust size of datatype appropriately */
-        if(dt->shared->type==H5T_ARRAY)
+        if(dt->shared->type == H5T_ARRAY)
             dt->shared->size = dt->shared->parent->shared->size * dt->shared->u.array.nelem;
-        else if(dt->shared->type!=H5T_VLEN)
+        else if(dt->shared->type != H5T_VLEN)
             dt->shared->size = dt->shared->parent->shared->size;
     } else {
-        if (H5T_IS_ATOMIC(dt->shared)) {
+        if(H5T_IS_ATOMIC(dt->shared)) {
             offset = dt->shared->u.atomic.offset;
             prec = dt->shared->u.atomic.prec;
 
             /* Decrement the offset and precision if necessary */
-            if (prec > 8*size)
+            if (prec > 8 * size)
                 offset = 0;
             else
-                if (offset+prec > 8*size)
+                if (offset+prec > 8 * size)
                     offset = 8 * size - prec;
-            if (prec > 8*size)
+            if (prec > 8 * size)
                 prec = 8 * size;
         } else {
             prec = offset = 0;
-        }
+        } /* end else */
 
-        switch (dt->shared->type) {
+        switch(dt->shared->type) {
             case H5T_INTEGER:
             case H5T_TIME:
             case H5T_BITFIELD:
@@ -3750,33 +3701,34 @@ H5T_set_size(H5T_t *dt, size_t size)
 
             case H5T_COMPOUND:
                 /* If decreasing size, check the last member isn't being cut. */
-                if(size<dt->shared->size) {
+                if(size < dt->shared->size) {
                     int         num_membs = 0;
-                    unsigned    i, max_index=0;
-                    size_t      memb_offset, max_offset=0;
+                    unsigned    i, max_index = 0;
+                    size_t      memb_offset, max_offset = 0;
                     size_t      max_size;
 
-                    if((num_membs = H5T_get_nmembers(dt))<0)
+                    if((num_membs = H5T_get_nmembers(dt)) < 0)
                         HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to get number of members");
 
                     if(num_membs) {
-			for(i=0; i<(unsigned)num_membs; i++) {
-			    memb_offset = H5T_get_member_offset(dt, i);
-			    if(memb_offset > max_offset) {
-			        max_offset = memb_offset;
-				max_index = i;
-			    }
-			}
-
-			max_size = H5T__get_member_size(dt, max_index);
-
-			if(size<(max_offset+max_size))
-			    HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "size shrinking will cut off last member ");
-                    }
+                        for(i = 0; i < (unsigned)num_membs; i++) {
+                            memb_offset = H5T_get_member_offset(dt, i);
+                            if(memb_offset > max_offset) {
+                                max_offset = memb_offset;
+                                max_index = i;
+                            } /* end if */
+                        } /* end for */
+
+                        max_size = H5T__get_member_size(dt, max_index);
+
+                        if(size < (max_offset+max_size))
+                            HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "size shrinking will cut off last member ");
+                    } /* end if */
 
-                    /* Compound must not have been packed previously */
-                    /* We will check if resizing changed the packed state of
-                     * this type at the end of this function */
+                    /* Compound must not have been packed previously.
+                     * We will check if resizing changed the packed state of
+                     * this type at the end of this function.
+                     */
                     HDassert(!dt->shared->u.compnd.packed);
                 }
 
@@ -3784,29 +3736,30 @@ H5T_set_size(H5T_t *dt, size_t size)
 
             case H5T_STRING:
                 /* Convert string to variable-length datatype */
-                if(size==H5T_VARIABLE) {
-                    H5T_t	*base = NULL;		/* base data type */
+                if(size == H5T_VARIABLE) {
+                    H5T_t       *base = NULL;           /* base data type */
                     H5T_cset_t  tmp_cset;               /* Temp. cset info */
                     H5T_str_t   tmp_strpad;             /* Temp. strpad info */
 
                     /* Get a copy of unsigned char type as the base/parent type */
                     if(NULL == (base = (H5T_t *)H5I_object(H5T_NATIVE_UCHAR)))
                         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "invalid base datatype");
-                    dt->shared->parent=H5T_copy(base,H5T_COPY_ALL);
+                    dt->shared->parent = H5T_copy(base,H5T_COPY_ALL);
 
                     /* change this datatype into a VL string */
                     dt->shared->type = H5T_VLEN;
 
                     /*
                      * Force conversions (i.e. memory to memory conversions
-		     * should duplicate data, not point to the same VL strings)
+                     * should duplicate data, not point to the same VL strings)
                      */
                     dt->shared->force_conv = TRUE;
 
-		    /* Before we mess with the info in the union, extract the
-		     * values we need */
-                    tmp_cset=dt->shared->u.atomic.u.s.cset;
-                    tmp_strpad=dt->shared->u.atomic.u.s.pad;
+                    /* Before we mess with the info in the union, extract the
+                     * values we need
+                     */
+                    tmp_cset = dt->shared->u.atomic.u.s.cset;
+                    tmp_strpad = dt->shared->u.atomic.u.s.pad;
 
                     /* This is a string, not a sequence */
                     dt->shared->u.vlen.type = H5T_VLEN_STRING;
@@ -3816,7 +3769,7 @@ H5T_set_size(H5T_t *dt, size_t size)
                     dt->shared->u.vlen.pad  = tmp_strpad;
 
                     /* Set up VL information */
-                    if (H5T_set_loc(dt, NULL, H5T_LOC_MEMORY)<0)
+                    if(H5T_set_loc(dt, NULL, H5T_LOC_MEMORY) < 0)
                         HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "invalid datatype location");
 
                 } else {
@@ -3834,28 +3787,28 @@ H5T_set_size(H5T_t *dt, size_t size)
                         dt->shared->u.atomic.u.f.epos + dt->shared->u.atomic.u.f.esize > prec+offset ||
                         dt->shared->u.atomic.u.f.mpos + dt->shared->u.atomic.u.f.msize > prec+offset) {
                     HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "adjust sign, mantissa, and exponent fields first");
-                }
+                } /* end if */
                 break;
 
             case H5T_ENUM:
             case H5T_VLEN:
             case H5T_ARRAY:
             case H5T_REFERENCE:
-                assert("can't happen" && 0);
+                HDassert("can't happen" && 0);
             case H5T_NO_CLASS:
             case H5T_NCLASSES:
-                assert("invalid type" && 0);
+                HDassert("invalid type" && 0);
             default:
-                assert("not implemented yet" && 0);
+                HDassert("not implemented yet" && 0);
         }
 
         /* Commit (if we didn't convert this type to a VL string) */
-        if(dt->shared->type!=H5T_VLEN) {
+        if(dt->shared->type != H5T_VLEN) {
             dt->shared->size = size;
             if (H5T_IS_ATOMIC(dt->shared)) {
                 dt->shared->u.atomic.offset = offset;
                 dt->shared->u.atomic.prec = prec;
-            }
+            } /* end if */
         } /* end if */
 
         /* Check if the new compound type is packed */
@@ -3869,20 +3822,18 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5T_get_size
+ * Function:    H5T_get_size
  *
- * Purpose:	Determines the total size of a data type in bytes.
+ * Purpose:     Determines the total size of a data type in bytes.
  *
- * Return:	Success:	Size of the data type in bytes.	 The size of
- *				the data type is the size of an instance of
- *				that data type.
+ * Return:      Success:    Size of the data type in bytes.	 The size of
+ *                          the data type is the size of an instance of
+ *                          that data type.
  *
- *		Failure:	0 (valid data types are never zero size)
+ *              Failure:    0 (valid data types are never zero size)
  *
- * Programmer:	Robb Matzke
- *		Tuesday, December  9, 1997
- *
- * Modifications:
+ * Programmer:  Robb Matzke
+ *              Tuesday, December  9, 1997
  *
  *-------------------------------------------------------------------------
  */
@@ -4079,9 +4030,9 @@ H5T_cmp(const H5T_t *dt1, const H5T_t *dt2, hbool_t superset)
 #ifdef H5T_DEBUG
             /* I don't quite trust the code above yet :-)  --RPM */
             for (u=0; u<dt1->shared->u.enumer.nmembs-1; u++) {
-                assert(HDstrcmp(dt1->shared->u.enumer.name[idx1[u]],
+                HDassert(HDstrcmp(dt1->shared->u.enumer.name[idx1[u]],
                         dt1->shared->u.enumer.name[idx1[u+1]]));
-                assert(HDstrcmp(dt2->shared->u.enumer.name[idx2[u]],
+                HDassert(HDstrcmp(dt2->shared->u.enumer.name[idx2[u]],
                         dt2->shared->u.enumer.name[idx2[u+1]]));
             }
 #endif
@@ -4999,26 +4950,24 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5T_is_sensible
+ * Function:    H5T_is_sensible
  *
- * Purpose:	Determines if a data type is sensible to store on disk
+ * Purpose:     Determines if a data type is sensible to store on disk
  *              (i.e. not partially initialized)
  *
- * Return:	Success:	TRUE, FALSE
+ * Return:      Success:    TRUE, FALSE
  *
- *		Failure:	Negative
+ *              Failure:    Negative
  *
- * Programmer:	Quincey Koziol
- *		Tuesday, June 11, 2002
- *
- * Modifications:
+ * Programmer:  Quincey Koziol
+ *              Tuesday, June 11, 2002
  *
  *-------------------------------------------------------------------------
  */
 htri_t
 H5T_is_sensible(const H5T_t *dt)
 {
-    htri_t	ret_value;
+    htri_t  ret_value;
 
     FUNC_ENTER_NOAPI(FAIL)
 
@@ -5028,28 +4977,28 @@ H5T_is_sensible(const H5T_t *dt)
         case H5T_COMPOUND:
             /* Only allow compound datatypes with at least one member to be stored on disk */
             if(dt->shared->u.compnd.nmembs > 0)
-                ret_value=TRUE;
+                ret_value = TRUE;
             else
-                ret_value=FALSE;
+                ret_value = FALSE;
             break;
 
         case H5T_ENUM:
             /* Only allow enum datatypes with at least one member to be stored on disk */
             if(dt->shared->u.enumer.nmembs > 0)
-                ret_value=TRUE;
+                ret_value = TRUE;
             else
-                ret_value=FALSE;
+                ret_value = FALSE;
             break;
 
         default:
             /* Assume all other datatype are sensible to store on disk */
-            ret_value=TRUE;
+            ret_value = TRUE;
             break;
     } /* end switch */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-}
+} /* end H5T_is_sensible */
 
 
 /*--------------------------------------------------------------------------
@@ -5241,11 +5190,11 @@ done:
  * Purpose:     H5T__visit callback to Upgrade the version of a datatype
  *              (if there's any benefit to doing so)
  *
- * Note:	The behavior below is tightly coupled with the "better"
+ * Note:        The behavior below is tightly coupled with the "better"
  *              encodings for datatype messages in the datatype message
  *              encoding routine.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
  * Programmer:  Quincey Koziol
  *              Thursday, July 19, 2007
diff --git a/src/H5Tconv.c b/src/H5Tconv.c
index 983922f..bb95713 100644
--- a/src/H5Tconv.c
+++ b/src/H5Tconv.c
@@ -2699,35 +2699,36 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5T__conv_enum
+ * Function:    H5T__conv_enum
  *
- * Purpose:	Converts one type of enumerated data to another.
+ * Purpose:     Converts one type of enumerated data to another.
  *
- * Return:	Success:	Non-negative
- *
- *		Failure:	negative
+ * Return:      SUCCEED/FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, January  4, 1999
  *-------------------------------------------------------------------------
  */
 herr_t
 H5T__conv_enum(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, size_t nelmts,
-	      size_t buf_stride, size_t UNUSED bkg_stride, void *_buf,
-              void UNUSED *bkg, hid_t UNUSED dxpl_id)
-{
-    uint8_t	*buf = (uint8_t*)_buf;	/*cast for pointer arithmetic	*/
-    H5T_t	*src = NULL, *dst = NULL;	/*src and dst datatypes	*/
-    H5T_t	*src_super = NULL, *dst_super = NULL;	/*parent types for src and dst*/
-    uint8_t	*s = NULL, *d = NULL;	/*src and dst BUF pointers	*/
-    int	src_delta, dst_delta;	/*conversion strides		*/
-    int	n;			/*src value cast as native int	*/
-    H5T_enum_struct_t *priv = (H5T_enum_struct_t*)(cdata->priv);
-    H5P_genplist_t      *plist;         /*property list pointer         */
-    H5T_conv_cb_t       cb_struct;      /*conversion callback structure */
-    H5T_conv_ret_t      except_ret;     /*return of callback function   */
-    size_t	i;			/*counters			*/
-    herr_t      ret_value = SUCCEED;    /* Return value                 */
+                size_t buf_stride, size_t UNUSED bkg_stride, void *_buf,
+                void UNUSED *bkg, hid_t UNUSED dxpl_id)
+{
+    uint8_t             *buf = (uint8_t *)_buf; /* cast for ptr arithmetic          */
+    H5T_t               *src = NULL;            /* src and dst datatypes            */
+    H5T_t               *dst = NULL;
+    H5T_t               *src_super = NULL;      /* src and dst parent types         */
+    H5T_t               *dst_super = NULL;
+    uint8_t             *s = NULL;              /* src and dst BUF pointers         */
+    uint8_t             *d = NULL;
+    int                 src_delta, dst_delta;   /* conversion strides               */
+    int                 n;                      /* src value cast as native int     */
+    H5T_enum_struct_t   *priv = (H5T_enum_struct_t*)(cdata->priv);
+    H5P_genplist_t      *plist;                 /* property list pointer            */
+    H5T_conv_cb_t       cb_struct;              /* conversion callback structure    */
+    H5T_conv_ret_t      except_ret;             /* return of callback function      */
+    size_t              i;                      /* counters                         */
+    herr_t              ret_value = SUCCEED;    /* Return value                     */
 
     FUNC_ENTER_PACKAGE
 
@@ -2736,7 +2737,7 @@ H5T__conv_enum(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, size_t nelmts,
             /*
              * Determine if this conversion function applies to the conversion
              * path SRC_ID->DST_ID.  If not return failure; otherwise initialize
-             * the `priv' field of `cdata' with information about the underlying
+             * the 'priv' field of 'cdata' with information about the underlying
              * integer conversion.
              */
             if(NULL == (src = (H5T_t *)H5I_object(src_id)) || NULL == (dst = (H5T_t *)H5I_object(dst_id)))
@@ -2776,7 +2777,8 @@ H5T__conv_enum(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, size_t nelmts,
             /* priv->src2dst map was computed for certain sort keys. Make sure those same
              * sort keys are used here during conversion. See H5T_conv_enum_init(). But
              * we actually don't care about the source type's order when doing the O(1)
-             * conversion algorithm, which is turned on by non-zero priv->length */
+             * conversion algorithm, which is turned on by non-zero priv->length
+             */
             H5T__sort_name(dst, NULL);
             if(!priv->length)
                 H5T__sort_value(src, NULL);
@@ -2788,12 +2790,12 @@ H5T__conv_enum(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, size_t nelmts,
                 src_delta = dst_delta = (int)buf_stride;
                 s = d = buf;
             } else if(dst->shared->size <= src->shared->size) {
-                src_delta = (int)src->shared->size; /*overflow shouldn't be possible*/
-                dst_delta = (int)dst->shared->size; /*overflow shouldn't be possible*/
+                src_delta = (int)src->shared->size; /* overflow shouldn't be possible */
+                dst_delta = (int)dst->shared->size; /* overflow shouldn't be possible */
                 s = d = buf;
             } else {
-                src_delta = -(int)src->shared->size; /*overflow shouldn't be possible*/
-                dst_delta = -(int)dst->shared->size; /*overflow shouldn't be possible*/
+                src_delta = -(int)src->shared->size; /* overflow shouldn't be possible */
+                dst_delta = -(int)dst->shared->size; /* overflow shouldn't be possible */
                 s = buf + (nelmts-1) * src->shared->size;
                 d = buf + (nelmts-1) * dst->shared->size;
             }
@@ -2825,7 +2827,7 @@ H5T__conv_enum(hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata, size_t nelmts,
                     if(n < 0 || n >= priv->length || priv->src2dst[n] < 0) {
                         /*overflow*/
                         except_ret = H5T_CONV_UNHANDLED;
-                        if(cb_struct.func) { /*If user's exception handler is present, use it*/
+                        if(cb_struct.func) { /* If user's exception handler is present, use it */
                             except_ret = (cb_struct.func)(H5T_CONV_EXCEPT_RANGE_HI, src_id, dst_id,
                                     s, d, cb_struct.user_data);
                         }
diff --git a/src/H5Tdbg.c b/src/H5Tdbg.c
index e5df7ff..a19a15a 100644
--- a/src/H5Tdbg.c
+++ b/src/H5Tdbg.c
@@ -34,9 +34,9 @@
 /***********/
 /* Headers */
 /***********/
-#include "H5private.h"		/* Generic Functions			*/
-#include "H5Eprivate.h"		/* Error handling		  	*/
-#include "H5Tpkg.h"		/* Datatypes         			*/
+#include "H5private.h"          /* Generic Functions                        */
+#include "H5Eprivate.h"         /* Error handling                           */
+#include "H5Tpkg.h"             /* Datatypes                                */
 
 
 /****************/
@@ -372,26 +372,25 @@ H5T_debug(const H5T_t *dt, FILE *stream)
             fprintf(stream, "\n");
         } /* end else */
     } else if(H5T_ENUM == dt->shared->type) {
-        size_t	base_size;
-
-	/* Enumeration data type */
-	fprintf(stream, " ");
-	H5T_debug(dt->shared->parent, stream);
-	base_size = dt->shared->parent->shared->size;
-	for(i = 0; i < dt->shared->u.enumer.nmembs; i++) {
-            size_t	k;
-
-	    fprintf(stream, "\n\"%s\" = 0x", dt->shared->u.enumer.name[i]);
-	    for(k = 0; k < base_size; k++)
-		fprintf(stream, "%02lx",
-			(unsigned long)(dt->shared->u.enumer.value + (i * base_size) + k));
-	} /* end for */
-	fprintf(stream, "\n");
+        size_t base_size;
+
+        /* Enumeration data type */
+        fprintf(stream, " ");
+        H5T_debug(dt->shared->parent, stream);
+        base_size = dt->shared->parent->shared->size;
+        for(i = 0; i < dt->shared->u.enumer.nmembs; i++) {
+            size_t k;
+
+            fprintf(stream, "\n\"%s\" = 0x", dt->shared->u.enumer.name[i]);
+            for(k = 0; k < base_size; k++)
+                fprintf(stream, "%02lx", (unsigned long)(dt->shared->u.enumer.value + (i * base_size) + k));
+        } /* end for */
+        fprintf(stream, "\n");
     } else if(H5T_OPAQUE == dt->shared->type) {
-	fprintf(stream, ", tag=\"%s\"", dt->shared->u.opaque.tag);
+        fprintf(stream, ", tag=\"%s\"", dt->shared->u.opaque.tag);
     } else {
-	/* Unknown */
-	fprintf(stream, "unknown class %d\n", (int)(dt->shared->type));
+        /* Unknown */
+        fprintf(stream, "unknown class %d\n", (int)(dt->shared->type));
     }
     fprintf(stream, "}");
 
diff --git a/src/H5Tenum.c b/src/H5Tenum.c
index 8e4e8a2..51bdf6f 100644
--- a/src/H5Tenum.c
+++ b/src/H5Tenum.c
@@ -24,17 +24,17 @@
 #define H5_INTERFACE_INIT_FUNC	H5T_init_enum_interface
 
 
-#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			  */
+#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              */
 
 /* Static local functions */
-static char *H5T_enum_nameof(const H5T_t *dt, const void *value, char *name/*out*/,
-			      size_t size);
+static char *H5T_enum_nameof(const H5T_t *dt, const void *value,
+                                char *name/*out*/, size_t size);
 static herr_t H5T_enum_valueof(const H5T_t *dt, const char *name,
-				void *value/*out*/);
+                                void *value/*out*/);
 
 
 /*--------------------------------------------------------------------------
@@ -60,42 +60,40 @@ H5T_init_enum_interface(void)
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tenum_create
+ * Function:    H5Tenum_create
  *
- * Purpose:	Create a new enumeration data type based on the specified
- *		TYPE, which must be an integer type.
+ * Purpose:     Create a new enumeration data type based on the specified
+ *              TYPE, which must be an integer type.
  *
- * Return:	Success:	ID of new enumeration data type
+ * Return:      Success:    ID of new enumeration data type
  *
- *		Failure:	Negative
+ *              Failure:    Negative
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Tuesday, December 22, 1998
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 hid_t
 H5Tenum_create(hid_t parent_id)
 {
-    H5T_t	*parent = NULL;		/*base integer data type	*/
-    H5T_t	*dt = NULL;		/*new enumeration data type	*/
-    hid_t	ret_value;	        /*return value			*/
+    H5T_t   *parent = NULL;     /* base integer data type       */
+    H5T_t   *dt = NULL;         /* new enumeration data type    */
+    hid_t   ret_value;          /* return value                 */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE1("i", "i", parent_id);
 
     /* Check args */
     if(NULL == (parent = (H5T_t *)H5I_object_verify(parent_id, H5I_DATATYPE)) || H5T_INTEGER != parent->shared->type)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an integer data type")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an integer data type")
 
     /* Build new type */
     if(NULL == (dt = H5T__enum_create(parent)))
-	HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "cannot create enum type")
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "cannot create enum type")
     /* Atomize the type */
-    if ((ret_value=H5I_register(H5I_DATATYPE, dt, TRUE))<0)
-	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTREGISTER, FAIL, "unable to register data type atom")
+    if ((ret_value = H5I_register(H5I_DATATYPE, dt, TRUE)) < 0)
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTREGISTER, FAIL, "unable to register data type atom")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -103,27 +101,25 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5T__enum_create
+ * Function:    H5T__enum_create
  *
- * Purpose:	Private function for H5Tenum_create.  Create a new
+ * Purpose:     Private function for H5Tenum_create.  Create a new
  *              enumeration data type based on the specified
- *		TYPE, which must be an integer type.
+ *              TYPE, which must be an integer type.
  *
- * Return:	Success:	new enumeration data type
+ * Return:      Success:    new enumeration data type
  *
- *		Failure:        NULL
+ *              Failure:    NULL
  *
- * Programmer:	Raymond Lu
+ * Programmer:  Raymond Lu
  *              October 9, 2002
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 H5T_t *
 H5T__enum_create(const H5T_t *parent)
 {
-    H5T_t	*ret_value;		/*new enumeration data type	*/
+    H5T_t   *ret_value;     /*new enumeration data type	*/
 
     FUNC_ENTER_PACKAGE
 
@@ -143,48 +139,44 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tenum_insert
- *
- * Purpose:	Insert a new enumeration data type member into an enumeration
- *		type. TYPE is the enumeration type, NAME is the name of the
- *		new member, and VALUE points to the value of the new member.
- *		The NAME and VALUE must both be unique within the TYPE. VALUE
- *		points to data which is of the data type defined when the
- *		enumeration type was created.
+ * Function:    H5Tenum_insert
  *
- * Return:	Success:	non-negative
+ * Purpose:     Insert a new enumeration data type member into an enumeration
+ *              type. TYPE is the enumeration type, NAME is the name of the
+ *              new member, and VALUE points to the value of the new member.
+ *              The NAME and VALUE must both be unique within the TYPE. VALUE
+ *              points to data which is of the data type defined when the
+ *              enumeration type was created.
  *
- *		Failure:	negative
+ * Return:      SUCCEED/FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, December 23, 1998
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 herr_t
 H5Tenum_insert(hid_t type, const char *name, const void *value)
 {
-    H5T_t	*dt=NULL;
-    herr_t      ret_value=SUCCEED;       /* Return value */
+    H5T_t       *dt = NULL;
+    herr_t      ret_value = SUCCEED;        /* Return value */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE3("e", "i*s*x", type, name, value);
 
     /* Check args */
     if(NULL == (dt = (H5T_t *)H5I_object_verify(type, H5I_DATATYPE)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type")
     if(H5T_ENUM != dt->shared->type)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an enumeration data type")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an enumeration data type")
     if (!name || !*name)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name specified")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name specified")
     if (!value)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no value specified")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no value specified")
 
     /* Do work */
     if(H5T__enum_insert(dt, name, value) < 0)
-	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to insert new enumeration member")
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to insert new enumeration member")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -192,31 +184,27 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5T__enum_insert
- *
- * Purpose:	Insert a new member having a NAME and VALUE into an
- *		enumeration data TYPE.  The NAME and VALUE must both be
- *		unique. The VALUE points to data of the data type defined for
- *		the enumeration base type.
+ * Function:    H5T__enum_insert
  *
- * Return:	Success:	non-negative
+ * Purpose:     Insert a new member having a NAME and VALUE into an
+ *              enumeration data TYPE.  The NAME and VALUE must both be
+ *              unique. The VALUE points to data of the data type defined for
+ *              the enumeration base type.
  *
- *		Failure:	negative
+ * Return:      SUCCEED/FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, December 23, 1998
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 herr_t
 H5T__enum_insert(const H5T_t *dt, const char *name, const void *value)
 {
-    unsigned	i;
-    char	**names=NULL;
-    uint8_t	*values=NULL;
-    herr_t      ret_value=SUCCEED;       /* Return value */
+    unsigned    i;
+    char        **names = NULL;
+    uint8_t     *values = NULL;
+    herr_t      ret_value = SUCCEED;        /* Return value */
 
     FUNC_ENTER_PACKAGE
 
@@ -225,32 +213,32 @@ H5T__enum_insert(const H5T_t *dt, const char *name, const void *value)
     assert(value);
 
     /* The name and value had better not already exist */
-    for (i=0; i<dt->shared->u.enumer.nmembs; i++) {
-	if (!HDstrcmp(dt->shared->u.enumer.name[i], name))
-	    HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "name redefinition")
-	if (!HDmemcmp(dt->shared->u.enumer.value+i*dt->shared->size, value, dt->shared->size))
-	    HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "value redefinition")
+    for (i = 0; i < dt->shared->u.enumer.nmembs; i++) {
+        if (!HDstrcmp(dt->shared->u.enumer.name[i], name))
+            HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "name redefinition")
+        if (!HDmemcmp(dt->shared->u.enumer.value+i*dt->shared->size, value, dt->shared->size))
+            HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "value redefinition")
     }
 
-    /* Increase table sizes */
+    /* Increase table sizes, if necessary */
     if(dt->shared->u.enumer.nmembs >= dt->shared->u.enumer.nalloc) {
-	unsigned n = MAX(32, 2*dt->shared->u.enumer.nalloc);
+        unsigned n = MAX(32, 2 * dt->shared->u.enumer.nalloc);
 
-	if(NULL == (names = (char **)H5MM_realloc(dt->shared->u.enumer.name, n * sizeof(char *))))
-	    HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
-	dt->shared->u.enumer.name = names;
+        if(NULL == (names = (char **)H5MM_realloc(dt->shared->u.enumer.name, n * sizeof(char *))))
+            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
+        dt->shared->u.enumer.name = names;
 
-	if(NULL == (values = (uint8_t *)H5MM_realloc(dt->shared->u.enumer.value, n * dt->shared->size)))
-	    HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
-	dt->shared->u.enumer.value = values;
-	dt->shared->u.enumer.nalloc = n;
+        if(NULL == (values = (uint8_t *)H5MM_realloc(dt->shared->u.enumer.value, n * dt->shared->size)))
+            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
+        dt->shared->u.enumer.value = values;
+        dt->shared->u.enumer.nalloc = n;
     }
 
     /* Insert new member at end of member arrays */
     dt->shared->u.enumer.sorted = H5T_SORT_NONE;
     i = dt->shared->u.enumer.nmembs++;
     dt->shared->u.enumer.name[i] = H5MM_xstrdup(name);
-    HDmemcpy(dt->shared->u.enumer.value+i*dt->shared->size, value, dt->shared->size);
+    HDmemcpy(dt->shared->u.enumer.value + (i * dt->shared->size), value, dt->shared->size);
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -258,63 +246,61 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tget_member_value
+ * Function:    H5Tget_member_value
  *
- * Purpose:	Return the value for an enumeration data type member.
+ * Purpose:     Return the value for an enumeration data type member.
  *
- * Return:	Success:	non-negative with the member value copied
- *				into the memory pointed to by VALUE.
+ * Return:      Success:    SUCCEED
+ *                          VALUE memory contains member value.
  *
- *		Failure:	negative, VALUE memory is undefined.
+ *              Failure:    FAIL
+ *                          VALUE memory is undefined.
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, December 23, 1998
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 herr_t
 H5Tget_member_value(hid_t type, unsigned membno, void *value/*out*/)
 {
-    H5T_t	*dt=NULL;
-    herr_t      ret_value=SUCCEED;       /* Return value */
+    H5T_t       *dt = NULL;
+    herr_t      ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE3("e", "iIux", type, membno, value);
 
     if(NULL == (dt = (H5T_t *)H5I_object_verify(type, H5I_DATATYPE)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type")
     if(H5T_ENUM != dt->shared->type)
-	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "operation not defined for data type class")
-    if (membno>=dt->shared->u.enumer.nmembs)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid member number")
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "operation not defined for data type class")
+    if (membno >= dt->shared->u.enumer.nmembs)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid member number")
     if (!value)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "null value buffer")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "null value buffer")
 
     if(H5T__get_member_value(dt, membno, value) < 0)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "unable to get member value")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "unable to get member value")
 done:
     FUNC_LEAVE_API(ret_value)
 }
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5T__get_member_value
+ * Function:    H5T__get_member_value
  *
- * Purpose:	Private function for H5T__get_member_value.  Return the
+ * Purpose:     Private function for H5T__get_member_value.  Return the
  *              value for an enumeration data type member.
  *
- * Return:	Success:	non-negative with the member value copied
- *				into the memory pointed to by VALUE.
+ * Return:      Success:    SUCCEED
+ *                          VALUE memory contains member value.
  *
- *		Failure:	negative, VALUE memory is undefined.
+ *              Failure:    FAIL
+ *                          VALUE memory is undefined.
  *
- * Programmer:	Raymond Lu
+ * Programmer:  Raymond Lu
  *              October 9, 2002
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 herr_t
@@ -333,48 +319,46 @@ H5T__get_member_value(const H5T_t *dt, unsigned membno, void *value/*out*/)
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tenum_nameof
+ * Function:    H5Tenum_nameof
  *
- * Purpose:	Finds the symbol name that corresponds to the specified VALUE
- *		of an enumeration data type TYPE. At most SIZE characters of
- *		the symbol name are copied into the NAME buffer. If the
- *		entire symbol anem and null terminator do not fit in the NAME
- *		buffer then as many characters as possible are copied (not
- *		null terminated) and the function fails.
+ * Purpose:     Finds the symbol name that corresponds to the specified VALUE
+ *              of an enumeration data type TYPE. At most SIZE characters of
+ *              the symbol name are copied into the NAME buffer. If the
+ *              entire symbol anem and null terminator do not fit in the NAME
+ *              buffer then as many characters as possible are copied (not
+ *              null terminated) and the function fails.
  *
- * Return:	Success:	Non-negative.
+ * Return:      Success:    SUCCEED
  *
- *		Failure:	Negative, first character of NAME is set to
- *				null if SIZE allows it.
+ *              Failure:    FAIL
+ *                          name[0] is set to null if size > 0
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, January  4, 1999
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 herr_t
 H5Tenum_nameof(hid_t type, const void *value, char *name/*out*/, size_t size)
 {
-    H5T_t	*dt = NULL;
-    herr_t      ret_value=SUCCEED;       /* Return value */
+    H5T_t       *dt = NULL;
+    herr_t      ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE4("e", "i*xxz", type, value, name, size);
 
     /* Check args */
     if(NULL == (dt = (H5T_t *)H5I_object_verify(type, H5I_DATATYPE)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type")
     if(H5T_ENUM != dt->shared->type)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an enumeration data type")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an enumeration data type")
     if (!value)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no value supplied")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no value supplied")
     if (!name)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name buffer supplied")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name buffer supplied")
 
-    if (NULL==H5T_enum_nameof(dt, value, name, size))
-	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "nameof query failed")
+    if (NULL == H5T_enum_nameof(dt, value, name, size))
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "nameof query failed")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -382,41 +366,37 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5T_enum_nameof
+ * Function:    H5T_enum_nameof
  *
- * Purpose:	Finds the symbol name that corresponds the the specified
- *		VALUE of an enumeration data type DT. At most SIZE characters
- *		of the symbol name are copied into the NAME buffer. If the
- *		entire symbol name and null terminator do not fit in the NAME
- *		buffer then as many characters as possible are copied and the
- *		function returns failure.
+ * Purpose:     Finds the symbol name that corresponds the the specified
+ *              VALUE of an enumeration data type DT. At most SIZE characters
+ *              of the symbol name are copied into the NAME buffer. If the
+ *              entire symbol name and null terminator do not fit in the NAME
+ *              buffer then as many characters as possible are copied and the
+ *              function returns failure.
  *
- *		If NAME is the null pointer and SIZE is zero then enough
- *		space is allocated to hold the result and a pointer to that
- *		memory is returned.
+ *              If NAME is the null pointer and SIZE is zero then enough
+ *              space is allocated to hold the result and a pointer to that
+ *              memory is returned.
  *
- * Return:	Success:	Pointer to NAME
+ * Return:      Success:    Pointer to NAME
  *
- *		Failure:	NULL, name[0] is set to null.
+ *              Failure:    NULL
+ *                          name[0] is set to null if size > 0
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, January  4, 1999
  *
- * Modifications:
- *              Raymond Lu
- *              Wednesday, Febuary 9, 2005
- *              Made a copy of original datatype and do sorting and search
- *              on that copy, to protect the original order of members.
  *-------------------------------------------------------------------------
  */
 static char *
 H5T_enum_nameof(const H5T_t *dt, const void *value, char *name/*out*/, size_t size)
 {
-    H5T_t       *copied_dt = NULL;      /* Do sorting in copied datatype */
-    unsigned	lt, md = 0, rt;		/* Indices for binary search	*/
-    int	        cmp = (-1);		/* Comparison result		*/
-    hbool_t     alloc_name = FALSE;     /* Whether name has been allocated */
-    char        *ret_value;             /* Return value */
+    H5T_t       *copied_dt = NULL;      /* Do sorting in copied datatype    */
+    unsigned    lt, md = 0, rt;         /* Indices for binary search        */
+    int         cmp = -1;               /* Comparison result                */
+    hbool_t     alloc_name = FALSE;     /* Whether name has been allocated  */
+    char        *ret_value;             /* Return value                     */
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -435,37 +415,36 @@ H5T_enum_nameof(const H5T_t *dt, const void *value, char *name/*out*/, size_t si
     /* Do a binary search over the values to find the correct one.  Do sorting
      * and search on the copied datatype to protect the original order. */
     if(NULL == (copied_dt = H5T_copy(dt, H5T_COPY_ALL)))
-	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, NULL, "unable to copy data type")
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, NULL, "unable to copy data type")
     if(H5T__sort_value(copied_dt, NULL) < 0)
         HGOTO_ERROR(H5E_DATATYPE, H5E_CANTCOMPARE, NULL, "value sort failed")
 
     lt = 0;
     rt = copied_dt->shared->u.enumer.nmembs;
     while(lt < rt) {
-	md = (lt + rt) / 2;
-	cmp = HDmemcmp(value, copied_dt->shared->u.enumer.value + md * copied_dt->shared->size, copied_dt->shared->size);
-	if(cmp < 0)
-	    rt = md;
-	else if(cmp > 0)
-	    lt = md + 1;
-	else
-	    break;
+        md = (lt + rt) / 2;
+        cmp = HDmemcmp(value, copied_dt->shared->u.enumer.value + (md * copied_dt->shared->size), copied_dt->shared->size);
+        if(cmp < 0)
+            rt = md;
+        else if(cmp > 0)
+            lt = md + 1;
+        else
+            break;
     } /* end while */
 
-    /* Value was not yet defined. This fixes bug # 774, 2002/06/05 EIP */
+    /* Value was not yet defined */
     if(cmp != 0)
         HGOTO_ERROR(H5E_DATATYPE, H5E_NOTFOUND, NULL, "value is currently not defined")
 
     /* Save result name */
     if(!name) {
-        if(NULL == (name = (char *)H5MM_malloc(
-                HDstrlen(copied_dt->shared->u.enumer.name[md]) + 1)))
+        if(NULL == (name = (char *)H5MM_malloc(HDstrlen(copied_dt->shared->u.enumer.name[md]) + 1)))
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
         alloc_name = TRUE;
     } /* end if */
     HDstrncpy(name, copied_dt->shared->u.enumer.name[md], size);
     if(HDstrlen(copied_dt->shared->u.enumer.name[md]) >= size)
-	HGOTO_ERROR(H5E_DATATYPE, H5E_NOSPACE, NULL, "name has been truncated")
+        HGOTO_ERROR(H5E_DATATYPE, H5E_NOSPACE, NULL, "name has been truncated")
 
     /* Set return value */
     ret_value = name;
@@ -482,48 +461,41 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tenum_valueof
+ * Function:    H5Tenum_valueof
  *
- * Purpose:	Finds the value that corresponds to the specified NAME f an
- *		enumeration TYPE. The VALUE argument should be at least as
- *		large as the value of H5Tget_size(type) in order to hold the
- *		result.
+ * Purpose:     Finds the value that corresponds to the specified NAME f an
+ *              enumeration TYPE. The VALUE argument should be at least as
+ *              large as the value of H5Tget_size(type) in order to hold the
+ *              result.
  *
- * Return:	Success:	Non-negative
+ * Return:      SUCCEED/FAIL
  *
- *		Failure:	Negative
- *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, January  4, 1999
  *
- * Modifications:
- *              Raymond Lu
- *              Wednesday, Febuary 9, 2005
- *              Made a copy of original datatype and do sorting and search
- *              on that copy, to protect the original order of members.
  *-------------------------------------------------------------------------
  */
 herr_t
 H5Tenum_valueof(hid_t type, const char *name, void *value/*out*/)
 {
-    H5T_t	*dt;
-    herr_t      ret_value = SUCCEED;       /* Return value */
+    H5T_t       *dt;
+    herr_t      ret_value = SUCCEED;        /* Return value */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE3("e", "i*sx", type, name, value);
 
     /* Check args */
     if(NULL == (dt = (H5T_t *)H5I_object_verify(type, H5I_DATATYPE)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type")
     if(H5T_ENUM != dt->shared->type)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an enumeration data type")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an enumeration data type")
     if(!name || !*name)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no name")
     if(!value)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no value buffer")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no value buffer")
 
     if(H5T_enum_valueof(dt, name, value) < 0)
-	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "valueof query failed")
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "valueof query failed")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -531,34 +503,31 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5T_enum_valueof
+ * Function:    H5T_enum_valueof
  *
- * Purpose:	Finds the value that corresponds the the specified symbol
- *		NAME of an enumeration data type DT and copy it to the VALUE
- *		result buffer. The VALUE should be allocated by the caller to
- *		be large enough for the result.
+ * Purpose:     Finds the value that corresponds the the specified symbol
+ *              NAME of an enumeration data type DT and copy it to the VALUE
+ *              result buffer. The VALUE should be allocated by the caller to
+ *              be large enough for the result.
  *
- * Return:	Success:	Non-negative, value stored in VALUE.
+ * Return:      Success:    SUCCEED
+ *                          VALUE contains the enum value.
  *
- *		Failure:	Negative, VALUE is undefined.
+ *              Failure:    FAIL
+ *                          VALUE is undefined.
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, January  4, 1999
  *
- * Modifications:
- *              Raymond Lu
- *              Wednesday, Febuary 9, 2005
- *              Made a copy of original datatype and do sorting and search
- *              on that copy, to protect the original order of members.
  *-------------------------------------------------------------------------
  */
 static herr_t
 H5T_enum_valueof(const H5T_t *dt, const char *name, void *value/*out*/)
 {
-    unsigned	lt, md=0, rt;		/*indices for binary search	*/
-    int	        cmp=(-1);		/*comparison result		*/
-    H5T_t       *copied_dt = NULL;      /*do sorting in copied datatype */
-    herr_t      ret_value=SUCCEED;      /* Return value */
+    unsigned    lt, md = 0, rt;         /* indices for binary search        */
+    int         cmp = -1;               /* comparison result                */
+    H5T_t       *copied_dt = NULL;      /* do sorting in copied datatype    */
+    herr_t      ret_value = SUCCEED;    /* Return value                     */
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -573,27 +542,27 @@ H5T_enum_valueof(const H5T_t *dt, const char *name, void *value/*out*/)
 
     /* Do a binary search over the names to find the correct one.  Do sorting
      * and search on the copied datatype to protect the original order. */
-    if (NULL==(copied_dt=H5T_copy(dt, H5T_COPY_ALL)))
-	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to copy data type");
+    if (NULL == (copied_dt = H5T_copy(dt, H5T_COPY_ALL)))
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to copy data type");
     if(H5T__sort_name(copied_dt, NULL) < 0)
         HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOMPARE, FAIL, "value sort failed")
 
     lt = 0;
     rt = copied_dt->shared->u.enumer.nmembs;
 
-    while (lt<rt) {
-	md = (lt+rt)/2;
-	cmp = HDstrcmp(name, copied_dt->shared->u.enumer.name[md]);
-	if (cmp<0) {
-	    rt = md;
-	} else if (cmp>0) {
-	    lt = md+1;
-	} else {
-	    break;
-	}
+    while (lt < rt) {
+        md = (lt + rt) / 2;
+        cmp = HDstrcmp(name, copied_dt->shared->u.enumer.name[md]);
+        if (cmp < 0) {
+            rt = md;
+        } else if (cmp>0) {
+            lt = md + 1;
+        } else {
+            break;
+        }
     }
-    /* Value was not yet defined. This fixes bug # 774, 2002/06/05 EIP */
-    if (cmp!=0)
+    /* Value was not yet defined. */
+    if (cmp != 0)
         HGOTO_ERROR(H5E_DATATYPE, H5E_NOTFOUND, FAIL, "string doesn't exist in the enumeration type")
 
     HDmemcpy(value, copied_dt->shared->u.enumer.value+md*copied_dt->shared->size, copied_dt->shared->size);
@@ -605,4 +574,3 @@ done:
 
     FUNC_LEAVE_NOAPI(ret_value)
 }
-
diff --git a/src/H5Tfields.c b/src/H5Tfields.c
index 163bab3..e980ae3 100644
--- a/src/H5Tfields.c
+++ b/src/H5Tfields.c
@@ -18,17 +18,17 @@
  *      enumerated & compound datatypes in the H5T interface.
  */
 
-#define H5T_PACKAGE		/*suppress error about including H5Tpkg	  */
+#define H5T_PACKAGE         /* suppress error about including H5Tpkg */
 
 /* Interface initialization */
-#define H5_INTERFACE_INIT_FUNC	H5T_init_fields_interface
+#define H5_INTERFACE_INIT_FUNC      H5T_init_fields_interface
 
 
-#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			  */
+#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                      */
 
 
 /*--------------------------------------------------------------------------
@@ -54,40 +54,35 @@ H5T_init_fields_interface(void)
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tget_nmembers
+ * Function:    H5Tget_nmembers
  *
- * Purpose:	Determines how many members TYPE_ID has.  The type must be
- *		either a compound datatype or an enumeration datatype.
+ * Purpose:     Determines how many members TYPE_ID has.  The type must be
+ *              either a compound datatype or an enumeration datatype.
  *
- * Return:	Success:	Number of members defined in the datatype.
+ * Return:      Success:    Number of members defined in the datatype.
  *
- *		Failure:	Negative
+ *              Failure:    Negative
  *
- * Errors:
+ * Programmer:  Robb Matzke
+ *              Monday, December  8, 1997
  *
- * Programmer:	Robb Matzke
- *		Monday, December  8, 1997
- *
- * Modifications:
- *	Robb Matzke, 22 Dec 1998
- *	Also works with enumeration datatypes.
  *-------------------------------------------------------------------------
  */
 int
 H5Tget_nmembers(hid_t type_id)
 {
-    H5T_t *dt;          /* Datatype to query */
-    int	ret_value;      /* Return value */
+    H5T_t   *dt;            /* Datatype to query */
+    int     ret_value;      /* Return value */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE1("Is", "i", type_id);
 
     /* Check args */
     if(NULL == (dt = (H5T_t *)H5I_object_verify(type_id, H5I_DATATYPE)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype")
 
     if((ret_value = H5T_get_nmembers(dt)) < 0)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "cannot return member number")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "cannot return member number")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -95,40 +90,36 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5T_get_nmembers
+ * Function:    H5T_get_nmembers
  *
- * Purpose:	Private function for H5Tget_nmembers.  Determines how many
+ * Purpose:     Private function for H5Tget_nmembers.  Determines how many
  *              members DTYPE has.  The type must be either a compound data
  *              type or an enumeration datatype.
  *
- * Return:	Success:	Number of members defined in the datatype.
+ * Return:      Success:    Number of members defined in the datatype.
  *
- *		Failure:	Negative
- *
- * Errors:
+ *              Failure:    Negative
  *
  * Programmer:  Raymond Lu
- *	        October 8, 2002
- *
- * Modifications:
+ *              October 8, 2002
  *
  *-------------------------------------------------------------------------
  */
 int
 H5T_get_nmembers(const H5T_t *dt)
 {
-    int	ret_value;
+    int ret_value;
 
     FUNC_ENTER_NOAPI(FAIL)
 
     HDassert(dt);
 
     if(H5T_COMPOUND == dt->shared->type)
-	ret_value = (int)dt->shared->u.compnd.nmembs;
+        ret_value = (int)dt->shared->u.compnd.nmembs;
     else if(H5T_ENUM == dt->shared->type)
-	ret_value = (int)dt->shared->u.enumer.nmembs;
+        ret_value = (int)dt->shared->u.enumer.nmembs;
     else
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "operation not supported for type class")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "operation not supported for type class")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -136,69 +127,65 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tget_member_name
+ * Function:    H5Tget_member_name
  *
- * Purpose:	Returns the name of a member of a compound or enumeration
- *		datatype. Members are stored in no particular order with
- *		numbers 0 through N-1 where N is the value returned by
- *		H5Tget_nmembers().
+ * Purpose:     Returns the name of a member of a compound or enumeration
+ *              datatype. Members are stored in no particular order with
+ *              numbers 0 through N-1 where N is the value returned by
+ *              H5Tget_nmembers().
  *
- * Return:	Success:	Ptr to a string allocated with malloc().  The
- *				caller is responsible for freeing the string.
+ * Return:      Success:    Ptr to a string allocated with malloc().  The
+ *                          caller is responsible for freeing the string.
  *
- *		Failure:	NULL
+ *              Failure:    NULL
  *
- * Programmer:	Robb Matzke
- *		Wednesday, January  7, 1998
+ * Programmer:  Robb Matzke
+ *              Wednesday, January  7, 1998
  *
- * Modifications:
- *	Robb Matzke, 22 Dec 1998
- *	Also works with enumeration datatypes.
  *-------------------------------------------------------------------------
  */
 char *
 H5Tget_member_name(hid_t type_id, unsigned membno)
 {
-    H5T_t	*dt = NULL;
-    char	*ret_value;
+    H5T_t   *dt = NULL;
+    char    *ret_value;
 
     FUNC_ENTER_API(NULL)
 
     /* Check args */
-    if (NULL == (dt = (H5T_t *)H5I_object_verify(type_id,H5I_DATATYPE)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a datatype")
+    if (NULL == (dt = (H5T_t *)H5I_object_verify(type_id, H5I_DATATYPE)))
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a datatype")
 
     if(NULL == (ret_value = H5T__get_member_name(dt, membno)))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "unable to get member name")
 
 done:
     FUNC_LEAVE_API(ret_value)
-}
+} /* end H5Tget_member_name */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5T__get_member_name
+ * Function:    H5T__get_member_name
  *
- * Purpose:	Private function for H5Tget_member_name.  Returns the name
+ * Purpose:     Private function for H5Tget_member_name.  Returns the name
  *              of a member of a compound or enumeration datatype. Members
  *              are stored in no particular order with numbers 0 through
  *              N-1 where N is the value returned by H5Tget_nmembers().
  *
- * Return:	Success:	Ptr to a string allocated with malloc().  The
- *				caller is responsible for freeing the string.
+ * Return:      Success:    Ptr to a string allocated with malloc().  The
+ *                          caller is responsible for freeing the string.
  *
- *		Failure:	NULL
+ *              Failure:    NULL
  *
- * Programmer:	Raymond Lu
+ * Programmer:  Raymond Lu
  *              October 9, 2002
  *
- * Modifications:
  *-------------------------------------------------------------------------
  */
 char *
 H5T__get_member_name(H5T_t const *dt, unsigned membno)
 {
-    char	*ret_value;
+    char    *ret_value;
 
     FUNC_ENTER_PACKAGE
 
@@ -230,11 +217,11 @@ H5T__get_member_name(H5T_t const *dt, unsigned membno)
         case H5T_NCLASSES:
         default:
             HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "operation not supported for type class")
-    } /*lint !e788 All appropriate cases are covered */
+    }
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-}
+} /* end H5T__get_member_name */
 
 
 /*-------------------------------------------------------------------------
@@ -304,30 +291,30 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5T__sort_value
+ * Function:    H5T__sort_value
  *
- * Purpose:	Sorts the members of a compound datatype by their offsets;
- *		sorts the members of an enum type by their values. This even
- *		works for locked datatypes since it doesn't change the value
- *		of the type.  MAP is an optional parallel integer array which
- *		is also swapped along with members of DT.
+ * Purpose:     Sorts the members of a compound datatype by their offsets;
+ *              sorts the members of an enum type by their values. This even
+ *              works for locked datatypes since it doesn't change the value
+ *              of the type.  MAP is an optional parallel integer array which
+ *              is also swapped along with members of DT.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
- * Programmer:	Robb Matzke
- *		Wednesday, January  7, 1998
+ * Programmer:  Robb Matzke
+ *              Wednesday, January  7, 1998
  *
  *-------------------------------------------------------------------------
  */
 herr_t
 H5T__sort_value(const H5T_t *dt, int *map)
 {
-    unsigned	nmembs;                 /* Number of members for datatype */
-    size_t	size;
-    hbool_t	swapped;                /* Whether we've swapped fields */
-    uint8_t	tbuf[32];
-    unsigned	i, j;                   /* Local index variables */
-    herr_t ret_value = SUCCEED;         /* Return value */
+    unsigned    nmembs;                 /* Number of members for datatype */
+    size_t      size;
+    hbool_t     swapped;                /* Whether we've swapped fields */
+    uint8_t     tbuf[32];
+    unsigned    i, j;                   /* Local index variables */
+    herr_t      ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_PACKAGE_NOERR
 
@@ -337,69 +324,69 @@ H5T__sort_value(const H5T_t *dt, int *map)
 
     /* Use a bubble sort because we can short circuit */
     if(H5T_COMPOUND == dt->shared->type) {
-	if(H5T_SORT_VALUE != dt->shared->u.compnd.sorted) {
-	    dt->shared->u.compnd.sorted = H5T_SORT_VALUE;
-	    nmembs = dt->shared->u.compnd.nmembs;
-	    for(i = nmembs - 1, swapped = TRUE; i > 0 && swapped; --i) {
-		for(j = 0, swapped = FALSE; j < i; j++) {
-		    if(dt->shared->u.compnd.memb[j].offset > dt->shared->u.compnd.memb[j + 1].offset) {
+        if(H5T_SORT_VALUE != dt->shared->u.compnd.sorted) {
+            dt->shared->u.compnd.sorted = H5T_SORT_VALUE;
+            nmembs = dt->shared->u.compnd.nmembs;
+            for(i = nmembs - 1, swapped = TRUE; i > 0 && swapped; --i) {
+                for(j = 0, swapped = FALSE; j < i; j++) {
+                    if(dt->shared->u.compnd.memb[j].offset > dt->shared->u.compnd.memb[j + 1].offset) {
                         H5T_cmemb_t tmp = dt->shared->u.compnd.memb[j];
-			dt->shared->u.compnd.memb[j] = dt->shared->u.compnd.memb[j + 1];
-			dt->shared->u.compnd.memb[j + 1] = tmp;
-			if(map) {
-			    int x = map[j];
-
-			    map[j] = map[j + 1];
-			    map[j + 1] = x;
-			} /* end if */
-			swapped = TRUE;
-		    } /* end if */
-		} /* end for */
-	    } /* end for */
+                        dt->shared->u.compnd.memb[j] = dt->shared->u.compnd.memb[j + 1];
+                        dt->shared->u.compnd.memb[j + 1] = tmp;
+                        if(map) {
+                            int x = map[j];
+
+                            map[j] = map[j + 1];
+                            map[j + 1] = x;
+                        } /* end if */
+                        swapped = TRUE;
+                    } /* end if */
+                } /* end for */
+            } /* end for */
 #ifndef NDEBUG
-	    /* I never trust a sort :-) -RPM */
-	    for(i = 0; i < (nmembs - 1); i++)
-		HDassert(dt->shared->u.compnd.memb[i].offset < dt->shared->u.compnd.memb[i + 1].offset);
+            /* I never trust a sort :-) -RPM */
+            for(i = 0; i < (nmembs - 1); i++)
+                HDassert(dt->shared->u.compnd.memb[i].offset < dt->shared->u.compnd.memb[i + 1].offset);
 #endif
-	} /* end if */
+        } /* end if */
     } else if(H5T_ENUM == dt->shared->type) {
-	if(H5T_SORT_VALUE != dt->shared->u.enumer.sorted) {
-	    dt->shared->u.enumer.sorted = H5T_SORT_VALUE;
-	    nmembs = dt->shared->u.enumer.nmembs;
-	    size = dt->shared->size;
-	    HDassert(size <= sizeof(tbuf));
-	    for(i = (nmembs - 1), swapped = TRUE; i > 0 && swapped; --i) {
-		for(j = 0, swapped = FALSE; j < i; j++) {
-		    if(HDmemcmp(dt->shared->u.enumer.value + (j * size), dt->shared->u.enumer.value + ((j + 1) * size), size) > 0) {
-			/* Swap names */
-			char *tmp = dt->shared->u.enumer.name[j];
-			dt->shared->u.enumer.name[j] = dt->shared->u.enumer.name[j + 1];
-			dt->shared->u.enumer.name[j + 1] = tmp;
-
-			/* Swap values */
-			HDmemcpy(tbuf, dt->shared->u.enumer.value + (j * size), size);
-			HDmemcpy(dt->shared->u.enumer.value + (j * size),
-				 dt->shared->u.enumer.value + ((j + 1) * size), size);
-			HDmemcpy(dt->shared->u.enumer.value + ((j + 1) * size), tbuf, size);
-
-			/* Swap map */
-			if(map) {
-			    int x = map[j];
-
-			    map[j] = map[j + 1];
-			    map[j + 1] = x;
-			} /* end if */
-
-			swapped = TRUE;
-		    } /* end if */
-		} /* end for */
-	    } /* end for */
+        if(H5T_SORT_VALUE != dt->shared->u.enumer.sorted) {
+            dt->shared->u.enumer.sorted = H5T_SORT_VALUE;
+            nmembs = dt->shared->u.enumer.nmembs;
+            size = dt->shared->size;
+            HDassert(size <= sizeof(tbuf));
+            for(i = (nmembs - 1), swapped = TRUE; i > 0 && swapped; --i) {
+                for(j = 0, swapped = FALSE; j < i; j++) {
+                    if(HDmemcmp(dt->shared->u.enumer.value + (j * size), dt->shared->u.enumer.value + ((j + 1) * size), size) > 0) {
+                        /* Swap names */
+                        char *tmp = dt->shared->u.enumer.name[j];
+                        dt->shared->u.enumer.name[j] = dt->shared->u.enumer.name[j + 1];
+                        dt->shared->u.enumer.name[j + 1] = tmp;
+
+                        /* Swap values */
+                        HDmemcpy(tbuf, dt->shared->u.enumer.value + (j * size), size);
+                        HDmemcpy(dt->shared->u.enumer.value + (j * size),
+                        dt->shared->u.enumer.value + ((j + 1) * size), size);
+                        HDmemcpy(dt->shared->u.enumer.value + ((j + 1) * size), tbuf, size);
+
+                        /* Swap map */
+                        if(map) {
+                            int x = map[j];
+
+                            map[j] = map[j + 1];
+                            map[j + 1] = x;
+                        } /* end if */
+
+                        swapped = TRUE;
+                    } /* end if */
+                } /* end for */
+            } /* end for */
 #ifndef NDEBUG
-	    /* I never trust a sort :-) -RPM */
-	    for(i = 0; i < (nmembs - 1); i++)
-		HDassert(HDmemcmp(dt->shared->u.enumer.value + (i * size), dt->shared->u.enumer.value + ((i + 1) * size), size) < 0);
+            /* I never trust a sort :-) -RPM */
+            for(i = 0; i < (nmembs - 1); i++)
+                HDassert(HDmemcmp(dt->shared->u.enumer.value + (i * size), dt->shared->u.enumer.value + ((i + 1) * size), size) < 0);
 #endif
-	} /* end if */
+        } /* end if */
     } /* end else */
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -407,106 +394,97 @@ H5T__sort_value(const H5T_t *dt, int *map)
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5T__sort_name
+ * Function:    H5T__sort_name
  *
- * Purpose:	Sorts members of a compound or enumeration datatype by their
- *		names. This even works for locked datatypes since it doesn't
- *		change the value of the types.
+ * Purpose:     Sorts members of a compound or enumeration datatype by their
+ *              names. This even works for locked datatypes since it doesn't
+ *              change the value of the types.
  *
- * Return:	Success:	Non-negative
+ * Return:      SUCCEED (can't fail)
  *
- *		Failure:	Negative
- *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, January  4, 1999
  *
- * Modifications:
- *
  *-------------------------------------------------------------------------
  */
 herr_t
 H5T__sort_name(const H5T_t *dt, int *map)
 {
-    unsigned	i, j, nmembs;
-    size_t	size;
-    hbool_t	swapped;
-    uint8_t	tbuf[32];
+    unsigned    i, j, nmembs;
+    size_t      size;
+    hbool_t     swapped;
+    uint8_t     tbuf[32];
 
     FUNC_ENTER_PACKAGE_NOERR
 
     /* Check args */
-    assert(dt);
-    assert(H5T_COMPOUND==dt->shared->type || H5T_ENUM==dt->shared->type);
+    HDassert(dt);
+    HDassert(H5T_COMPOUND == dt->shared->type || H5T_ENUM == dt->shared->type);
 
     /* Use a bubble sort because we can short circuit */
-    if (H5T_COMPOUND==dt->shared->type) {
-	if (H5T_SORT_NAME!=dt->shared->u.compnd.sorted) {
-	    dt->shared->u.compnd.sorted = H5T_SORT_NAME;
-	    nmembs = dt->shared->u.compnd.nmembs;
-	    for (i=nmembs-1, swapped=TRUE; i>0 && swapped; --i) {
-		for (j=0, swapped=FALSE; j<i; j++) {
-		    if (HDstrcmp(dt->shared->u.compnd.memb[j].name,
-				 dt->shared->u.compnd.memb[j+1].name)>0) {
-			H5T_cmemb_t tmp = dt->shared->u.compnd.memb[j];
-			dt->shared->u.compnd.memb[j] = dt->shared->u.compnd.memb[j+1];
-			dt->shared->u.compnd.memb[j+1] = tmp;
-			swapped = TRUE;
-			if (map) {
-			    int x = map[j];
-			    map[j] = map[j+1];
-			    map[j+1] = x;
-			}
-		    }
-		}
-	    }
+    if(H5T_COMPOUND == dt->shared->type) {
+        if(H5T_SORT_NAME != dt->shared->u.compnd.sorted) {
+            dt->shared->u.compnd.sorted = H5T_SORT_NAME;
+            nmembs = dt->shared->u.compnd.nmembs;
+            for(i = nmembs - 1, swapped = TRUE; i > 0 && swapped; --i) {
+                for(j = 0, swapped = FALSE; j < i; j++) {
+                    if(HDstrcmp(dt->shared->u.compnd.memb[j].name, dt->shared->u.compnd.memb[j+1].name) > 0) {
+                        H5T_cmemb_t tmp = dt->shared->u.compnd.memb[j];
+                        dt->shared->u.compnd.memb[j] = dt->shared->u.compnd.memb[j+1];
+                        dt->shared->u.compnd.memb[j+1] = tmp;
+                        swapped = TRUE;
+                        if(map) {
+                            int x = map[j];
+                            map[j] = map[j+1];
+                            map[j+1] = x;
+                        } /* end if */
+                    } /* end if */
+                } /* end for */
+            } /* end for */
 #ifndef NDEBUG
-	    /* I never trust a sort :-) -RPM */
-	    for (i=0; i<nmembs-1; i++) {
-		assert(HDstrcmp(dt->shared->u.compnd.memb[i].name,
-				dt->shared->u.compnd.memb[i+1].name)<0);
-	    }
+            /* I never trust a sort :-) -RPM */
+            for(i = 0; i < nmembs - 1; i++)
+                HDassert(HDstrcmp(dt->shared->u.compnd.memb[i].name, dt->shared->u.compnd.memb[i+1].name) < 0);
 #endif
-	}
-    } else if (H5T_ENUM==dt->shared->type) {
-	if (H5T_SORT_NAME!=dt->shared->u.enumer.sorted) {
-	    dt->shared->u.enumer.sorted = H5T_SORT_NAME;
-	    nmembs = dt->shared->u.enumer.nmembs;
-	    size = dt->shared->size;
-	    assert(size<=sizeof(tbuf));
-	    for (i=nmembs-1, swapped=TRUE; i>0 && swapped; --i) {
-		for (j=0, swapped=FALSE; j<i; j++) {
-		    if (HDstrcmp(dt->shared->u.enumer.name[j],
-				 dt->shared->u.enumer.name[j+1])>0) {
-			/* Swap names */
-			char *tmp = dt->shared->u.enumer.name[j];
-			dt->shared->u.enumer.name[j] = dt->shared->u.enumer.name[j+1];
-			dt->shared->u.enumer.name[j+1] = tmp;
-
-			/* Swap values */
-			HDmemcpy(tbuf, dt->shared->u.enumer.value+j*size, size);
-			HDmemcpy(dt->shared->u.enumer.value+j*size,
-				 dt->shared->u.enumer.value+(j+1)*size, size);
-			HDmemcpy(dt->shared->u.enumer.value+(j+1)*size, tbuf, size);
-
-			/* Swap map */
-			if (map) {
-			    int x = map[j];
-			    map[j] = map[j+1];
-			    map[j+1] = x;
-			}
-
-			swapped = TRUE;
-		    }
-		}
-	    }
+        } /* end if */
+    } else if(H5T_ENUM == dt->shared->type) {
+        if(H5T_SORT_NAME != dt->shared->u.enumer.sorted) {
+            dt->shared->u.enumer.sorted = H5T_SORT_NAME;
+            nmembs = dt->shared->u.enumer.nmembs;
+            size = dt->shared->size;
+            HDassert(size <= sizeof(tbuf));
+            for(i = nmembs - 1, swapped = TRUE; i > 0 && swapped; --i) {
+                for(j = 0, swapped = FALSE; j < i; j++) {
+                    if(HDstrcmp(dt->shared->u.enumer.name[j], dt->shared->u.enumer.name[j+1]) > 0) {
+                        /* Swap names */
+                        char *tmp = dt->shared->u.enumer.name[j];
+                        dt->shared->u.enumer.name[j] = dt->shared->u.enumer.name[j+1];
+                        dt->shared->u.enumer.name[j+1] = tmp;
+
+                        /* Swap values */
+                        HDmemcpy(tbuf, dt->shared->u.enumer.value+j * size, size);
+                        HDmemcpy(dt->shared->u.enumer.value + j * size,
+                        dt->shared->u.enumer.value + (j+1) * size, size);
+                        HDmemcpy(dt->shared->u.enumer.value + (j+1) * size, tbuf, size);
+
+                        /* Swap map */
+                        if(map) {
+                            int x = map[j];
+                            map[j] = map[j+1];
+                            map[j+1] = x;
+                        } /* end if */
+
+                        swapped = TRUE;
+                    } /* end if */
+                } /* end for */
+            }
 #ifndef NDEBUG
-	    /* I never trust a sort :-) -RPM */
-	    for (i=0; i<nmembs-1; i++)
-		assert(HDstrcmp(dt->shared->u.enumer.name[i], dt->shared->u.enumer.name[i+1])<0);
+            /* I never trust a sort :-) -RPM */
+            for(i = 0; i < nmembs - 1; i++)
+                HDassert(HDstrcmp(dt->shared->u.enumer.name[i], dt->shared->u.enumer.name[i+1]) < 0);
 #endif
-	}
-    }
+        } /* end if */
+    } /* end if */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-}
-
+} /* end H5T__sort_name() */
diff --git a/src/H5Tfixed.c b/src/H5Tfixed.c
index 51737eb..23919a3 100644
--- a/src/H5Tfixed.c
+++ b/src/H5Tfixed.c
@@ -133,43 +133,39 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tset_sign
+ * Function:    H5Tset_sign
  *
- * Purpose:	Sets the sign property for an integer.
+ * Purpose:     Sets the sign property for an integer.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
- * Programmer:	Robb Matzke
- *		Wednesday, January  7, 1998
- *
- * Modifications:
- * 	Robb Matzke, 22 Dec 1998
- *	Also works with derived datatypes.
+ * Programmer:  Robb Matzke
+ *              Wednesday, January  7, 1998
  *
  *-------------------------------------------------------------------------
  */
 herr_t
 H5Tset_sign(hid_t type_id, H5T_sign_t sign)
 {
-    H5T_t	*dt = NULL;
-    herr_t      ret_value=SUCCEED;       /* Return value */
+    H5T_t       *dt = NULL;
+    herr_t      ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE2("e", "iTs", type_id, sign);
 
     /* Check args */
-    if (NULL == (dt = H5I_object_verify(type_id,H5I_DATATYPE)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an integer datatype")
-    if (H5T_STATE_TRANSIENT!=dt->shared->state)
-	HGOTO_ERROR(H5E_ARGS, H5E_CANTINIT, FAIL, "datatype is read-only")
-    if (sign < H5T_SGN_NONE || sign >= H5T_NSGN)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "illegal sign type")
-    if (H5T_ENUM==dt->shared->type && dt->shared->u.enumer.nmembs>0)
-	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "operation not allowed after members are defined")
-    while (dt->shared->parent)
+    if(NULL == (dt = H5I_object_verify(type_id,H5I_DATATYPE)))
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an integer datatype")
+    if(H5T_STATE_TRANSIENT != dt->shared->state)
+        HGOTO_ERROR(H5E_ARGS, H5E_CANTINIT, FAIL, "datatype is read-only")
+    if(sign < H5T_SGN_NONE || sign >= H5T_NSGN)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "illegal sign type")
+    if(H5T_ENUM == dt->shared->type && dt->shared->u.enumer.nmembs > 0)
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "operation not allowed after members are defined")
+    while(dt->shared->parent)
         dt = dt->shared->parent; /*defer to parent*/
-    if (H5T_INTEGER!=dt->shared->type)
-	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "operation not defined for datatype class")
+    if(H5T_INTEGER != dt->shared->type)
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "operation not defined for datatype class")
 
     /* Commit */
     dt->shared->u.atomic.u.i.sign = sign;
diff --git a/src/H5Toffset.c b/src/H5Toffset.c
index bea8d2b..2b15aaf 100644
--- a/src/H5Toffset.c
+++ b/src/H5Toffset.c
@@ -18,16 +18,16 @@
  *      the datatype offset for the H5T interface.
  */
 
-#define H5T_PACKAGE		/*suppress error about including H5Tpkg	  */
+#define H5T_PACKAGE     /* suppress error about including H5Tpkg */
 
 /* Interface initialization */
-#define H5_INTERFACE_INIT_FUNC	H5T_init_offset_interface
+#define H5_INTERFACE_INIT_FUNC      H5T_init_offset_interface
 
 
-#include "H5private.h"		/* Generic Functions			*/
-#include "H5Eprivate.h"		/* Error handling		  	*/
-#include "H5Iprivate.h"		/* IDs			  		*/
-#include "H5Tpkg.h"		/* Datatypes				*/
+#include "H5private.h"          /* Generic Functions                        */
+#include "H5Eprivate.h"         /* Error handling                           */
+#include "H5Iprivate.h"         /* IDs                                      */
+#include "H5Tpkg.h"             /* Datatypes                                */
 
 /* Static local functions */
 static herr_t H5T_set_offset(const H5T_t *dt, size_t offset);
@@ -157,68 +157,64 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tset_offset
+ * Function:    H5Tset_offset
  *
- * Purpose:	Sets the bit offset of the first significant bit.  The
- *		signficant bits of an atomic datum can be offset from the
- *		beginning of the memory for that datum by an amount of
- *		padding. The `offset' property specifies the number of bits
- *		of padding that appear to the "right of" the value.  That is,
- *		if we have a 32-bit datum with 16-bits of precision having
- *		the value 0x1122 then it will be layed out in memory as (from
- *		small byte address toward larger byte addresses):
+ * Purpose:     Sets the bit offset of the first significant bit.  The
+ *              signficant bits of an atomic datum can be offset from the
+ *              beginning of the memory for that datum by an amount of
+ *              padding. The `offset' property specifies the number of bits
+ *              of padding that appear to the "right of" the value.  That is,
+ *              if we have a 32-bit datum with 16-bits of precision having
+ *              the value 0x1122 then it will be layed out in memory as (from
+ *              small byte address toward larger byte addresses):
  *
- *		    Big	     Big       Little	Little
- *		    Endian   Endian    Endian	Endian
- *		    offset=0 offset=16 offset=0 offset=16
+ *                     Big         Big            Little        Little
+ *                    Endian      Endian          Endian        Endian
+ *                  offset = 0  offset = 16     offset = 0    offset = 16
  *
- *		0:  [ pad]   [0x11]    [0x22]	[ pad]
- *		1:  [ pad]   [0x22]    [0x11]	[ pad]
- *		2:  [0x11]   [ pad]    [ pad]	[0x22]
- *		3:  [0x22]   [ pad]    [ pad]	[0x11]
+ *                  0:  [ pad]   [0x11]    [0x22]   [ pad]
+ *                  1:  [ pad]   [0x22]    [0x11]   [ pad]
+ *                  2:  [0x11]   [ pad]    [ pad]   [0x22]
+ *                  3:  [0x22]   [ pad]    [ pad]   [0x11]
  *
- *		If the offset is incremented then the total size is
- *		incremented also if necessary to prevent significant bits of
- *		the value from hanging over the edge of the data type.
+ *              If the offset is incremented then the total size is
+ *              incremented also if necessary to prevent significant bits of
+ *              the value from hanging over the edge of the data type.
  *
- *		The offset of an H5T_STRING cannot be set to anything but
- *		zero.
+ *              The offset of an H5T_STRING cannot be set to anything but
+ *              zero.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
- * Programmer:	Robb Matzke
- *		Wednesday, January  7, 1998
- *
- * Modifications:
- * 	Robb Matzke, 22 Dec 1998
- *	Moved real work to a private function.
+ * Programmer:  Robb Matzke
+ *              Wednesday, January  7, 1998
  *
  *-------------------------------------------------------------------------
  */
 herr_t
 H5Tset_offset(hid_t type_id, size_t offset)
 {
-    H5T_t	*dt;
-    herr_t      ret_value=SUCCEED;       /* Return value */
+    H5T_t       *dt;
+    herr_t      ret_value = SUCCEED;        /* Return value */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE2("e", "iz", type_id, offset);
 
     /* Check args */
-    if (NULL == (dt = (H5T_t *)H5I_object_verify(type_id,H5I_DATATYPE)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an atomic data type")
-    if (H5T_STATE_TRANSIENT!=dt->shared->state)
-	HGOTO_ERROR(H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only")
-    if (H5T_STRING == dt->shared->type && offset != 0)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "offset must be zero for this type")
-    if (H5T_ENUM==dt->shared->type && dt->shared->u.enumer.nmembs>0)
-	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "operation not allowed after members are defined")
-    if (H5T_COMPOUND==dt->shared->type || H5T_REFERENCE==dt->shared->type || H5T_OPAQUE==dt->shared->type)
-	HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "operation not defined for this datatype")
+    if(NULL == (dt = (H5T_t *)H5I_object_verify(type_id,H5I_DATATYPE)))
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an atomic data type")
+    if(H5T_STATE_TRANSIENT != dt->shared->state)
+        HGOTO_ERROR(H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only")
+    if(H5T_STRING == dt->shared->type && offset != 0)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "offset must be zero for this type")
+    if(H5T_ENUM == dt->shared->type && dt->shared->u.enumer.nmembs > 0)
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "operation not allowed after members are defined")
+    if(H5T_COMPOUND == dt->shared->type || H5T_REFERENCE == dt->shared->type || H5T_OPAQUE == dt->shared->type)
+        HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "operation not defined for this datatype")
 
     /* Do the real work */
-    if (H5T_set_offset(dt, offset)<0)
-	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to set offset")
+    if (H5T_set_offset(dt, offset) < 0)
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to set offset")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -226,70 +222,66 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5T_set_offset
- *
- * Purpose:	Sets the bit offset of the first significant bit.  The
- *		signficant bits of an atomic datum can be offset from the
- *		beginning of the memory for that datum by an amount of
- *		padding. The `offset' property specifies the number of bits
- *		of padding that appear to the "right of" the value.  That is,
- *		if we have a 32-bit datum with 16-bits of precision having
- *		the value 0x1122 then it will be layed out in memory as (from
- *		small byte address toward larger byte addresses):
+ * Function:    H5T_set_offset
  *
- *		    Big	     Big       Little	Little
- *		    Endian   Endian    Endian	Endian
- *		    offset=0 offset=16 offset=0 offset=16
+ * Purpose:     Sets the bit offset of the first significant bit.  The
+ *              signficant bits of an atomic datum can be offset from the
+ *              beginning of the memory for that datum by an amount of
+ *              padding. The `offset' property specifies the number of bits
+ *              of padding that appear to the "right of" the value.  That is,
+ *              if we have a 32-bit datum with 16-bits of precision having
+ *              the value 0x1122 then it will be layed out in memory as (from
+ *              small byte address toward larger byte addresses):
  *
- *		0:  [ pad]   [0x11]    [0x22]	[ pad]
- *		1:  [ pad]   [0x22]    [0x11]	[ pad]
- *		2:  [0x11]   [ pad]    [ pad]	[0x22]
- *		3:  [0x22]   [ pad]    [ pad]	[0x11]
+ *                     Big         Big            Little        Little
+ *                    Endian      Endian          Endian        Endian
+ *                  offset = 0  offset = 16     offset = 0    offset = 16
  *
- *		If the offset is incremented then the total size is
- *		incremented also if necessary to prevent significant bits of
- *		the value from hanging over the edge of the data type.
+ *                  0:  [ pad]   [0x11]    [0x22]   [ pad]
+ *                  1:  [ pad]   [0x22]    [0x11]   [ pad]
+ *                  2:  [0x11]   [ pad]    [ pad]   [0x22]
+ *                  3:  [0x22]   [ pad]    [ pad]   [0x11]
  *
- *		The offset of an H5T_STRING cannot be set to anything but
- *		zero.
+ *              If the offset is incremented then the total size is
+ *              incremented also if necessary to prevent significant bits of
+ *              the value from hanging over the edge of the data type.
  *
- * Return:	Non-negative on success/Negative on failure
+ *              The offset of an H5T_STRING cannot be set to anything but
+ *              zero.
  *
- * Programmer:	Robb Matzke
- *		Wednesday, January  7, 1998
+ * Return:      SUCCEED/FAIL
  *
- * Modifications:
- * 	Robb Matzke, 22 Dec 1998
- *	Also works for derived data types.
+ * Programmer:  Robb Matzke
+ *              Wednesday, January  7, 1998
  *
  *-------------------------------------------------------------------------
  */
 static herr_t
 H5T_set_offset(const H5T_t *dt, size_t offset)
 {
-    herr_t      ret_value=SUCCEED;       /* Return value */
+    herr_t      ret_value = SUCCEED;        /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Check args */
     assert(dt);
-    assert(H5T_STRING!=dt->shared->type || 0==offset);
-    assert(H5T_REFERENCE!=dt->shared->type);
-    assert(H5T_OPAQUE!=dt->shared->type);
-    assert(H5T_COMPOUND!=dt->shared->type);
-    assert(!(H5T_ENUM==dt->shared->type && 0==dt->shared->u.enumer.nmembs));
+    assert(H5T_STRING != dt->shared->type || 0 == offset);
+    assert(H5T_REFERENCE != dt->shared->type);
+    assert(H5T_OPAQUE != dt->shared->type);
+    assert(H5T_COMPOUND != dt->shared->type);
+    assert(!(H5T_ENUM == dt->shared->type && 0 == dt->shared->u.enumer.nmembs));
 
     if (dt->shared->parent) {
-	if (H5T_set_offset(dt->shared->parent, offset)<0)
-	    HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to set offset for base type")
+        if (H5T_set_offset(dt->shared->parent, offset) < 0)
+            HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "unable to set offset for base type")
 
         /* Adjust size of datatype appropriately */
-        if(dt->shared->type==H5T_ARRAY)
+        if(dt->shared->type == H5T_ARRAY)
             dt->shared->size = dt->shared->parent->shared->size * dt->shared->u.array.nelem;
-        else if(dt->shared->type!=H5T_VLEN)
+        else if(dt->shared->type != H5T_VLEN)
             dt->shared->size = dt->shared->parent->shared->size;
     } else {
-        if (offset+dt->shared->u.atomic.prec > 8*dt->shared->size)
+        if (offset + dt->shared->u.atomic.prec > 8 * dt->shared->size)
             dt->shared->size = (offset + dt->shared->u.atomic.prec + 7) / 8;
         dt->shared->u.atomic.offset = offset;
     }
diff --git a/src/H5Torder.c b/src/H5Torder.c
index 35be454..38ca6c6 100644
--- a/src/H5Torder.c
+++ b/src/H5Torder.c
@@ -249,14 +249,14 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5T_set_order
+ * Function:    H5T_set_order
  *
- * Purpose:	Private function to set the byte order for a datatype.
+ * Purpose:     Private function to set the byte order for a datatype.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
- * Programmer:	Raymond Lu
- *		13 August 2010
+ * Programmer:  Raymond Lu
+ *              13 August 2010
  *
  *-------------------------------------------------------------------------
  */
@@ -268,7 +268,7 @@ H5T_set_order(H5T_t *dtype, H5T_order_t order)
     FUNC_ENTER_NOAPI(FAIL)
 
     if(H5T_ENUM == dtype->shared->type && dtype->shared->u.enumer.nmembs > 0)
-	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTSET, FAIL, "operation not allowed after enum members are defined")
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTSET, FAIL, "operation not allowed after enum members are defined")
 
     /* For derived data type, defer to parent */ 
     while(dtype->shared->parent)
@@ -277,7 +277,7 @@ H5T_set_order(H5T_t *dtype, H5T_order_t order)
     /* Check for setting order on inappropriate datatype */
     if(order == H5T_ORDER_NONE && !(H5T_REFERENCE == dtype->shared->type || 
             H5T_OPAQUE == dtype->shared->type || H5T_IS_FIXED_STRING(dtype->shared)))
-	HGOTO_ERROR(H5E_DATATYPE, H5E_BADVALUE, FAIL, "illegal byte order for type")
+        HGOTO_ERROR(H5E_DATATYPE, H5E_BADVALUE, FAIL, "illegal byte order for type")
 
     /* For atomic data type */
     if(H5T_IS_ATOMIC(dtype->shared))
diff --git a/src/H5Tpad.c b/src/H5Tpad.c
index 88a5e13..511db7d 100644
--- a/src/H5Tpad.c
+++ b/src/H5Tpad.c
@@ -99,43 +99,39 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tset_pad
+ * Function:    H5Tset_pad
  *
- * Purpose:	Sets the LSB and MSB pad types.
+ * Purpose:     Sets the LSB and MSB pad types.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      Non-negative on success/Negative on failure
  *
- * Programmer:	Robb Matzke
- *		Friday, January	 9, 1998
- *
- * Modifications:
- *	Robb Matzke, 22 Dec 1998
- *	Also works with derived data types.
+ * Programmer:  Robb Matzke
+ *              Friday, January 9, 1998
  *
  *-------------------------------------------------------------------------
  */
 herr_t
 H5Tset_pad(hid_t type_id, H5T_pad_t lsb, H5T_pad_t msb)
 {
-    H5T_t *dt = NULL;
-    herr_t      ret_value=SUCCEED;       /* Return value */
+    H5T_t   *dt = NULL;
+    herr_t  ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE3("e", "iTpTp", type_id, lsb, msb);
 
     /* Check args */
-    if (NULL == (dt = H5I_object_verify(type_id,H5I_DATATYPE)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type")
-    if (H5T_STATE_TRANSIENT!=dt->shared->state)
-	HGOTO_ERROR(H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only")
-    if (lsb < H5T_PAD_ZERO || lsb >= H5T_NPAD || msb < H5T_PAD_ZERO || msb >= H5T_NPAD)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid pad type")
-    if (H5T_ENUM==dt->shared->type && dt->shared->u.enumer.nmembs>0)
-	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "operation not allowed after members are defined")
-    while (dt->shared->parent)
+    if(NULL == (dt = H5I_object_verify(type_id,H5I_DATATYPE)))
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type")
+    if(H5T_STATE_TRANSIENT != dt->shared->state)
+        HGOTO_ERROR(H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only")
+    if(lsb < H5T_PAD_ZERO || lsb >= H5T_NPAD || msb < H5T_PAD_ZERO || msb >= H5T_NPAD)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid pad type")
+    if(H5T_ENUM == dt->shared->type && dt->shared->u.enumer.nmembs > 0)
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "operation not allowed after members are defined")
+    while(dt->shared->parent)
         dt = dt->shared->parent; /*defer to parent*/
-    if (!H5T_IS_ATOMIC(dt->shared))
-	HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "operation not defined for specified data type")
+    if(!H5T_IS_ATOMIC(dt->shared))
+        HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "operation not defined for specified data type")
 
     /* Commit */
     dt->shared->u.atomic.lsb_pad = lsb;
@@ -144,4 +140,3 @@ H5Tset_pad(hid_t type_id, H5T_pad_t lsb, H5T_pad_t msb)
 done:
     FUNC_LEAVE_API(ret_value)
 }
-
diff --git a/src/H5Tprecis.c b/src/H5Tprecis.c
index c5ac186..98dc322 100644
--- a/src/H5Tprecis.c
+++ b/src/H5Tprecis.c
@@ -138,60 +138,56 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tset_precision
+ * Function:    H5Tset_precision
  *
- * Purpose:	Sets the precision of a datatype.  The precision is
- *		the number of significant bits which, unless padding is
- *		present, is 8 times larger than the value returned by
- *		H5Tget_size().
+ * Purpose:     Sets the precision of a datatype.  The precision is
+ *              the number of significant bits which, unless padding is
+ *              present, is 8 times larger than the value returned by
+ *              H5Tget_size().
  *
- *		If the precision is increased then the offset is decreased
- *		and then the size is increased to insure that significant
- *		bits do not "hang over" the edge of the datatype.
+ *              If the precision is increased then the offset is decreased
+ *              and then the size is increased to insure that significant
+ *              bits do not "hang over" the edge of the datatype.
  *
- *		The precision property of strings is read-only.
+ *              The precision property of strings is read-only.
  *
- *		When decreasing the precision of a floating point type, set
- *		the locations and sizes of the sign, mantissa, and exponent
- *		fields first.
+ *              When decreasing the precision of a floating point type, set
+ *              the locations and sizes of the sign, mantissa, and exponent
+ *              fields first.
  *
- * Return:	Non-negative on success/Negative on failure
+ * Return:      SUCCEED/FAIL
  *
- * Programmer:	Robb Matzke
- *		Wednesday, January  7, 1998
- *
- * Modifications:
- * 	Robb Matzke, 22 Dec 1998
- *	Moved real work to a private function.
+ * Programmer:  Robb Matzke
+ *              Wednesday, January  7, 1998
  *
  *-------------------------------------------------------------------------
  */
 herr_t
 H5Tset_precision(hid_t type_id, size_t prec)
 {
-    H5T_t	*dt = NULL;
-    herr_t      ret_value=SUCCEED;       /* Return value */
+    H5T_t       *dt = NULL;
+    herr_t      ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE2("e", "iz", type_id, prec);
 
     /* Check args */
     if (NULL == (dt = H5I_object_verify(type_id,H5I_DATATYPE)))
-	HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype")
-    if (H5T_STATE_TRANSIENT!=dt->shared->state)
-	HGOTO_ERROR(H5E_ARGS, H5E_CANTSET, FAIL, "datatype is read-only")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a datatype")
+    if (H5T_STATE_TRANSIENT != dt->shared->state)
+        HGOTO_ERROR(H5E_ARGS, H5E_CANTSET, FAIL, "datatype is read-only")
     if (prec == 0)
-	HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "precision must be positive")
-    if (H5T_ENUM==dt->shared->type && dt->shared->u.enumer.nmembs>0)
-	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTSET, FAIL, "operation not allowed after members are defined")
-    if (H5T_STRING==dt->shared->type)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "precision must be positive")
+    if (H5T_ENUM == dt->shared->type && dt->shared->u.enumer.nmembs>0)
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTSET, FAIL, "operation not allowed after members are defined")
+    if (H5T_STRING == dt->shared->type)
         HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "precision for this type is read-only")
-    if (H5T_COMPOUND==dt->shared->type || H5T_OPAQUE==dt->shared->type)
-	HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "operation not defined for specified datatype")
+    if (H5T_COMPOUND == dt->shared->type || H5T_OPAQUE==dt->shared->type)
+        HGOTO_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, FAIL, "operation not defined for specified datatype")
 
     /* Do the work */
-    if (H5T_set_precision(dt, prec)<0)
-	HGOTO_ERROR(H5E_DATATYPE, H5E_CANTSET, FAIL, "unable to set precision")
+    if (H5T_set_precision(dt, prec) < 0)
+        HGOTO_ERROR(H5E_DATATYPE, H5E_CANTSET, FAIL, "unable to set precision")
 
 done:
     FUNC_LEAVE_API(ret_value)
@@ -199,73 +195,69 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5T_set_precision
+ * Function:    H5T_set_precision
  *
- * Purpose:	Sets the precision of a datatype.  The precision is
- *		the number of significant bits which, unless padding is
- *		present, is 8 times larger than the value returned by
- *		H5Tget_size().
+ * Purpose:     Sets the precision of a datatype.  The precision is
+ *              the number of significant bits which, unless padding is
+ *              present, is 8 times larger than the value returned by
+ *              H5Tget_size().
  *
- *		If the precision is increased then the offset is decreased
- *		and then the size is increased to insure that significant
- *		bits do not "hang over" the edge of the datatype.
+ *              If the precision is increased then the offset is decreased
+ *              and then the size is increased to insure that significant
+ *              bits do not "hang over" the edge of the datatype.
  *
- *		The precision property of strings is read-only.
+ *              The precision property of strings is read-only.
  *
- *		When decreasing the precision of a floating point type, set
- *		the locations and sizes of the sign, mantissa, and exponent
- *		fields first.
+ *              When decreasing the precision of a floating point type, set
+ *              the locations and sizes of the sign, mantissa, and exponent
+ *              fields first.
  *
- * Return:	Non-negative on success/Negative on failure
- *
- * Programmer:	Robb Matzke
- *		Wednesday, January  7, 1998
+ * Return:      Non-negative on success/Negative on failure
  *
- * Modifications:
- * 	Robb Matzke, 22 Dec 1998
- *	Also works for derived datatypes.
+ * Programmer:  Robb Matzke
+ *              Wednesday, January  7, 1998
  *
  *-------------------------------------------------------------------------
  */
 static herr_t
 H5T_set_precision(const H5T_t *dt, size_t prec)
 {
-    size_t	offset, size;
-    herr_t      ret_value=SUCCEED;       /* Return value */
+    size_t      offset, size;
+    herr_t      ret_value = SUCCEED;        /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Check args */
     assert(dt);
-    assert(prec>0);
-    assert(H5T_OPAQUE!=dt->shared->type);
-    assert(H5T_COMPOUND!=dt->shared->type);
-    assert(H5T_STRING!=dt->shared->type);
-    assert(!(H5T_ENUM==dt->shared->type && 0==dt->shared->u.enumer.nmembs));
+    assert(prec > 0);
+    assert(H5T_OPAQUE != dt->shared->type);
+    assert(H5T_COMPOUND != dt->shared->type);
+    assert(H5T_STRING != dt->shared->type);
+    assert(!(H5T_ENUM == dt->shared->type && 0 == dt->shared->u.enumer.nmembs));
 
     if (dt->shared->parent) {
-	if (H5T_set_precision(dt->shared->parent, prec)<0)
-	    HGOTO_ERROR(H5E_DATATYPE, H5E_CANTSET, FAIL, "unable to set precision for base type")
+        if (H5T_set_precision(dt->shared->parent, prec) < 0)
+            HGOTO_ERROR(H5E_DATATYPE, H5E_CANTSET, FAIL, "unable to set precision for base type")
 
         /* Adjust size of datatype appropriately */
-        if(dt->shared->type==H5T_ARRAY)
+        if(dt->shared->type == H5T_ARRAY)
             dt->shared->size = dt->shared->parent->shared->size * dt->shared->u.array.nelem;
-        else if(dt->shared->type!=H5T_VLEN)
+        else if(dt->shared->type != H5T_VLEN)
             dt->shared->size = dt->shared->parent->shared->size;
     } else {
         if (H5T_IS_ATOMIC(dt->shared)) {
-	    /* Adjust the offset and size */
-	    offset = dt->shared->u.atomic.offset;
-	    size = dt->shared->size;
-	    if (prec > 8*size)
+            /* Adjust the offset and size */
+            offset = dt->shared->u.atomic.offset;
+            size = dt->shared->size;
+            if (prec > 8*size)
                 offset = 0;
-	    else if (offset+prec > 8 * size)
+            else if (offset+prec > 8 * size)
                 offset = 8 * size - prec;
-	    if (prec > 8*size)
+            if (prec > 8*size)
                 size = (prec+7) / 8;
 
-	    /* Check that things are still kosher */
-	    switch (dt->shared->type) {
+            /* Check that things are still kosher */
+            switch (dt->shared->type) {
                 case H5T_INTEGER:
                 case H5T_TIME:
                 case H5T_BITFIELD:
@@ -285,13 +277,13 @@ H5T_set_precision(const H5T_t *dt, size_t prec)
                     break;
                 default:
                     HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "operation not defined for datatype class")
-	    } /* end switch */ /*lint !e788 All appropriate cases are covered */
+            } /* end switch */ /*lint !e788 All appropriate cases are covered */
 
-	    /* Commit */
-	    dt->shared->size = size;
+            /* Commit */
+            dt->shared->size = size;
             dt->shared->u.atomic.offset = offset;
             dt->shared->u.atomic.prec = prec;
-	} /* end if */
+        } /* end if */
         else
             HGOTO_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "operation not defined for specified datatype")
     } /* end else */