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

1 files changed, 2324 insertions, 2387 deletions

diff --git a/src/H5T.c b/src/H5T.c
index 3dd6802..c555147 100644
--- a/src/H5T.c
+++ b/src/H5T.c
@@ -11,65 +11,65 @@
 ****************************************************************************/
 
 #ifdef RCSID
-static char RcsId[] = "@(#)$Revision$";
+static char             RcsId[] = "@(#)$Revision$";
 #endif
 
-#define H5T_PACKAGE		/*suppress error about including H5Tpkg	*/
+#define H5T_PACKAGE             /*suppress error about including H5Tpkg   */
 
-#include <H5private.h>		/*generic functions 			*/
-#include <H5Aprivate.h>		/*atom functions 			*/
-#include <H5Eprivate.h>		/*error handling 			*/
-#include <H5Mprivate.h>		/*meta data 				*/
-#include <H5MMprivate.h>	/*memory management			*/
-#include <H5Pprivate.h>		/*data space 				*/
-#include <H5Tpkg.h>		/*data-type functions 			*/
+#include <H5private.h>          /*generic functions                       */
+#include <H5Aprivate.h>         /*atom functions                  */
+#include <H5Eprivate.h>         /*error handling                  */
+#include <H5Mprivate.h>         /*meta data                               */
+#include <H5MMprivate.h>        /*memory management                       */
+#include <H5Pprivate.h>         /*data space                              */
+#include <H5Tpkg.h>             /*data-type functions                     */
 
-#define PABLO_MASK	H5T_mask
+#define PABLO_MASK      H5T_mask
 
-#define H5T_COMPND_INC	64	/*typical max numb of members per struct*/
+#define H5T_COMPND_INC  64      /*typical max numb of members per struct */
 
 /* Interface initialization */
-static intn interface_initialize_g = FALSE;
+static intn             interface_initialize_g = FALSE;
 #define INTERFACE_INIT H5T_init_interface
-static void H5T_term_interface (void);
+static void             H5T_term_interface(void);
 
 /* Predefined types */
-hid_t H5T_NATIVE_CHAR_g		= FAIL;
-hid_t H5T_NATIVE_UCHAR_g	= FAIL;
-hid_t H5T_NATIVE_SHORT_g	= FAIL;
-hid_t H5T_NATIVE_USHORT_g	= FAIL;
-hid_t H5T_NATIVE_INT_g		= FAIL;
-hid_t H5T_NATIVE_UINT_g		= FAIL;
-hid_t H5T_NATIVE_LONG_g		= FAIL;
-hid_t H5T_NATIVE_LLONG_g	= FAIL;
-hid_t H5T_NATIVE_ULLONG_g	= FAIL;
-hid_t H5T_NATIVE_HYPER_g	= FAIL;
-hid_t H5T_NATIVE_UHYPER_g	= FAIL;
-hid_t H5T_NATIVE_INT8_g		= FAIL;
-hid_t H5T_NATIVE_UINT8_g	= FAIL;
-hid_t H5T_NATIVE_INT16_g	= FAIL;
-hid_t H5T_NATIVE_UINT16_g	= FAIL;
-hid_t H5T_NATIVE_INT32_g	= FAIL;
-hid_t H5T_NATIVE_UINT32_g	= FAIL;
-hid_t H5T_NATIVE_INT64_g	= FAIL;
-hid_t H5T_NATIVE_UINT64_g	= FAIL;
-hid_t H5T_NATIVE_ULONG_g	= FAIL;
-hid_t H5T_NATIVE_FLOAT_g	= FAIL;
-hid_t H5T_NATIVE_DOUBLE_g	= FAIL;
-hid_t H5T_NATIVE_TIME_g		= FAIL;
-hid_t H5T_NATIVE_STRING_g	= FAIL;
-hid_t H5T_NATIVE_BITFIELD_g	= FAIL;
-hid_t H5T_NATIVE_OPAQUE_g	= FAIL;
+hid_t                   H5T_NATIVE_CHAR_g = FAIL;
+hid_t                   H5T_NATIVE_UCHAR_g = FAIL;
+hid_t                   H5T_NATIVE_SHORT_g = FAIL;
+hid_t                   H5T_NATIVE_USHORT_g = FAIL;
+hid_t                   H5T_NATIVE_INT_g = FAIL;
+hid_t                   H5T_NATIVE_UINT_g = FAIL;
+hid_t                   H5T_NATIVE_LONG_g = FAIL;
+hid_t                   H5T_NATIVE_LLONG_g = FAIL;
+hid_t                   H5T_NATIVE_ULLONG_g = FAIL;
+hid_t                   H5T_NATIVE_HYPER_g = FAIL;
+hid_t                   H5T_NATIVE_UHYPER_g = FAIL;
+hid_t                   H5T_NATIVE_INT8_g = FAIL;
+hid_t                   H5T_NATIVE_UINT8_g = FAIL;
+hid_t                   H5T_NATIVE_INT16_g = FAIL;
+hid_t                   H5T_NATIVE_UINT16_g = FAIL;
+hid_t                   H5T_NATIVE_INT32_g = FAIL;
+hid_t                   H5T_NATIVE_UINT32_g = FAIL;
+hid_t                   H5T_NATIVE_INT64_g = FAIL;
+hid_t                   H5T_NATIVE_UINT64_g = FAIL;
+hid_t                   H5T_NATIVE_ULONG_g = FAIL;
+hid_t                   H5T_NATIVE_FLOAT_g = FAIL;
+hid_t                   H5T_NATIVE_DOUBLE_g = FAIL;
+hid_t                   H5T_NATIVE_TIME_g = FAIL;
+hid_t                   H5T_NATIVE_STRING_g = FAIL;
+hid_t                   H5T_NATIVE_BITFIELD_g = FAIL;
+hid_t                   H5T_NATIVE_OPAQUE_g = FAIL;
 
 /* The path database */
-static intn		H5T_npath_g	= 0;	/*num paths defined	*/
-static intn		H5T_apath_g	= 0;	/*num slots allocated	*/
-static H5T_path_t	*H5T_path_g	= NULL;	/*path array		*/
+static intn             H5T_npath_g = 0;        /*num paths defined     */
+static intn             H5T_apath_g = 0;        /*num slots allocated   */
+static H5T_path_t      *H5T_path_g = NULL;      /*path array            */
 
 /* The soft conversion function master list */
-static intn		H5T_nsoft_g	= 0;	/*num soft funcs defined*/
-static intn		H5T_asoft_g	= 0;	/*num slots allocated	*/
-static H5T_soft_t	*H5T_soft_g	= NULL;	/*master soft list	*/
+static intn             H5T_nsoft_g = 0;        /*num soft funcs defined */
+static intn             H5T_asoft_g = 0;        /*num slots allocated   */
+static H5T_soft_t      *H5T_soft_g = NULL;      /*master soft list      */
 
 /*--------------------------------------------------------------------------
 NAME
@@ -84,170 +84,163 @@ DESCRIPTION
 
 --------------------------------------------------------------------------*/
 herr_t
-H5T_init_interface (void)
+H5T_init_interface(void)
 {
-   H5T_t	*dt = NULL;
-   herr_t 	ret_value = SUCCEED;
-
-   interface_initialize_g = TRUE;
-   FUNC_ENTER (H5T_init_interface, FAIL);
-
-   /* Initialize the atom group for the file IDs */
-   if ((ret_value=H5Ainit_group (H5_DATATYPE, H5A_DATATYPEID_HASHSIZE,
-				 H5T_RESERVED_ATOMS,
-				 (herr_t (*)(void*))H5T_close))!=FAIL) {
-      ret_value=H5_add_exit (&H5T_term_interface);
-   }
-
-   /*
-    * Initialize pre-defined data types that depend on the architecture.
-    */
-   ret_value = H5T_init ();
-
-   /*
-    * Initialize pre-define data types that can be derived from
-    * architecture-dependent types.
-    */
-
-   /* INT8 */
-   H5T_NATIVE_INT8_g = H5Tcopy (H5T_NATIVE_INT_g);
-   H5Tset_size (H5T_NATIVE_INT8_g, 1);
-   H5Tset_precision (H5T_NATIVE_INT8_g, 8);
-   H5Tlock (H5T_NATIVE_INT8_g);
-   
-   /* UINT8 */
-   H5T_NATIVE_UINT8_g = H5Tcopy (H5T_NATIVE_UINT_g);
-   H5Tset_size (H5T_NATIVE_UINT8_g, 1);
-   H5Tset_precision (H5T_NATIVE_UINT8_g, 8);
-   H5Tlock (H5T_NATIVE_UINT8_g);
-
-   /* INT16 */
-   H5T_NATIVE_INT16_g = H5Tcopy (H5T_NATIVE_INT_g);
-   H5Tset_size (H5T_NATIVE_INT16_g, 2);
-   H5Tset_precision (H5T_NATIVE_INT16_g, 16);
-   H5Tlock (H5T_NATIVE_INT16_g);
-   
-   /* UINT16 */
-   H5T_NATIVE_UINT16_g = H5Tcopy (H5T_NATIVE_UINT_g);
-   H5Tset_size (H5T_NATIVE_UINT16_g, 2);
-   H5Tset_precision (H5T_NATIVE_UINT16_g, 16);
-   H5Tlock (H5T_NATIVE_UINT16_g);
-   
-   /* INT32 */
-   H5T_NATIVE_INT32_g = H5Tcopy (H5T_NATIVE_INT_g);
-   H5Tset_size (H5T_NATIVE_INT32_g, 4);
-   H5Tset_precision (H5T_NATIVE_INT32_g, 32);
-   H5Tlock (H5T_NATIVE_INT32_g);
-   
-   /* UINT32 */
-   H5T_NATIVE_UINT32_g = H5Tcopy (H5T_NATIVE_UINT_g);
-   H5Tset_size (H5T_NATIVE_UINT32_g, 4);
-   H5Tset_precision (H5T_NATIVE_UINT32_g, 32);
-   H5Tlock (H5T_NATIVE_UINT32_g);
-   
-   /* INT64 */
-   H5T_NATIVE_INT64_g = H5Tcopy (H5T_NATIVE_INT_g);
-   H5Tset_size (H5T_NATIVE_INT64_g, 8);
-   H5Tset_precision (H5T_NATIVE_INT64_g, 64);
-   H5Tlock (H5T_NATIVE_INT64_g);
-   
-   /* UINT64 */
-   H5T_NATIVE_UINT64_g = H5Tcopy (H5T_NATIVE_UINT_g);
-   H5Tset_size (H5T_NATIVE_UINT64_g, 8);
-   H5Tset_precision (H5T_NATIVE_UINT64_g, 64);
-   H5Tlock (H5T_NATIVE_UINT64_g);
-   
-
-   /*
-    * Initialize pre-defined data types that don't depend on architecture.
-    */
-
-   /* TIME */
-   dt = H5MM_xcalloc (1, sizeof(H5T_t));
-   dt->locked = TRUE;
-   dt->type = H5T_TIME;
-   dt->size = 1;
-   dt->u.atomic.order = H5Tget_order (H5T_NATIVE_INT_g);
-   dt->u.atomic.offset = 0;
-   dt->u.atomic.prec = 8*dt->size;
-   dt->u.atomic.lsb_pad = H5T_PAD_ZERO;
-   dt->u.atomic.msb_pad = H5T_PAD_ZERO;
-   if ((H5T_NATIVE_TIME_g = H5Aregister_atom (H5_DATATYPE, dt))<0) {
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL,
-		     "can't initialize H5T layer");
-   }
-
-   /* STRING */
-   dt = H5MM_xcalloc (1, sizeof(H5T_t));
-   dt->locked = TRUE;
-   dt->type = H5T_STRING;
-   dt->size = 1;
-   dt->u.atomic.order = H5T_ORDER_NONE;
-   dt->u.atomic.offset = 0;
-   dt->u.atomic.prec = 8*dt->size;
-   dt->u.atomic.lsb_pad = H5T_PAD_ZERO;
-   dt->u.atomic.msb_pad = H5T_PAD_ZERO;
-   dt->u.atomic.u.s.cset = H5T_CSET_ASCII;
-   dt->u.atomic.u.s.pad = H5T_STR_NULL;
-   if ((H5T_NATIVE_STRING_g = H5Aregister_atom (H5_DATATYPE, dt))<0) {
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL,
-		     "can't initialize H5T layer");
-   }
-
-   /* BITFIELD */
-   dt = H5MM_xcalloc (1, sizeof(H5T_t));
-   dt->locked = TRUE;
-   dt->type = H5T_BITFIELD;
-   dt->size = 1;
-   dt->u.atomic.order = H5Tget_order (H5T_NATIVE_INT_g);
-   dt->u.atomic.offset = 0;
-   dt->u.atomic.prec = 8*dt->size;
-   dt->u.atomic.lsb_pad = H5T_PAD_ZERO;
-   dt->u.atomic.msb_pad = H5T_PAD_ZERO;
-   if ((H5T_NATIVE_BITFIELD_g = H5Aregister_atom (H5_DATATYPE, dt))<0) {
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL,
-		     "unable to initialize H5T layer");
-   }
-
-   /* OPAQUE */
-   dt = H5MM_xcalloc (1, sizeof(H5T_t));
-   dt->locked = TRUE;
-   dt->type = H5T_OPAQUE;
-   dt->size = 1;
-   dt->u.atomic.order = H5T_ORDER_NONE;
-   dt->u.atomic.offset = 0;
-   dt->u.atomic.prec = 8*dt->size;
-   dt->u.atomic.lsb_pad = H5T_PAD_ZERO;
-   dt->u.atomic.msb_pad = H5T_PAD_ZERO;
-   if ((H5T_NATIVE_OPAQUE_g = H5Aregister_atom (H5_DATATYPE, dt))<0) {
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL,
-		     "unable to initialize H5T layer");
-   }
-
-   /*
-    * Define aliases.
-    */
-   H5T_NATIVE_HYPER_g = H5Tcopy (H5T_NATIVE_LLONG_g);
-   H5Tlock (H5T_NATIVE_HYPER_g);
-
-   H5T_NATIVE_UHYPER_g = H5Tcopy (H5T_NATIVE_ULLONG_g);
-   H5Tlock (H5T_NATIVE_UHYPER_g);
-
-   /*
-    * Register conversion functions beginning with the most general and
-    * ending with the most specific.
-    */
-   
-   if (H5Tregister_soft (H5T_INTEGER, H5T_INTEGER, H5T_conv_order)<0) {
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL,
-		     "unable to register conversion function");
-   }
-   if (H5Tregister_soft (H5T_FLOAT, H5T_FLOAT, H5T_conv_order)<0) {
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL,
-		     "unable to register conversion function");
-   }
-   
-   FUNC_LEAVE (ret_value);
+    H5T_t                  *dt = NULL;
+    herr_t                  ret_value = SUCCEED;
+
+    interface_initialize_g = TRUE;
+    FUNC_ENTER(H5T_init_interface, FAIL);
+
+    /* Initialize the atom group for the file IDs */
+    if ((ret_value = H5Ainit_group(H5_DATATYPE, H5A_DATATYPEID_HASHSIZE,
+                                   H5T_RESERVED_ATOMS,
+                                 (herr_t (*)(void *)) H5T_close)) != FAIL) {
+        ret_value = H5_add_exit(&H5T_term_interface);
+    }
+    /*
+     * Initialize pre-defined data types that depend on the architecture.
+     */
+    ret_value = H5T_init();
+
+    /*
+     * Initialize pre-define data types that can be derived from
+     * architecture-dependent types.
+     */
+
+    /* INT8 */
+    H5T_NATIVE_INT8_g = H5Tcopy(H5T_NATIVE_INT_g);
+    H5Tset_size(H5T_NATIVE_INT8_g, 1);
+    H5Tset_precision(H5T_NATIVE_INT8_g, 8);
+    H5Tlock(H5T_NATIVE_INT8_g);
+
+    /* UINT8 */
+    H5T_NATIVE_UINT8_g = H5Tcopy(H5T_NATIVE_UINT_g);
+    H5Tset_size(H5T_NATIVE_UINT8_g, 1);
+    H5Tset_precision(H5T_NATIVE_UINT8_g, 8);
+    H5Tlock(H5T_NATIVE_UINT8_g);
+
+    /* INT16 */
+    H5T_NATIVE_INT16_g = H5Tcopy(H5T_NATIVE_INT_g);
+    H5Tset_size(H5T_NATIVE_INT16_g, 2);
+    H5Tset_precision(H5T_NATIVE_INT16_g, 16);
+    H5Tlock(H5T_NATIVE_INT16_g);
+
+    /* UINT16 */
+    H5T_NATIVE_UINT16_g = H5Tcopy(H5T_NATIVE_UINT_g);
+    H5Tset_size(H5T_NATIVE_UINT16_g, 2);
+    H5Tset_precision(H5T_NATIVE_UINT16_g, 16);
+    H5Tlock(H5T_NATIVE_UINT16_g);
+
+    /* INT32 */
+    H5T_NATIVE_INT32_g = H5Tcopy(H5T_NATIVE_INT_g);
+    H5Tset_size(H5T_NATIVE_INT32_g, 4);
+    H5Tset_precision(H5T_NATIVE_INT32_g, 32);
+    H5Tlock(H5T_NATIVE_INT32_g);
+
+    /* UINT32 */
+    H5T_NATIVE_UINT32_g = H5Tcopy(H5T_NATIVE_UINT_g);
+    H5Tset_size(H5T_NATIVE_UINT32_g, 4);
+    H5Tset_precision(H5T_NATIVE_UINT32_g, 32);
+    H5Tlock(H5T_NATIVE_UINT32_g);
+
+    /* INT64 */
+    H5T_NATIVE_INT64_g = H5Tcopy(H5T_NATIVE_INT_g);
+    H5Tset_size(H5T_NATIVE_INT64_g, 8);
+    H5Tset_precision(H5T_NATIVE_INT64_g, 64);
+    H5Tlock(H5T_NATIVE_INT64_g);
+
+    /* UINT64 */
+    H5T_NATIVE_UINT64_g = H5Tcopy(H5T_NATIVE_UINT_g);
+    H5Tset_size(H5T_NATIVE_UINT64_g, 8);
+    H5Tset_precision(H5T_NATIVE_UINT64_g, 64);
+    H5Tlock(H5T_NATIVE_UINT64_g);
+
+    /*
+     * Initialize pre-defined data types that don't depend on architecture.
+     */
+
+    /* TIME */
+    dt = H5MM_xcalloc(1, sizeof(H5T_t));
+    dt->locked = TRUE;
+    dt->type = H5T_TIME;
+    dt->size = 1;
+    dt->u.atomic.order = H5Tget_order(H5T_NATIVE_INT_g);
+    dt->u.atomic.offset = 0;
+    dt->u.atomic.prec = 8 * dt->size;
+    dt->u.atomic.lsb_pad = H5T_PAD_ZERO;
+    dt->u.atomic.msb_pad = H5T_PAD_ZERO;
+    if ((H5T_NATIVE_TIME_g = H5Aregister_atom(H5_DATATYPE, dt)) < 0) {
+        HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL,
+                      "can't initialize H5T layer");
+    }
+    /* STRING */
+    dt = H5MM_xcalloc(1, sizeof(H5T_t));
+    dt->locked = TRUE;
+    dt->type = H5T_STRING;
+    dt->size = 1;
+    dt->u.atomic.order = H5T_ORDER_NONE;
+    dt->u.atomic.offset = 0;
+    dt->u.atomic.prec = 8 * dt->size;
+    dt->u.atomic.lsb_pad = H5T_PAD_ZERO;
+    dt->u.atomic.msb_pad = H5T_PAD_ZERO;
+    dt->u.atomic.u.s.cset = H5T_CSET_ASCII;
+    dt->u.atomic.u.s.pad = H5T_STR_NULL;
+    if ((H5T_NATIVE_STRING_g = H5Aregister_atom(H5_DATATYPE, dt)) < 0) {
+        HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL,
+                      "can't initialize H5T layer");
+    }
+    /* BITFIELD */
+    dt = H5MM_xcalloc(1, sizeof(H5T_t));
+    dt->locked = TRUE;
+    dt->type = H5T_BITFIELD;
+    dt->size = 1;
+    dt->u.atomic.order = H5Tget_order(H5T_NATIVE_INT_g);
+    dt->u.atomic.offset = 0;
+    dt->u.atomic.prec = 8 * dt->size;
+    dt->u.atomic.lsb_pad = H5T_PAD_ZERO;
+    dt->u.atomic.msb_pad = H5T_PAD_ZERO;
+    if ((H5T_NATIVE_BITFIELD_g = H5Aregister_atom(H5_DATATYPE, dt)) < 0) {
+        HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL,
+                      "unable to initialize H5T layer");
+    }
+    /* OPAQUE */
+    dt = H5MM_xcalloc(1, sizeof(H5T_t));
+    dt->locked = TRUE;
+    dt->type = H5T_OPAQUE;
+    dt->size = 1;
+    dt->u.atomic.order = H5T_ORDER_NONE;
+    dt->u.atomic.offset = 0;
+    dt->u.atomic.prec = 8 * dt->size;
+    dt->u.atomic.lsb_pad = H5T_PAD_ZERO;
+    dt->u.atomic.msb_pad = H5T_PAD_ZERO;
+    if ((H5T_NATIVE_OPAQUE_g = H5Aregister_atom(H5_DATATYPE, dt)) < 0) {
+        HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL,
+                      "unable to initialize H5T layer");
+    }
+    /*
+     * Define aliases.
+     */
+    H5T_NATIVE_HYPER_g = H5Tcopy(H5T_NATIVE_LLONG_g);
+    H5Tlock(H5T_NATIVE_HYPER_g);
+
+    H5T_NATIVE_UHYPER_g = H5Tcopy(H5T_NATIVE_ULLONG_g);
+    H5Tlock(H5T_NATIVE_UHYPER_g);
+
+    /*
+     * Register conversion functions beginning with the most general and
+     * ending with the most specific.
+     */
+
+    if (H5Tregister_soft(H5T_INTEGER, H5T_INTEGER, H5T_conv_order) < 0) {
+        HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL,
+                      "unable to register conversion function");
+    }
+    if (H5Tregister_soft(H5T_FLOAT, H5T_FLOAT, H5T_conv_order) < 0) {
+        HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL,
+                      "unable to register conversion function");
+    }
+    FUNC_LEAVE(ret_value);
 }
 
 /*--------------------------------------------------------------------------
@@ -268,28 +261,27 @@ H5T_init_interface (void)
  REVISION LOG
 --------------------------------------------------------------------------*/
 static void
-H5T_term_interface (void)
+H5T_term_interface(void)
 {
-   H5Adestroy_group (H5_DATATYPE);
+    H5Adestroy_group(H5_DATATYPE);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tcreate
+ * Function:    H5Tcreate
  *
- * Purpose:	Create a new type and initialize it to reasonable values.
- *		The type is a member of type class TYPE and is SIZE bytes.
+ * Purpose:     Create a new type and initialize it to reasonable values.
+ *              The type is a member of type class TYPE and is SIZE bytes.
  *
- * Return:	Success:	A new type identifier.
+ * Return:      Success:        A new type identifier.
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
  * Errors:
- *		ARGS      BADVALUE      Invalid size. 
- *		DATATYPE  CANTINIT      Can't create type. 
- *		DATATYPE  CANTREGISTER  Can't register data type atom. 
+ *              ARGS      BADVALUE      Invalid size. 
+ *              DATATYPE  CANTINIT      Can't create type. 
+ *              DATATYPE  CANTREGISTER  Can't register data type atom. 
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Friday, December  5, 1997
  *
  * Modifications:
@@ -297,45 +289,41 @@ H5T_term_interface (void)
  *-------------------------------------------------------------------------
  */
 hid_t
-H5Tcreate (H5T_class_t type, size_t size)
+H5Tcreate(H5T_class_t type, size_t size)
 {
-   H5T_t	*dt = NULL;
-   hid_t	ret_value = FAIL;
-   
-   FUNC_ENTER (H5Tcreate, FAIL);
-
-   /* check args */
-   if (size<=0) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "invalid size");
-   }
-   
-   /* create the type */
-   if (NULL==(dt=H5T_create (type, size))) {
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL, "can't create type");
-   }
-   
-   /* Make it an atom */
-   if ((ret_value=H5Aregister_atom (H5_DATATYPE, dt))<0) {
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTREGISTER, FAIL,
-		     "can't register data type atom");
-   }
-
-   FUNC_LEAVE (ret_value);
+    H5T_t                  *dt = NULL;
+    hid_t                   ret_value = FAIL;
+
+    FUNC_ENTER(H5Tcreate, FAIL);
+
+    /* check args */
+    if (size <= 0) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid size");
+    }
+    /* create the type */
+    if (NULL == (dt = H5T_create(type, size))) {
+        HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "can't create type");
+    }
+    /* Make it an atom */
+    if ((ret_value = H5Aregister_atom(H5_DATATYPE, dt)) < 0) {
+        HRETURN_ERROR(H5E_DATATYPE, H5E_CANTREGISTER, FAIL,
+                      "can't register data type atom");
+    }
+    FUNC_LEAVE(ret_value);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tcopy
+ * Function:    H5Tcopy
  *
- * Purpose:	Copies a data type.  The resulting data type is not locked.
- *		The data type should be closed when no longer needed by
- *		calling H5Tclose().
+ * Purpose:     Copies a data type.  The resulting data type is not locked.
+ *              The data type should be closed when no longer needed by
+ *              calling H5Tclose().
  *
- * Return:	Success:	The ID of a new data type.
+ * Return:      Success:        The ID of a new data type.
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Tuesday, December  9, 1997
  *
  * Modifications:
@@ -343,47 +331,43 @@ H5Tcreate (H5T_class_t type, size_t size)
  *-------------------------------------------------------------------------
  */
 hid_t
-H5Tcopy (hid_t type_id)
+H5Tcopy(hid_t type_id)
 {
-   H5T_t	*dt = NULL;
-   H5T_t	*new_dt = NULL;
-   hid_t	ret_value = FAIL;
-   
-   FUNC_ENTER (H5Tcopy, FAIL);
-   H5ECLEAR;
-
-   /* check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
-   }
-
-   /* copy */
-   if (NULL==(new_dt = H5T_copy (dt))) {
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL, "can't copy");
-   }
-
-   /* atomize result */
-   if ((ret_value=H5Aregister_atom (H5_DATATYPE, new_dt))<0) {
-      H5T_close (new_dt);
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTREGISTER, FAIL,
-		     "can't register data type atom");
-   }
-
-   FUNC_LEAVE (ret_value);
+    H5T_t                  *dt = NULL;
+    H5T_t                  *new_dt = NULL;
+    hid_t                   ret_value = FAIL;
+
+    FUNC_ENTER(H5Tcopy, FAIL);
+    H5ECLEAR;
+
+    /* check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id))) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+    }
+    /* copy */
+    if (NULL == (new_dt = H5T_copy(dt))) {
+        HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL, "can't copy");
+    }
+    /* atomize result */
+    if ((ret_value = H5Aregister_atom(H5_DATATYPE, new_dt)) < 0) {
+        H5T_close(new_dt);
+        HRETURN_ERROR(H5E_DATATYPE, H5E_CANTREGISTER, FAIL,
+                      "can't register data type atom");
+    }
+    FUNC_LEAVE(ret_value);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tclose
+ * Function:    H5Tclose
  *
- * Purpose:	Frees a data type and all associated memory.
+ * Purpose:     Frees a data type and all associated memory.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Tuesday, December  9, 1997
  *
  * Modifications:
@@ -391,43 +375,40 @@ H5Tcopy (hid_t type_id)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Tclose (hid_t type_id)
+H5Tclose(hid_t type_id)
 {
-   H5T_t	*dt = NULL;
-   
-   FUNC_ENTER (H5Tclose, FAIL);
-   H5ECLEAR;
-
-   /* check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
-   }
-   if (dt->locked) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "predefined data type");
-   }
-
-   /* When the reference count reaches zero the resources are freed */
-   if (H5A_dec_ref (type_id)<0) {
-      HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL, "problem freeing id");
-   }
-
-   FUNC_LEAVE (SUCCEED);
+    H5T_t                  *dt = NULL;
+
+    FUNC_ENTER(H5Tclose, FAIL);
+    H5ECLEAR;
+
+    /* check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id))) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+    }
+    if (dt->locked) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "predefined data type");
+    }
+    /* When the reference count reaches zero the resources are freed */
+    if (H5A_dec_ref(type_id) < 0) {
+        HRETURN_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "problem freeing id");
+    }
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tequal
+ * Function:    H5Tequal
  *
- * Purpose:	Determines if two data types are equal.
+ * Purpose:     Determines if two data types are equal.
  *
- * Return:	Success:	TRUE if equal, FALSE if unequal
+ * Return:      Success:        TRUE if equal, FALSE if unequal
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
  * Errors:
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, December 10, 1997
  *
  * Modifications:
@@ -435,43 +416,41 @@ H5Tclose (hid_t type_id)
  *-------------------------------------------------------------------------
  */
 hbool_t
-H5Tequal (hid_t type1_id, hid_t type2_id)
+H5Tequal(hid_t type1_id, hid_t type2_id)
 {
-   const H5T_t	*dt1 = NULL;
-   const H5T_t	*dt2 = NULL;
-   hbool_t	ret_value = FAIL;
-   
-   FUNC_ENTER (H5Tequal, FAIL);
-
-   /* check args */
-   if (H5_DATATYPE!=H5Aatom_group (type1_id) ||
-       NULL==(dt1=H5Aatom_object (type1_id)) ||
-       H5_DATATYPE!=H5Aatom_group (type2_id) ||
-       NULL==(dt2=H5Aatom_object (type2_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
-   }
-
-   ret_value = (0==H5T_cmp (dt1, dt2));
-
-   FUNC_LEAVE (ret_value);
+    const H5T_t            *dt1 = NULL;
+    const H5T_t            *dt2 = NULL;
+    hbool_t                 ret_value = FAIL;
+
+    FUNC_ENTER(H5Tequal, FAIL);
+
+    /* check args */
+    if (H5_DATATYPE != H5Aatom_group(type1_id) ||
+        NULL == (dt1 = H5Aatom_object(type1_id)) ||
+        H5_DATATYPE != H5Aatom_group(type2_id) ||
+        NULL == (dt2 = H5Aatom_object(type2_id))) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+    }
+    ret_value = (0 == H5T_cmp(dt1, dt2));
+
+    FUNC_LEAVE(ret_value);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tlock
+ * Function:    H5Tlock
  *
- * Purpose:	Locks a type, making it read only and non-destructable.  This
- *		is normally done by the library for predefined data types so
- *		the application doesn't inadvertently change or delete a
- *		predefined type.
+ * Purpose:     Locks a type, making it read only and non-destructable.  This
+ *              is normally done by the library for predefined data types so
+ *              the application doesn't inadvertently change or delete a
+ *              predefined type.
  *
- * 		Once a data type is locked it can never be unlocked.
+ *              Once a data type is locked it can never be unlocked.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Friday, January  9, 1998
  *
  * Modifications:
@@ -479,34 +458,32 @@ H5Tequal (hid_t type1_id, hid_t type2_id)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Tlock (hid_t type_id)
+H5Tlock(hid_t type_id)
 {
-   H5T_t	*dt = NULL;
-   
-   FUNC_ENTER (H5Tlock, FAIL);
+    H5T_t                  *dt = NULL;
 
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
-   }
+    FUNC_ENTER(H5Tlock, FAIL);
 
-   dt->locked = TRUE;
-   FUNC_LEAVE (SUCCEED);
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id))) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+    }
+    dt->locked = TRUE;
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tget_class
+ * Function:    H5Tget_class
  *
- * Purpose:	Returns the data type class identifier for data type TYPE_ID.
+ * Purpose:     Returns the data type class identifier for data type TYPE_ID.
  *
- * Return:	Success:	One of the non-negative data type class
- *				constants.
+ * Return:      Success:        One of the non-negative data type class
+ *                              constants.
  *
- *		Failure:	H5T_NO_CLASS (-1, same as FAIL)
+ *              Failure:        H5T_NO_CLASS (-1, same as FAIL)
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, December  8, 1997
  *
  * Modifications:
@@ -514,35 +491,33 @@ H5Tlock (hid_t type_id)
  *-------------------------------------------------------------------------
  */
 H5T_class_t
-H5Tget_class (hid_t type_id)
+H5Tget_class(hid_t type_id)
 {
-   H5T_t	*dt = NULL;
-   
-   FUNC_ENTER (H5Tget_class, H5T_NO_CLASS);
-   H5ECLEAR;
+    H5T_t                  *dt = NULL;
 
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, H5T_NO_CLASS, "not a data type");
-   }
+    FUNC_ENTER(H5Tget_class, H5T_NO_CLASS);
+    H5ECLEAR;
 
-   FUNC_LEAVE (dt->type);
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id))) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, H5T_NO_CLASS, "not a data type");
+    }
+    FUNC_LEAVE(dt->type);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tget_size
+ * Function:    H5Tget_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
- *				data type is the size of an instance of that
- *				data type.
+ * Return:      Success:        Size of the data type in bytes.  The size of
+ *                              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
+ * Programmer:  Robb Matzke
  *              Monday, December  8, 1997
  *
  * Modifications:
@@ -550,49 +525,47 @@ H5Tget_class (hid_t type_id)
  *-------------------------------------------------------------------------
  */
 size_t
-H5Tget_size (hid_t type_id)
+H5Tget_size(hid_t type_id)
 {
-   H5T_t	*dt = NULL;
-   size_t	size;
-   
-   FUNC_ENTER (H5Tget_size, 0);
-   H5ECLEAR;
+    H5T_t                  *dt = NULL;
+    size_t                  size;
 
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, 0, "not a data type");
-   }
+    FUNC_ENTER(H5Tget_size, 0);
+    H5ECLEAR;
 
-   /* size */
-   size = H5T_get_size (dt);
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id))) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, 0, "not a data type");
+    }
+    /* size */
+    size = H5T_get_size(dt);
 
-   FUNC_LEAVE (size);
+    FUNC_LEAVE(size);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tset_size
+ * Function:    H5Tset_size
  *
- * Purpose:	Sets the total size in bytes for an atomic data type (this
- *		operation is not permitted on compound 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 an atomic data type (this
+ *              operation is not permitted on compound 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.
+ *              All data types have a positive size.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
@@ -600,95 +573,96 @@ H5Tget_size (hid_t type_id)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Tset_size (hid_t type_id, size_t size)
+H5Tset_size(hid_t type_id, size_t size)
 {
-   H5T_t	*dt = NULL;
-   size_t	prec, offset;
-   
-   FUNC_ENTER (H5Tset_size, FAIL);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       !H5T_is_atomic (dt)) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not an atomic data type");
-   }
-   if (dt->locked) {
-      HRETURN_ERROR (H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
-   }
-   if (size<=0) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "size must be positive");
-   }
-
-   offset = dt->u.atomic.offset;
-   prec = dt->u.atomic.prec;
-   
-   /* Decrement the offset and precision if necessary */
-   if (prec > 8*size) offset = 0;
-   else if (offset + prec > 8*size) offset = 8*size - prec;
-   if (prec > 8*size) prec = 8*size;
-
-   /* Make sure that other values are still okay */
-   switch (dt->type) {
-   case H5T_INTEGER:
-   case H5T_TIME:
-   case H5T_BITFIELD:
-      /* nothing to check */
-      break;
-      
-   case H5T_STRING:
-      prec = 8*size;
-      offset = 0;
-      break;
-
-   case H5T_FLOAT:
-      /*
-       * The sign, mantissa, and exponent fields should be adjusted first
-       * when decreasing the size of a floating point type.
-       */
-      if (dt->u.atomic.u.f.sign >= prec ||
-	  dt->u.atomic.u.f.epos + dt->u.atomic.u.f.esize > prec ||
-	  dt->u.atomic.u.f.mpos + dt->u.atomic.u.f.msize > prec) {
-	 HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
-			"adjust sign, mantissa, and exponent fields first");
-      }
-      break;
-
-   case H5T_OPAQUE:
-      /*
-       * The significant bits of an opaque type are not allowed to change
-       * implicitly.
-       */
-      if (prec != dt->u.atomic.prec) {
-	 HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
-			"unable to change precision of an opaque type");
-      }
-      break;
-
-   default:
-      assert ("not implemented yet" && 0);
-   }
-
-   /* Commit */
-   dt->size = size;
-   dt->u.atomic.offset = offset;
-   dt->u.atomic.prec = prec;
-
-   FUNC_LEAVE (SUCCEED);
+    H5T_t                  *dt = NULL;
+    size_t                  prec, offset;
+
+    FUNC_ENTER(H5Tset_size, FAIL);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        !H5T_is_atomic(dt)) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an atomic data type");
+    }
+    if (dt->locked) {
+        HRETURN_ERROR(H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
+    }
+    if (size <= 0) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "size must be positive");
+    }
+    offset = dt->u.atomic.offset;
+    prec = dt->u.atomic.prec;
+
+    /* Decrement the offset and precision if necessary */
+    if (prec > 8 * size)
+        offset = 0;
+    else if (offset + prec > 8 * size)
+        offset = 8 * size - prec;
+    if (prec > 8 * size)
+        prec = 8 * size;
+
+    /* Make sure that other values are still okay */
+    switch (dt->type) {
+    case H5T_INTEGER:
+    case H5T_TIME:
+    case H5T_BITFIELD:
+        /* nothing to check */
+        break;
+
+    case H5T_STRING:
+        prec = 8 * size;
+        offset = 0;
+        break;
+
+    case H5T_FLOAT:
+        /*
+         * The sign, mantissa, and exponent fields should be adjusted first
+         * when decreasing the size of a floating point type.
+         */
+        if (dt->u.atomic.u.f.sign >= prec ||
+            dt->u.atomic.u.f.epos + dt->u.atomic.u.f.esize > prec ||
+            dt->u.atomic.u.f.mpos + dt->u.atomic.u.f.msize > prec) {
+            HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
+                        "adjust sign, mantissa, and exponent fields first");
+        }
+        break;
+
+    case H5T_OPAQUE:
+        /*
+         * The significant bits of an opaque type are not allowed to change
+         * implicitly.
+         */
+        if (prec != dt->u.atomic.prec) {
+            HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
+                          "unable to change precision of an opaque type");
+        }
+        break;
+
+    default:
+        assert("not implemented yet" && 0);
+    }
+
+    /* Commit */
+    dt->size = size;
+    dt->u.atomic.offset = offset;
+    dt->u.atomic.prec = prec;
+
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tget_order
+ * Function:    H5Tget_order
  *
- * Purpose:	Returns the byte order of an atomic data type.
+ * Purpose:     Returns the byte order of an atomic data type.
  *
- * Return:	Success:	A byte order constant
+ * Return:      Success:        A byte order constant
  *
- *		Failure:	H5T_ORDER_ERROR (-1, same as FAIL)
+ *              Failure:        H5T_ORDER_ERROR (-1, same as FAIL)
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
@@ -696,39 +670,37 @@ H5Tset_size (hid_t type_id, size_t size)
  *-------------------------------------------------------------------------
  */
 H5T_order_t
-H5Tget_order (hid_t type_id)
+H5Tget_order(hid_t type_id)
 {
-   H5T_t	*dt = NULL;
-   H5T_order_t	order;
-   
-   FUNC_ENTER (H5Tget_order, H5T_ORDER_ERROR);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       !H5T_is_atomic (dt)) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, H5T_ORDER_ERROR,
-		     "not an atomic data type");
-   }
-
-   /* order */
-   order = dt->u.atomic.order;
-
-   FUNC_LEAVE (order);
+    H5T_t                  *dt = NULL;
+    H5T_order_t             order;
+
+    FUNC_ENTER(H5Tget_order, H5T_ORDER_ERROR);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        !H5T_is_atomic(dt)) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, H5T_ORDER_ERROR,
+                      "not an atomic data type");
+    }
+    /* order */
+    order = dt->u.atomic.order;
+
+    FUNC_LEAVE(order);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tset_order
+ * Function:    H5Tset_order
  *
- * Purpose:	Sets the byte order for an atomic data type.
+ * Purpose:     Sets the byte order for an atomic data type.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
@@ -736,46 +708,44 @@ H5Tget_order (hid_t type_id)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Tset_order (hid_t type_id, H5T_order_t order)
+H5Tset_order(hid_t type_id, H5T_order_t order)
 {
-   H5T_t	*dt = NULL;
-
-   FUNC_ENTER (H5Tset_order, FAIL);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       !H5T_is_atomic (dt)) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not an atomic data type");
-   }
-   if (dt->locked) {
-      HRETURN_ERROR (H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
-   }
-   if (order<0 || order>H5T_ORDER_NONE) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "illegal byte order");
-   }
-   
-   /* order */
-   dt->u.atomic.order = order;
-   FUNC_LEAVE (SUCCEED);
+    H5T_t                  *dt = NULL;
+
+    FUNC_ENTER(H5Tset_order, FAIL);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        !H5T_is_atomic(dt)) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an atomic data type");
+    }
+    if (dt->locked) {
+        HRETURN_ERROR(H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
+    }
+    if (order < 0 || order > H5T_ORDER_NONE) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "illegal byte order");
+    }
+    /* order */
+    dt->u.atomic.order = order;
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tget_precision
+ * Function:    H5Tget_precision
  *
- * Purpose:	Gets the precision of an atomic data type.  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:     Gets the precision of an atomic data type.  The precision is
+ *              the number of significant bits which, unless padding is
+ *              present, is 8 times larger than the value returned by
+ *              H5Tget_size().
  *
- * Return:	Success:	Number of significant bits
+ * Return:      Success:        Number of significant bits
  *
- *		Failure:	0 (all atomic types have at least one
- *				significant bit)
+ *              Failure:        0 (all atomic types have at least one
+ *                              significant bit)
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
@@ -783,52 +753,50 @@ H5Tset_order (hid_t type_id, H5T_order_t order)
  *-------------------------------------------------------------------------
  */
 size_t
-H5Tget_precision (hid_t type_id)
+H5Tget_precision(hid_t type_id)
 {
-   H5T_t	*dt = NULL;
-   size_t	prec;
-   
-   FUNC_ENTER (H5Tget_precision, 0);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       !H5T_is_atomic (dt)) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, 0, "not an atomic data type");
-   }
-
-   /* precision */
-   prec = dt->u.atomic.prec;
-
-   FUNC_LEAVE (prec);
+    H5T_t                  *dt = NULL;
+    size_t                  prec;
+
+    FUNC_ENTER(H5Tget_precision, 0);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        !H5T_is_atomic(dt)) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, 0, "not an atomic data type");
+    }
+    /* precision */
+    prec = dt->u.atomic.prec;
+
+    FUNC_LEAVE(prec);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tset_precision
+ * Function:    H5Tset_precision
  *
- * Purpose:	Sets the precision of an atomic data type.  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 an atomic data type.  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 data type.
+ *              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 data type.
  *
- *		Changing the precision of an H5T_STRING automatically changes
- *		the size as well.  The precision must be a multiple of 8.
+ *              Changing the precision of an H5T_STRING automatically changes
+ *              the size as well.  The precision must be a multiple of 8.
  *
- *		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:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
@@ -836,105 +804,106 @@ H5Tget_precision (hid_t type_id)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Tset_precision (hid_t type_id, size_t prec)
+H5Tset_precision(hid_t type_id, size_t prec)
 {
-   H5T_t	*dt = NULL;
-   size_t	offset, size;
-
-   FUNC_ENTER (H5Tset_prec, FAIL);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       !H5T_is_atomic (dt)) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not an atomic data type");
-   }
-   if (dt->locked) {
-      HRETURN_ERROR (H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
-   }
-   if (prec<=0) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
-		     "precision must be positive");
-   }
-
-   /* Adjust the offset and size */
-   offset = dt->u.atomic.offset;
-   size = dt->size;
-   if (prec > 8*size) offset = 0;
-   else if (offset + prec > 8*size) offset = 8*size - prec;
-   if (prec > 8*size) size = (prec+7)/8;
-
-   /* Check that things are still kosher */
-   switch (dt->type) {
-   case H5T_INTEGER:
-   case H5T_TIME:
-   case H5T_BITFIELD:
-   case H5T_OPAQUE:
-      /* nothing to check */
-      break;
-      
-   case H5T_STRING:
-      if (prec % 8) {
-	 HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
-			"precision for this type must be a multiple of 8");
-      }
-      offset = 0;
-      size = prec / 8;
-      break;
-
-   case H5T_FLOAT:
-      /*
-       * The sign, mantissa, and exponent fields should be adjusted first
-       * when decreasing the precision of a floating point type.
-       */
-      if (dt->u.atomic.u.f.sign >= prec ||
-	  dt->u.atomic.u.f.epos + dt->u.atomic.u.f.esize > prec ||
-	  dt->u.atomic.u.f.mpos + dt->u.atomic.u.f.msize > prec) {
-	 HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
-			"adjust sign, mantissa, and exponent fields first");
-      }
-      break;
-
-   default:
-      assert ("not implemented yet" && 0);
-   }
-   
-   /* Commit */
-   dt->size = size;
-   dt->u.atomic.offset = offset;
-   dt->u.atomic.prec = prec;
-   
-   FUNC_LEAVE (SUCCEED);
+    H5T_t                  *dt = NULL;
+    size_t                  offset, size;
+
+    FUNC_ENTER(H5Tset_prec, FAIL);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        !H5T_is_atomic(dt)) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an atomic data type");
+    }
+    if (dt->locked) {
+        HRETURN_ERROR(H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
+    }
+    if (prec <= 0) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
+                      "precision must be positive");
+    }
+    /* Adjust the offset and size */
+    offset = dt->u.atomic.offset;
+    size = dt->size;
+    if (prec > 8 * size)
+        offset = 0;
+    else if (offset + prec > 8 * size)
+        offset = 8 * size - prec;
+    if (prec > 8 * size)
+        size = (prec + 7) / 8;
+
+    /* Check that things are still kosher */
+    switch (dt->type) {
+    case H5T_INTEGER:
+    case H5T_TIME:
+    case H5T_BITFIELD:
+    case H5T_OPAQUE:
+        /* nothing to check */
+        break;
+
+    case H5T_STRING:
+        if (prec % 8) {
+            HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
+                          "precision for this type must be a multiple of 8");
+        }
+        offset = 0;
+        size = prec / 8;
+        break;
+
+    case H5T_FLOAT:
+        /*
+         * The sign, mantissa, and exponent fields should be adjusted first
+         * when decreasing the precision of a floating point type.
+         */
+        if (dt->u.atomic.u.f.sign >= prec ||
+            dt->u.atomic.u.f.epos + dt->u.atomic.u.f.esize > prec ||
+            dt->u.atomic.u.f.mpos + dt->u.atomic.u.f.msize > prec) {
+            HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
+                        "adjust sign, mantissa, and exponent fields first");
+        }
+        break;
+
+    default:
+        assert("not implemented yet" && 0);
+    }
+
+    /* Commit */
+    dt->size = size;
+    dt->u.atomic.offset = offset;
+    dt->u.atomic.prec = prec;
+
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tget_offset
+ * Function:    H5Tget_offset
  *
- * Purpose:	Retrieves 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:     Retrieves 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]
  *
- * Return:	Success:	The offset
+ * Return:      Success:        The offset
  *
- *		Failure:	0
+ *              Failure:        0
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
@@ -942,61 +911,59 @@ H5Tset_precision (hid_t type_id, size_t prec)
  *-------------------------------------------------------------------------
  */
 size_t
-H5Tget_offset (hid_t type_id)
+H5Tget_offset(hid_t type_id)
 {
-   H5T_t	*dt = NULL;
-   size_t	offset;
-   
-   FUNC_ENTER (H5Tget_offset, 0);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       !H5T_is_atomic (dt)) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, 0, "not an atomic data type");
-   }
-
-   /* offset */
-   offset = dt->u.atomic.offset;
-
-   FUNC_LEAVE (offset);
+    H5T_t                  *dt = NULL;
+    size_t                  offset;
+
+    FUNC_ENTER(H5Tget_offset, 0);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        !H5T_is_atomic(dt)) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, 0, "not an atomic data type");
+    }
+    /* offset */
+    offset = dt->u.atomic.offset;
+
+    FUNC_LEAVE(offset);
 }
-
 
 /*-------------------------------------------------------------------------
- * 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:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
@@ -1004,51 +971,48 @@ H5Tget_offset (hid_t type_id)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Tset_offset (hid_t type_id, size_t offset)
+H5Tset_offset(hid_t type_id, size_t offset)
 {
-   H5T_t	*dt = NULL;
-
-   FUNC_ENTER (H5Tset_offset, FAIL);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       !H5T_is_atomic (dt)) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not an atomic data type");
-   }
-   if (dt->locked) {
-      HRETURN_ERROR (H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
-   }
-   if (H5T_STRING==dt->type && offset!=0) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
-		     "offset must be zero for this type");
-   }
-
-   /* Adjust the size */
-   if (offset + dt->u.atomic.prec > 8*dt->size) {
-      dt->size = (offset + dt->u.atomic.prec + 7) / 8;
-   }
-
-   /* Commit */
-   dt->u.atomic.offset = offset;
-   
-   FUNC_LEAVE (SUCCEED);
+    H5T_t                  *dt = NULL;
+
+    FUNC_ENTER(H5Tset_offset, FAIL);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        !H5T_is_atomic(dt)) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an atomic data type");
+    }
+    if (dt->locked) {
+        HRETURN_ERROR(H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
+    }
+    if (H5T_STRING == dt->type && offset != 0) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
+                      "offset must be zero for this type");
+    }
+    /* Adjust the size */
+    if (offset + dt->u.atomic.prec > 8 * dt->size) {
+        dt->size = (offset + dt->u.atomic.prec + 7) / 8;
+    }
+    /* Commit */
+    dt->u.atomic.offset = offset;
+
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tget_pad
+ * Function:    H5Tget_pad
  *
- * Purpose:	Gets the least significant pad type and the most significant
- *		pad type and returns their values through the LSB and MSB
- *		arguments, either of which may be the null pointer.
+ * Purpose:     Gets the least significant pad type and the most significant
+ *              pad type and returns their values through the LSB and MSB
+ *              arguments, either of which may be the null pointer.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Friday, January  9, 1998
  *
  * Modifications:
@@ -1056,38 +1020,38 @@ H5Tset_offset (hid_t type_id, size_t offset)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Tget_pad (hid_t type_id, H5T_pad_t *lsb/*out*/, H5T_pad_t *msb/*out*/)
+H5Tget_pad(hid_t type_id, H5T_pad_t *lsb /*out */ , H5T_pad_t *msb /*out */ )
 {
-   H5T_t	*dt = NULL;
-
-   FUNC_ENTER (H5Tget_pad, FAIL);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       !H5T_is_atomic (dt)) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not an atomic data type");
-   }
-
-   /* Get values */
-   if (lsb) *lsb = dt->u.atomic.lsb_pad;
-   if (msb) *msb = dt->u.atomic.msb_pad;
-
-   FUNC_LEAVE (SUCCEED);
+    H5T_t                  *dt = NULL;
+
+    FUNC_ENTER(H5Tget_pad, FAIL);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        !H5T_is_atomic(dt)) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an atomic data type");
+    }
+    /* Get values */
+    if (lsb)
+        *lsb = dt->u.atomic.lsb_pad;
+    if (msb)
+        *msb = dt->u.atomic.msb_pad;
+
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tset_pad
+ * Function:    H5Tset_pad
  *
- * Purpose:	Sets the LSB and MSB pad types.
+ * Purpose:     Sets the LSB and MSB pad types.
  *
- * Return:	Success:	
+ * Return:      Success:        
  *
- *		Failure:	
+ *              Failure:        
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Friday, January  9, 1998
  *
  * Modifications:
@@ -1095,43 +1059,41 @@ H5Tget_pad (hid_t type_id, H5T_pad_t *lsb/*out*/, H5T_pad_t *msb/*out*/)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Tset_pad (hid_t type_id, H5T_pad_t lsb, H5T_pad_t msb)
+H5Tset_pad(hid_t type_id, H5T_pad_t lsb, H5T_pad_t msb)
 {
-   H5T_t	*dt = NULL;
-
-   FUNC_ENTER (H5Tset_pad, FAIL);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       !H5T_is_atomic (dt)) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not an atomic data type");
-   }
-   if (dt->locked) {
-      HRETURN_ERROR (H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
-   }
-   if (lsb<0 || lsb>=H5T_NPAD || msb<0 || msb>=H5T_NPAD) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "invalid pad type");
-   }
-
-   dt->u.atomic.lsb_pad = lsb;
-   dt->u.atomic.msb_pad = msb;
-
-   FUNC_LEAVE (SUCCEED);
+    H5T_t                  *dt = NULL;
+
+    FUNC_ENTER(H5Tset_pad, FAIL);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        !H5T_is_atomic(dt)) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an atomic data type");
+    }
+    if (dt->locked) {
+        HRETURN_ERROR(H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
+    }
+    if (lsb < 0 || lsb >= H5T_NPAD || msb < 0 || msb >= H5T_NPAD) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid pad type");
+    }
+    dt->u.atomic.lsb_pad = lsb;
+    dt->u.atomic.msb_pad = msb;
+
+    FUNC_LEAVE(SUCCEED);
 }
-   
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tget_sign
+ * Function:    H5Tget_sign
  *
- * Purpose:	Retrieves the sign type for an integer type.
+ * Purpose:     Retrieves the sign type for an integer type.
  *
- * Return:	Success:	The sign type.
+ * Return:      Success:        The sign type.
  *
- *		Failure:	H5T_SGN_ERROR (-1, same as FAIL)
+ *              Failure:        H5T_SGN_ERROR (-1, same as FAIL)
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
@@ -1139,39 +1101,37 @@ H5Tset_pad (hid_t type_id, H5T_pad_t lsb, H5T_pad_t msb)
  *-------------------------------------------------------------------------
  */
 H5T_sign_t
-H5Tget_sign (hid_t type_id)
+H5Tget_sign(hid_t type_id)
 {
-   H5T_t	*dt = NULL;
-   H5T_sign_t	sign;
-   
-   FUNC_ENTER (H5Tget_sign, H5T_SGN_ERROR);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       H5T_INTEGER!=dt->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, H5T_SGN_ERROR,
-		     "not an integer data type");
-   }
-
-   /* sign */
-   sign = dt->u.atomic.u.i.sign;
-
-   FUNC_LEAVE (sign);
+    H5T_t                  *dt = NULL;
+    H5T_sign_t              sign;
+
+    FUNC_ENTER(H5Tget_sign, H5T_SGN_ERROR);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        H5T_INTEGER != dt->type) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, H5T_SGN_ERROR,
+                      "not an integer data type");
+    }
+    /* sign */
+    sign = dt->u.atomic.u.i.sign;
+
+    FUNC_LEAVE(sign);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tset_sign
+ * Function:    H5Tset_sign
  *
- * Purpose:	Sets the sign property for an integer.
+ * Purpose:     Sets the sign property for an integer.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
@@ -1179,48 +1139,46 @@ H5Tget_sign (hid_t type_id)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Tset_sign (hid_t type_id, H5T_sign_t sign)
+H5Tset_sign(hid_t type_id, H5T_sign_t sign)
 {
-   H5T_t	*dt = NULL;
-
-   FUNC_ENTER (H5Tset_sign, FAIL);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       H5T_INTEGER!=dt->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not an integer data type");
-   }
-   if (dt->locked) {
-      HRETURN_ERROR (H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
-   }
-   if (sign<0 || sign>=H5T_NSGN) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "illegal sign type");
-   }
-   
-   /* sign */
-   dt->u.atomic.u.i.sign = sign;
-   FUNC_LEAVE (SUCCEED);
+    H5T_t                  *dt = NULL;
+
+    FUNC_ENTER(H5Tset_sign, FAIL);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        H5T_INTEGER != dt->type) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not an integer data type");
+    }
+    if (dt->locked) {
+        HRETURN_ERROR(H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
+    }
+    if (sign < 0 || sign >= H5T_NSGN) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "illegal sign type");
+    }
+    /* sign */
+    dt->u.atomic.u.i.sign = sign;
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tget_fields
+ * Function:    H5Tget_fields
  *
- * Purpose:	Returns information about the locations of the various bit
- *		fields of a floating point data type.  The field positions
- *		are bit positions in the significant region of the data type.
- *		Bits are numbered with the least significant bit number zero.
+ * Purpose:     Returns information about the locations of the various bit
+ *              fields of a floating point data type.  The field positions
+ *              are bit positions in the significant region of the data type.
+ *              Bits are numbered with the least significant bit number zero.
  *
- * 		Any (or even all) of the arguments can be null pointers.
+ *              Any (or even all) of the arguments can be null pointers.
  *
- * Return:	Success:	SUCCEED, field locations and sizes are
- *				returned through the arguments.
+ * Return:      Success:        SUCCEED, field locations and sizes are
+ *                              returned through the arguments.
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
@@ -1228,50 +1186,53 @@ H5Tset_sign (hid_t type_id, H5T_sign_t sign)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Tget_fields (hid_t type_id, size_t *spos/*out*/,
-	       size_t *epos/*out*/, size_t *esize/*out*/,
-	       size_t *mpos/*out*/, size_t *msize/*out*/)
+H5Tget_fields(hid_t type_id, size_t *spos /*out */ ,
+              size_t *epos /*out */ , size_t *esize /*out */ ,
+              size_t *mpos /*out */ , size_t *msize /*out */ )
 {
-   H5T_t	*dt = NULL;
-
-   FUNC_ENTER (H5Tget_fields, FAIL);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       H5T_FLOAT!=dt->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL,
-		     "not a floating-point data type");
-   }
-
-   /* Get values */
-   if (spos) *spos = dt->u.atomic.u.f.sign;
-   if (epos) *epos = dt->u.atomic.u.f.epos;
-   if (esize) *esize = dt->u.atomic.u.f.esize;
-   if (mpos) *mpos = dt->u.atomic.u.f.mpos;
-   if (msize) *msize = dt->u.atomic.u.f.msize;
-
-   FUNC_LEAVE (SUCCEED);
+    H5T_t                  *dt = NULL;
+
+    FUNC_ENTER(H5Tget_fields, FAIL);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        H5T_FLOAT != dt->type) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL,
+                      "not a floating-point data type");
+    }
+    /* Get values */
+    if (spos)
+        *spos = dt->u.atomic.u.f.sign;
+    if (epos)
+        *epos = dt->u.atomic.u.f.epos;
+    if (esize)
+        *esize = dt->u.atomic.u.f.esize;
+    if (mpos)
+        *mpos = dt->u.atomic.u.f.mpos;
+    if (msize)
+        *msize = dt->u.atomic.u.f.msize;
+
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tset_fields
+ * Function:    H5Tset_fields
  *
- * Purpose:	Sets the locations and sizes of the various floating point
- *		bit fields.  The field positions are bit positions in the
- *		significant region of the data type.  Bits are numbered with
- *		the least significant bit number zero.
+ * Purpose:     Sets the locations and sizes of the various floating point
+ *              bit fields.  The field positions are bit positions in the
+ *              significant region of the data type.  Bits are numbered with
+ *              the least significant bit number zero.
  *
- *		Fields are not allowed to extend beyond the number of bits of
- *		precision, nor are they allowed to overlap with one another.
- *		
- * Return:	Success:	SUCCEED
+ *              Fields are not allowed to extend beyond the number of bits of
+ *              precision, nor are they allowed to overlap with one another.
+ *              
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
@@ -1279,73 +1240,70 @@ H5Tget_fields (hid_t type_id, size_t *spos/*out*/,
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Tset_fields (hid_t type_id, size_t spos, size_t epos, size_t esize,
-	       size_t mpos, size_t msize)
+H5Tset_fields(hid_t type_id, size_t spos, size_t epos, size_t esize,
+              size_t mpos, size_t msize)
 {
-   H5T_t	*dt = NULL;
-
-   FUNC_ENTER (H5Tset_fields, FAIL);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       H5T_FLOAT!=dt->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL,
-		     "not a floating-point data type");
-   }
-   if (dt->locked) {
-      HRETURN_ERROR (H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
-   }
-   if (epos<0 || epos+esize>dt->u.atomic.prec) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
-		     "exponent bit field size/location is invalid");
-   }
-   if (mpos<0 || mpos+msize>dt->u.atomic.prec) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
-		     "mantissa bit field size/location is invalid");
-   }
-   if (spos<0 || spos>=dt->u.atomic.prec) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
-		     "sign location is not valid");
-   }
-
-   /* Check for overlap */
-   if (spos>=epos && spos<epos+esize) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
-		     "sign bit appears within exponent field");
-   }
-   if (spos>=mpos && spos<mpos+msize) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
-		     "sign bit appears within mantissa field");
-   }
-   if ((mpos<epos && mpos+msize>epos) ||
-       (epos<mpos && epos+esize>mpos)) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
-		     "exponent and mantissa fields overlap");
-   }
-
-   /* Commit */
-   dt->u.atomic.u.f.sign = spos;
-   dt->u.atomic.u.f.epos = epos;
-   dt->u.atomic.u.f.mpos = mpos;
-   dt->u.atomic.u.f.esize = esize;
-   dt->u.atomic.u.f.msize = msize;
-
-   FUNC_LEAVE (SUCCEED);
+    H5T_t                  *dt = NULL;
+
+    FUNC_ENTER(H5Tset_fields, FAIL);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        H5T_FLOAT != dt->type) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL,
+                      "not a floating-point data type");
+    }
+    if (dt->locked) {
+        HRETURN_ERROR(H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
+    }
+    if (epos < 0 || epos + esize > dt->u.atomic.prec) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
+                      "exponent bit field size/location is invalid");
+    }
+    if (mpos < 0 || mpos + msize > dt->u.atomic.prec) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
+                      "mantissa bit field size/location is invalid");
+    }
+    if (spos < 0 || spos >= dt->u.atomic.prec) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
+                      "sign location is not valid");
+    }
+    /* Check for overlap */
+    if (spos >= epos && spos < epos + esize) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
+                      "sign bit appears within exponent field");
+    }
+    if (spos >= mpos && spos < mpos + msize) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
+                      "sign bit appears within mantissa field");
+    }
+    if ((mpos < epos && mpos + msize > epos) ||
+        (epos < mpos && epos + esize > mpos)) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
+                      "exponent and mantissa fields overlap");
+    }
+    /* Commit */
+    dt->u.atomic.u.f.sign = spos;
+    dt->u.atomic.u.f.epos = epos;
+    dt->u.atomic.u.f.mpos = mpos;
+    dt->u.atomic.u.f.esize = esize;
+    dt->u.atomic.u.f.msize = msize;
+
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tget_ebias
+ * Function:    H5Tget_ebias
  *
- * Purpose:	Retrieves the exponent bias of a floating-point type.
+ * Purpose:     Retrieves the exponent bias of a floating-point type.
  *
- * Return:	Success:	The bias
+ * Return:      Success:        The bias
  *
- *		Failure:	0
+ *              Failure:        0
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
@@ -1353,39 +1311,37 @@ H5Tset_fields (hid_t type_id, size_t spos, size_t epos, size_t esize,
  *-------------------------------------------------------------------------
  */
 size_t
-H5Tget_ebias (hid_t type_id)
+H5Tget_ebias(hid_t type_id)
 {
-   H5T_t	*dt = NULL;
-   size_t	ebias;
-
-   FUNC_ENTER (H5Tget_ebias, 0);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       H5T_FLOAT!=dt->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, 0,
-		     "not a floating-point data type");
-   }
-
-   /* bias */
-   ebias = dt->u.atomic.u.f.ebias;
-
-   FUNC_LEAVE (ebias);
+    H5T_t                  *dt = NULL;
+    size_t                  ebias;
+
+    FUNC_ENTER(H5Tget_ebias, 0);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        H5T_FLOAT != dt->type) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, 0,
+                      "not a floating-point data type");
+    }
+    /* bias */
+    ebias = dt->u.atomic.u.f.ebias;
+
+    FUNC_LEAVE(ebias);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tset_ebias
+ * Function:    H5Tset_ebias
  *
- * Purpose:	Sets the exponent bias of a floating-point type.
+ * Purpose:     Sets the exponent bias of a floating-point type.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
@@ -1393,41 +1349,39 @@ H5Tget_ebias (hid_t type_id)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Tset_ebias (hid_t type_id, size_t ebias)
+H5Tset_ebias(hid_t type_id, size_t ebias)
 {
-   H5T_t	*dt = NULL;
-   
-   FUNC_ENTER (H5Tset_ebias, FAIL);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       H5T_FLOAT!=dt->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL,
-		     "not a floating-point data type");
-   }
-   if (dt->locked) {
-      HRETURN_ERROR (H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
-   }
-
-   dt->u.atomic.u.f.ebias = ebias;
-
-   FUNC_LEAVE (SUCCEED);
+    H5T_t                  *dt = NULL;
+
+    FUNC_ENTER(H5Tset_ebias, FAIL);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        H5T_FLOAT != dt->type) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL,
+                      "not a floating-point data type");
+    }
+    if (dt->locked) {
+        HRETURN_ERROR(H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
+    }
+    dt->u.atomic.u.f.ebias = ebias;
+
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tget_norm
+ * Function:    H5Tget_norm
  *
- * Purpose:	Returns the mantisssa normalization of a floating-point data
- *		type.
+ * Purpose:     Returns the mantisssa normalization of a floating-point data
+ *              type.
  *
- * Return:	Success:	Normalization ID
+ * Return:      Success:        Normalization ID
  *
- *		Failure:	H5T_NORM_ERROR (-1, same as FAIL)
+ *              Failure:        H5T_NORM_ERROR (-1, same as FAIL)
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
@@ -1435,40 +1389,38 @@ H5Tset_ebias (hid_t type_id, size_t ebias)
  *-------------------------------------------------------------------------
  */
 H5T_norm_t
-H5Tget_norm (hid_t type_id)
+H5Tget_norm(hid_t type_id)
 {
-   H5T_t	*dt = NULL;
-   H5T_norm_t	norm;
-   
-   FUNC_ENTER (H5Tget_norm, H5T_NORM_ERROR);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       H5T_FLOAT!=dt->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, H5T_NORM_ERROR,
-		     "not a floating-point data type");
-   }
-
-   /* norm */
-   norm = dt->u.atomic.u.f.norm;
-
-   FUNC_LEAVE (norm);
+    H5T_t                  *dt = NULL;
+    H5T_norm_t              norm;
+
+    FUNC_ENTER(H5Tget_norm, H5T_NORM_ERROR);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        H5T_FLOAT != dt->type) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, H5T_NORM_ERROR,
+                      "not a floating-point data type");
+    }
+    /* norm */
+    norm = dt->u.atomic.u.f.norm;
+
+    FUNC_LEAVE(norm);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tset_norm
+ * Function:    H5Tset_norm
  *
- * Purpose:	Sets the mantissa normalization method for a floating point
- *		data type.
+ * Purpose:     Sets the mantissa normalization method for a floating point
+ *              data type.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
@@ -1476,46 +1428,44 @@ H5Tget_norm (hid_t type_id)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Tset_norm (hid_t type_id, H5T_norm_t norm)
+H5Tset_norm(hid_t type_id, H5T_norm_t norm)
 {
-   H5T_t	*dt = NULL;
-
-   FUNC_ENTER (H5Tset_norm, FAIL);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       H5T_FLOAT!=dt->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL,
-		     "not a floating-point data type");
-   }
-   if (dt->locked) {
-      HRETURN_ERROR (H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
-   }
-   if (norm<0 || norm>H5T_NORM_NONE) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "illegal normalization");
-   }
-   
-   /* norm */
-   dt->u.atomic.u.f.norm = norm;
-   FUNC_LEAVE (SUCCEED);
+    H5T_t                  *dt = NULL;
+
+    FUNC_ENTER(H5Tset_norm, FAIL);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        H5T_FLOAT != dt->type) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL,
+                      "not a floating-point data type");
+    }
+    if (dt->locked) {
+        HRETURN_ERROR(H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
+    }
+    if (norm < 0 || norm > H5T_NORM_NONE) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "illegal normalization");
+    }
+    /* norm */
+    dt->u.atomic.u.f.norm = norm;
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tget_inpad
+ * Function:    H5Tget_inpad
  *
- * Purpose:	If any internal bits of a floating point type are unused
- *		(that is, those significant bits which are not part of the
- *		sign, exponent, or mantissa) then they will be filled
- *		according to the value of this property.
+ * Purpose:     If any internal bits of a floating point type are unused
+ *              (that is, those significant bits which are not part of the
+ *              sign, exponent, or mantissa) then they will be filled
+ *              according to the value of this property.
  *
- * Return:	Success:	The internal padding type.
+ * Return:      Success:        The internal padding type.
  *
- *		Failure:	H5T_PAD_ERROR (-1, same as FAIL)
+ *              Failure:        H5T_PAD_ERROR (-1, same as FAIL)
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Friday, January  9, 1998
  *
  * Modifications:
@@ -1523,42 +1473,40 @@ H5Tset_norm (hid_t type_id, H5T_norm_t norm)
  *-------------------------------------------------------------------------
  */
 H5T_pad_t
-H5Tget_inpad (hid_t type_id)
+H5Tget_inpad(hid_t type_id)
 {
-   H5T_t	*dt = NULL;
-   H5T_pad_t	pad;
-   
-   FUNC_ENTER (H5Tget_inpad, H5T_PAD_ERROR);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       H5T_FLOAT!=dt->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, H5T_PAD_ERROR,
-		     "not a floating-point data type");
-   }
-
-   /* pad */
-   pad = dt->u.atomic.u.f.pad;
-
-   FUNC_LEAVE (pad);
+    H5T_t                  *dt = NULL;
+    H5T_pad_t               pad;
+
+    FUNC_ENTER(H5Tget_inpad, H5T_PAD_ERROR);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        H5T_FLOAT != dt->type) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, H5T_PAD_ERROR,
+                      "not a floating-point data type");
+    }
+    /* pad */
+    pad = dt->u.atomic.u.f.pad;
+
+    FUNC_LEAVE(pad);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tset_inpad
+ * Function:    H5Tset_inpad
  *
- * Purpose:	If any internal bits of a floating point type are unused
- *		(that is, those significant bits which are not part of the
- *		sign, exponent, or mantissa) then they will be filled
- *		according to the value of this property.
+ * Purpose:     If any internal bits of a floating point type are unused
+ *              (that is, those significant bits which are not part of the
+ *              sign, exponent, or mantissa) then they will be filled
+ *              according to the value of this property.
  *
- * Return:	Success:	
+ * Return:      Success:        
  *
- *		Failure:	
+ *              Failure:        
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Friday, January  9, 1998
  *
  * Modifications:
@@ -1566,46 +1514,44 @@ H5Tget_inpad (hid_t type_id)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Tset_inpad (hid_t type_id, H5T_pad_t pad)
+H5Tset_inpad(hid_t type_id, H5T_pad_t pad)
 {
-   H5T_t	*dt = NULL;
-
-   FUNC_ENTER (H5Tset_inpad, FAIL);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       H5T_FLOAT!=dt->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL,
-		     "not a floating-point data type");
-   }
-   if (dt->locked) {
-      HRETURN_ERROR (H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
-   }
-   if (pad<0 || pad>=H5T_NPAD) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
-		     "illegal internal pad type");
-   }
-   
-   /* pad */
-   dt->u.atomic.u.f.pad = pad;
-   FUNC_LEAVE (SUCCEED);
+    H5T_t                  *dt = NULL;
+
+    FUNC_ENTER(H5Tset_inpad, FAIL);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        H5T_FLOAT != dt->type) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL,
+                      "not a floating-point data type");
+    }
+    if (dt->locked) {
+        HRETURN_ERROR(H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
+    }
+    if (pad < 0 || pad >= H5T_NPAD) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
+                      "illegal internal pad type");
+    }
+    /* pad */
+    dt->u.atomic.u.f.pad = pad;
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tget_cset
+ * Function:    H5Tget_cset
  *
- * Purpose:	HDF5 is able to distinguish between character sets of
- *		different nationalities and to convert between them to the
- *		extent possible.
- *		
- * Return:	Success:	The character set of an H5T_STRING type.
+ * Purpose:     HDF5 is able to distinguish between character sets of
+ *              different nationalities and to convert between them to the
+ *              extent possible.
+ *              
+ * Return:      Success:        The character set of an H5T_STRING type.
  *
- *		Failure:	H5T_CSET_ERROR (-1, same as FAIL)
+ *              Failure:        H5T_CSET_ERROR (-1, same as FAIL)
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Friday, January  9, 1998
  *
  * Modifications:
@@ -1613,41 +1559,39 @@ H5Tset_inpad (hid_t type_id, H5T_pad_t pad)
  *-------------------------------------------------------------------------
  */
 H5T_cset_t
-H5Tget_cset (hid_t type_id)
+H5Tget_cset(hid_t type_id)
 {
-   H5T_t	*dt = NULL;
-   H5T_cset_t	cset;
-   
-   FUNC_ENTER (H5Tget_cset, H5T_CSET_ERROR);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       H5T_STRING!=dt->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, H5T_CSET_ERROR,
-		     "not a string data type");
-   }
-
-   /* result */
-   cset = dt->u.atomic.u.s.cset;
-
-   FUNC_LEAVE (cset);
+    H5T_t                  *dt = NULL;
+    H5T_cset_t              cset;
+
+    FUNC_ENTER(H5Tget_cset, H5T_CSET_ERROR);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        H5T_STRING != dt->type) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, H5T_CSET_ERROR,
+                      "not a string data type");
+    }
+    /* result */
+    cset = dt->u.atomic.u.s.cset;
+
+    FUNC_LEAVE(cset);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tset_cset
+ * Function:    H5Tset_cset
  *
- * Purpose:	HDF5 is able to distinguish between character sets of
- *		different nationalities and to convert between them to the
- *		extent possible.
+ * Purpose:     HDF5 is able to distinguish between character sets of
+ *              different nationalities and to convert between them to the
+ *              extent possible.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Friday, January  9, 1998
  *
  * Modifications:
@@ -1655,46 +1599,44 @@ H5Tget_cset (hid_t type_id)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Tset_cset (hid_t type_id, H5T_cset_t cset)
+H5Tset_cset(hid_t type_id, H5T_cset_t cset)
 {
-   H5T_t	*dt = NULL;
-
-   FUNC_ENTER (H5Tset_cset, FAIL);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       H5T_STRING!=dt->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a string data type");
-   }
-   if (dt->locked) {
-      HRETURN_ERROR (H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
-   }
-   if (cset<0 || cset>=H5T_NCSET) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
-		     "illegal character set type");
-   }
-   
-   /* set */
-   dt->u.atomic.u.s.cset = cset;
-   FUNC_LEAVE (SUCCEED);
+    H5T_t                  *dt = NULL;
+
+    FUNC_ENTER(H5Tset_cset, FAIL);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        H5T_STRING != dt->type) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a string data type");
+    }
+    if (dt->locked) {
+        HRETURN_ERROR(H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
+    }
+    if (cset < 0 || cset >= H5T_NCSET) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
+                      "illegal character set type");
+    }
+    /* set */
+    dt->u.atomic.u.s.cset = cset;
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tget_strpad
+ * Function:    H5Tget_strpad
  *
- * Purpose:	The method used to store character strings differs with the
- *		programming language: C usually null terminates strings while
- *		Fortran left-justifies and space-pads strings.  This property
- *		defines the storage mechanism for the string.
- *		
- * Return:	Success:	The character set of an H5T_STRING type.
+ * Purpose:     The method used to store character strings differs with the
+ *              programming language: C usually null terminates strings while
+ *              Fortran left-justifies and space-pads strings.  This property
+ *              defines the storage mechanism for the string.
+ *              
+ * Return:      Success:        The character set of an H5T_STRING type.
  *
- *		Failure:	H5T_STR_ERROR (-1, same as FAIL)
+ *              Failure:        H5T_STR_ERROR (-1, same as FAIL)
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Friday, January  9, 1998
  *
  * Modifications:
@@ -1702,42 +1644,40 @@ H5Tset_cset (hid_t type_id, H5T_cset_t cset)
  *-------------------------------------------------------------------------
  */
 H5T_str_t
-H5Tget_strpad (hid_t type_id)
+H5Tget_strpad(hid_t type_id)
 {
-   H5T_t	*dt = NULL;
-   H5T_str_t	strpad;
-   
-   FUNC_ENTER (H5Tget_strpad, H5T_STR_ERROR);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       H5T_STRING!=dt->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, H5T_STR_ERROR,
-		     "not a string data type");
-   }
-
-   /* result */
-   strpad = dt->u.atomic.u.s.pad;
-
-   FUNC_LEAVE (strpad);
+    H5T_t                  *dt = NULL;
+    H5T_str_t               strpad;
+
+    FUNC_ENTER(H5Tget_strpad, H5T_STR_ERROR);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        H5T_STRING != dt->type) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, H5T_STR_ERROR,
+                      "not a string data type");
+    }
+    /* result */
+    strpad = dt->u.atomic.u.s.pad;
+
+    FUNC_LEAVE(strpad);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tset_strpad
+ * Function:    H5Tset_strpad
  *
- * Purpose:	The method used to store character strings differs with the
- *		programming language: C usually null terminates strings while
- *		Fortran left-justifies and space-pads strings.  This property
- *		defines the storage mechanism for the string.
+ * Purpose:     The method used to store character strings differs with the
+ *              programming language: C usually null terminates strings while
+ *              Fortran left-justifies and space-pads strings.  This property
+ *              defines the storage mechanism for the string.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Friday, January  9, 1998
  *
  * Modifications:
@@ -1745,45 +1685,43 @@ H5Tget_strpad (hid_t type_id)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Tset_strpad (hid_t type_id, H5T_str_t strpad)
+H5Tset_strpad(hid_t type_id, H5T_str_t strpad)
 {
-   H5T_t	*dt = NULL;
-
-   FUNC_ENTER (H5Tset_strpad, FAIL);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       H5T_STRING!=dt->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a string data type");
-   }
-   if (dt->locked) {
-      HRETURN_ERROR (H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
-   }
-   if (strpad<0 || strpad>=H5T_NSTR) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "illegal string pad type");
-   }
-   
-   /* set */
-   dt->u.atomic.u.s.pad = strpad;
-   FUNC_LEAVE (SUCCEED);
+    H5T_t                  *dt = NULL;
+
+    FUNC_ENTER(H5Tset_strpad, FAIL);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        H5T_STRING != dt->type) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a string data type");
+    }
+    if (dt->locked) {
+        HRETURN_ERROR(H5E_ARGS, H5E_CANTINIT, FAIL, "data type is read-only");
+    }
+    if (strpad < 0 || strpad >= H5T_NSTR) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "illegal string pad type");
+    }
+    /* set */
+    dt->u.atomic.u.s.pad = strpad;
+    FUNC_LEAVE(SUCCEED);
 }
-   
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tget_nmembers
+ * Function:    H5Tget_nmembers
  *
- * Purpose:	Determines how many members compound data type TYPE_ID has.
+ * Purpose:     Determines how many members compound data type TYPE_ID has.
  *
- * Return:	Success:	Number of members defined in a compound data
- *				type.
+ * Return:      Success:        Number of members defined in a compound data
+ *                              type.
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
  * Errors:
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, December  8, 1997
  *
  * Modifications:
@@ -1791,83 +1729,79 @@ H5Tset_strpad (hid_t type_id, H5T_str_t strpad)
  *-------------------------------------------------------------------------
  */
 intn
-H5Tget_nmembers (hid_t type_id)
+H5Tget_nmembers(hid_t type_id)
 {
-   
-   H5T_t	*dt = NULL;
 
-   FUNC_ENTER (H5Tget_num_members, FAIL);
-   H5ECLEAR;
+    H5T_t                  *dt = NULL;
 
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       H5T_COMPOUND!=dt->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a compound data type");
-   }
+    FUNC_ENTER(H5Tget_num_members, FAIL);
+    H5ECLEAR;
 
-   FUNC_LEAVE (dt->u.compnd.nmembs);
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        H5T_COMPOUND != dt->type) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a compound data type");
+    }
+    FUNC_LEAVE(dt->u.compnd.nmembs);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tget_member_name
+ * Function:    H5Tget_member_name
  *
- * Purpose:	Returns the name of a member of a compound data type.
- *		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 data type.
+ *              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
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
-char *
-H5Tget_member_name (hid_t type_id, int membno)
+char                   *
+H5Tget_member_name(hid_t type_id, int membno)
 {
-   H5T_t	*dt = NULL;
-   char		*s = NULL;
-
-   FUNC_ENTER (H5Tget_member_name, NULL);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       H5T_COMPOUND!=dt->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, NULL, "not a compound data type");
-   }
-   if (membno<0 || membno>=dt->u.compnd.nmembs) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, NULL, "invalid member number");
-   }
-
-   s = H5MM_xstrdup (dt->u.compnd.memb[membno].name);
-   FUNC_LEAVE (s);
+    H5T_t                  *dt = NULL;
+    char                   *s = NULL;
+
+    FUNC_ENTER(H5Tget_member_name, NULL);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        H5T_COMPOUND != dt->type) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a compound data type");
+    }
+    if (membno < 0 || membno >= dt->u.compnd.nmembs) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, NULL, "invalid member number");
+    }
+    s = H5MM_xstrdup(dt->u.compnd.memb[membno].name);
+    FUNC_LEAVE(s);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tget_member_offset
+ * Function:    H5Tget_member_offset
  *
- * Purpose:	Returns the byte offset of the beginning of a member with
- *		respect to the beginning of the compound data type datum.
+ * Purpose:     Returns the byte offset of the beginning of a member with
+ *              respect to the beginning of the compound data type datum.
  *
- * Return:	Success:	Byte offset.
+ * Return:      Success:        Byte offset.
  *
- *		Failure:	Zero. Zero is a valid offset, but this
- *				function will fail only if a call to
- *				H5Tget_member_dims() fails with the same
- *				arguments.
+ *              Failure:        Zero. Zero is a valid offset, but this
+ *                              function will fail only if a call to
+ *                              H5Tget_member_dims() fails with the same
+ *                              arguments.
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
@@ -1875,42 +1809,40 @@ H5Tget_member_name (hid_t type_id, int membno)
  *-------------------------------------------------------------------------
  */
 size_t
-H5Tget_member_offset (hid_t type_id, int membno)
+H5Tget_member_offset(hid_t type_id, int membno)
 {
-   H5T_t	*dt = NULL;
-   size_t	offset = 0;
-
-   FUNC_ENTER (H5Tget_member_offset, 0);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       H5T_COMPOUND!=dt->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, 0, "not a compound data type");
-   }
-   if (membno<0 || membno>=dt->u.compnd.nmembs) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, 0, "invalid member number");
-   }
-
-   offset = dt->u.compnd.memb[membno].offset;
-   FUNC_LEAVE (offset);
+    H5T_t                  *dt = NULL;
+    size_t                  offset = 0;
+
+    FUNC_ENTER(H5Tget_member_offset, 0);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        H5T_COMPOUND != dt->type) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, 0, "not a compound data type");
+    }
+    if (membno < 0 || membno >= dt->u.compnd.nmembs) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, 0, "invalid member number");
+    }
+    offset = dt->u.compnd.memb[membno].offset;
+    FUNC_LEAVE(offset);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tget_member_dims
+ * Function:    H5Tget_member_dims
  *
- * Purpose:	Returns the dimensionality of the member.  The dimensions and
- *		permuation vector are returned through arguments DIMS and
- *		PERM, both arrays of at least four elements.  Either (or even
- *		both) may be null pointers.
+ * Purpose:     Returns the dimensionality of the member.  The dimensions and
+ *              permuation vector are returned through arguments DIMS and
+ *              PERM, both arrays of at least four elements.  Either (or even
+ *              both) may be null pointers.
  *
- * Return:	Success:	A value between zero and four, inclusive.
+ * Return:      Success:        A value between zero and four, inclusive.
  *
- *		Failure:	-1
+ *              Failure:        -1
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
@@ -1918,49 +1850,49 @@ H5Tget_member_offset (hid_t type_id, int membno)
  *-------------------------------------------------------------------------
  */
 int
-H5Tget_member_dims (hid_t type_id, int membno,
-		    int dims[]/*out*/, int perm[]/*out*/)
+H5Tget_member_dims(hid_t type_id, int membno,
+                   int dims[] /*out */ , int perm[] /*out */ )
 {
-   H5T_t	*dt = NULL;
-   intn		ndims, i;
-
-   FUNC_ENTER (H5Tget_member_dims, FAIL);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       H5T_COMPOUND!=dt->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a compound data type");
-   }
-   if (membno<0 || membno>=dt->u.compnd.nmembs) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "invalid member number");
-   }
-
-   ndims = dt->u.compnd.memb[membno].ndims;
-   for (i=0; i<ndims; i++) {
-      if (dims[i]) dims[i] = dt->u.compnd.memb[membno].dim[i];
-      if (perm[i]) perm[i] = dt->u.compnd.memb[membno].perm[i];
-   }
-   
-   FUNC_LEAVE (ndims);
+    H5T_t                  *dt = NULL;
+    intn                    ndims, i;
+
+    FUNC_ENTER(H5Tget_member_dims, FAIL);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        H5T_COMPOUND != dt->type) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a compound data type");
+    }
+    if (membno < 0 || membno >= dt->u.compnd.nmembs) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid member number");
+    }
+    ndims = dt->u.compnd.memb[membno].ndims;
+    for (i = 0; i < ndims; i++) {
+        if (dims[i])
+            dims[i] = dt->u.compnd.memb[membno].dim[i];
+        if (perm[i])
+            perm[i] = dt->u.compnd.memb[membno].perm[i];
+    }
+
+    FUNC_LEAVE(ndims);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tget_member_type
+ * Function:    H5Tget_member_type
  *
- * Purpose:	Returns the data type of the specified member.  The caller
- *		should invoke H5Tclose() to release resources associated with
- *		the type.
+ * Purpose:     Returns the data type of the specified member.  The caller
+ *              should invoke H5Tclose() to release resources associated with
+ *              the type.
  *
- * Return:	Success:	An OID of a copy of the member data type;
- *				modifying the returned data type does not
- *				modify the member type.
+ * Return:      Success:        An OID of a copy of the member data type;
+ *                              modifying the returned data type does not
+ *                              modify the member type.
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
@@ -1968,61 +1900,58 @@ H5Tget_member_dims (hid_t type_id, int membno,
  *-------------------------------------------------------------------------
  */
 hid_t
-H5Tget_member_type (hid_t type_id, int membno)
+H5Tget_member_type(hid_t type_id, int membno)
 {
-   H5T_t	*dt = NULL, *memb_dt = NULL;
-   hid_t	memb_type_id;
-
-   FUNC_ENTER (H5Tget_member_type, FAIL);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       H5T_COMPOUND!=dt->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a compound data type");
-   }
-   if (membno<0 || membno>=dt->u.compnd.nmembs) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "invalid member number");
-   }
-   
-   /* Copy data type into an atom */
-   if (NULL==(memb_dt=H5T_copy (&(dt->u.compnd.memb[membno].type)))) {
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL,
-		     "unable to copy member data type");
-   }
-   if ((memb_type_id=H5Aregister_atom (H5_DATATYPE, memb_dt))<0) {
-      H5T_close (memb_dt);
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTREGISTER, FAIL,
-		     "can't register data type atom");
-   }
-
-   FUNC_LEAVE (memb_type_id);
+    H5T_t                  *dt = NULL, *memb_dt = NULL;
+    hid_t                   memb_type_id;
+
+    FUNC_ENTER(H5Tget_member_type, FAIL);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        H5T_COMPOUND != dt->type) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a compound data type");
+    }
+    if (membno < 0 || membno >= dt->u.compnd.nmembs) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid member number");
+    }
+    /* Copy data type into an atom */
+    if (NULL == (memb_dt = H5T_copy(&(dt->u.compnd.memb[membno].type)))) {
+        HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL,
+                      "unable to copy member data type");
+    }
+    if ((memb_type_id = H5Aregister_atom(H5_DATATYPE, memb_dt)) < 0) {
+        H5T_close(memb_dt);
+        HRETURN_ERROR(H5E_DATATYPE, H5E_CANTREGISTER, FAIL,
+                      "can't register data type atom");
+    }
+    FUNC_LEAVE(memb_type_id);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tinsert
+ * Function:    H5Tinsert
  *
- * Purpose:	Adds another member to the compound data type PARENT_ID.  The
- *		new member has a NAME which must be unique within the
- *		compound data type. The OFFSET argument defines the start of
- *		the member in an instance of the compound data type, and
- *		MEMBER_ID is the type of the new member.
+ * Purpose:     Adds another member to the compound data type PARENT_ID.  The
+ *              new member has a NAME which must be unique within the
+ *              compound data type. The OFFSET argument defines the start of
+ *              the member in an instance of the compound data type, and
+ *              MEMBER_ID is the type of the new member.
  *
- * Note:	All members of a compound data type must be atomic; a
- *		compound data type cannot have a member which is a compound
- *		data type.
+ * Note:        All members of a compound data type must be atomic; a
+ *              compound data type cannot have a member which is a compound
+ *              data type.
  *
- * Return:	Success:	SUCCEED, the PARENT_ID compound data type is
- *				modified to include a copy of the member type
- *				MEMBER_ID.
+ * Return:      Success:        SUCCEED, the PARENT_ID compound data type is
+ *                              modified to include a copy of the member type
+ *                              MEMBER_ID.
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
  * Errors:
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, December  8, 1997
  *
  * Modifications:
@@ -2030,51 +1959,48 @@ H5Tget_member_type (hid_t type_id, int membno)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Tinsert (hid_t parent_id, const char *name, off_t offset, hid_t member_id)
+H5Tinsert(hid_t parent_id, const char *name, off_t offset, hid_t member_id)
 {
-   H5T_t	*parent = NULL;		/*the compound parent data type	*/
-   H5T_t	*member = NULL;		/*the atomic member type	*/
-   
-   FUNC_ENTER (H5Tinsert, FAIL);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (parent_id) ||
-       NULL==(parent=H5Aatom_object (parent_id)) ||
-       H5T_COMPOUND!=parent->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a compound data type");
-   }
-   if (parent->locked) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "parent type read-only");
-   }
-   if (!name || !*name) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no member name");
-   }
-   if (H5_DATATYPE!=H5Aatom_group (member_id) ||
-       NULL==(member=H5Aatom_object (member_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
-   }
-
-   if (H5T_insert (parent, name, offset, member)<0) {
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINSERT, FAIL,
-		     "can't insert member");
-   }
-
-   FUNC_LEAVE (SUCCEED);
+    H5T_t                  *parent = NULL;      /*the compound parent data type */
+    H5T_t                  *member = NULL;      /*the atomic member type        */
+
+    FUNC_ENTER(H5Tinsert, FAIL);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(parent_id) ||
+        NULL == (parent = H5Aatom_object(parent_id)) ||
+        H5T_COMPOUND != parent->type) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a compound data type");
+    }
+    if (parent->locked) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "parent type read-only");
+    }
+    if (!name || !*name) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no member name");
+    }
+    if (H5_DATATYPE != H5Aatom_group(member_id) ||
+        NULL == (member = H5Aatom_object(member_id))) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+    }
+    if (H5T_insert(parent, name, offset, member) < 0) {
+        HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINSERT, FAIL,
+                      "can't insert member");
+    }
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tpack
+ * Function:    H5Tpack
  *
- * Purpose:	Recursively removes padding from within a compound data type
- *		to make it more efficient (space-wise) to store that data.
+ * Purpose:     Recursively removes padding from within a compound data type
+ *              to make it more efficient (space-wise) to store that data.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
@@ -2082,51 +2008,48 @@ H5Tinsert (hid_t parent_id, const char *name, off_t offset, hid_t member_id)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Tpack (hid_t type_id)
+H5Tpack(hid_t type_id)
 {
-   H5T_t	*dt = NULL;
-   
-   FUNC_ENTER (H5Tpack, FAIL);
-   H5ECLEAR;
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (type_id) ||
-       NULL==(dt=H5Aatom_object (type_id)) ||
-       H5T_COMPOUND!=dt->type) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a compound data type");
-   }
-   if (dt->locked) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "data type is read-only");
-   }
-
-   if (H5T_pack (dt)<0) {
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL,
-		     "unable to pack compound data type");
-   }
-
-   FUNC_LEAVE (SUCCEED);
+    H5T_t                  *dt = NULL;
+
+    FUNC_ENTER(H5Tpack, FAIL);
+    H5ECLEAR;
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(type_id) ||
+        NULL == (dt = H5Aatom_object(type_id)) ||
+        H5T_COMPOUND != dt->type) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a compound data type");
+    }
+    if (dt->locked) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "data type is read-only");
+    }
+    if (H5T_pack(dt) < 0) {
+        HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL,
+                      "unable to pack compound data type");
+    }
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tregister_hard
+ * Function:    H5Tregister_hard
  *
- * Purpose:	Register a hard conversion function for a data type
- *		conversion path.  The path is specified by the source and
- *		destination data types SRC_ID and DST_ID.  A conversion path
- *		can only have one hard function, so FUNC replaces any
- *		previous hard function.
+ * Purpose:     Register a hard conversion function for a data type
+ *              conversion path.  The path is specified by the source and
+ *              destination data types SRC_ID and DST_ID.  A conversion path
+ *              can only have one hard function, so FUNC replaces any
+ *              previous hard function.
  *
- *		If FUNC is the null pointer then any hard function registered
- *		for this path is removed from this path.  The soft functions
- *		are then used when determining which conversion function is
- *		appropriate for this path.
+ *              If FUNC is the null pointer then any hard function registered
+ *              for this path is removed from this path.  The soft functions
+ *              are then used when determining which conversion function is
+ *              appropriate for this path.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Friday, January  9, 1998
  *
  * Modifications:
@@ -2134,46 +2057,43 @@ H5Tpack (hid_t type_id)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Tregister_hard (hid_t src_id, hid_t dst_id, H5T_conv_t func)
+H5Tregister_hard(hid_t src_id, hid_t dst_id, H5T_conv_t func)
 {
-   H5T_t	*src = NULL;
-   H5T_t	*dst = NULL;
-   H5T_path_t	*path = NULL;
-   
-   FUNC_ENTER (H5Tregister_hard, FAIL);
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (src_id) ||
-       NULL==(src=H5Aatom_object (src_id)) ||
-       H5_DATATYPE!=H5Aatom_group (dst_id) ||
-       NULL==(dst=H5Aatom_object (dst_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
-   }
-
-   /* Locate or create a new conversion path */
-   if (NULL==(path=H5T_path_find (src, dst, TRUE))) {
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL,
-		     "unable to locate/allocate conversion path");
-   }
-
-   /* Initialize the hard function */
-   path->hard = func;
-   FUNC_LEAVE (SUCCEED);
+    H5T_t                  *src = NULL;
+    H5T_t                  *dst = NULL;
+    H5T_path_t             *path = NULL;
+
+    FUNC_ENTER(H5Tregister_hard, FAIL);
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(src_id) ||
+        NULL == (src = H5Aatom_object(src_id)) ||
+        H5_DATATYPE != H5Aatom_group(dst_id) ||
+        NULL == (dst = H5Aatom_object(dst_id))) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data type");
+    }
+    /* Locate or create a new conversion path */
+    if (NULL == (path = H5T_path_find(src, dst, TRUE))) {
+        HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL,
+                      "unable to locate/allocate conversion path");
+    }
+    /* Initialize the hard function */
+    path->hard = func;
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tregister_soft
+ * Function:    H5Tregister_soft
  *
- * Purpose:	Registers a soft conversion function by adding it to the end
- *		of the master soft list and replacing the soft function in
- *		all applicable existing conversion paths.
+ * Purpose:     Registers a soft conversion function by adding it to the end
+ *              of the master soft list and replacing the soft function in
+ *              all applicable existing conversion paths.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Tuesday, January 13, 1998
  *
  * Modifications:
@@ -2181,74 +2101,73 @@ H5Tregister_hard (hid_t src_id, hid_t dst_id, H5T_conv_t func)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Tregister_soft (H5T_class_t src_cls, H5T_class_t dst_cls, H5T_conv_t func)
+H5Tregister_soft(H5T_class_t src_cls, H5T_class_t dst_cls, H5T_conv_t func)
 {
-   intn		i;
-   hid_t	src_id, dst_id;
-   
-   FUNC_ENTER (H5Tregister_soft, FAIL);
-
-   /* Check args */
-   if (src_cls<0 || src_cls>=H5T_NCLASSES ||
-       dst_cls<0 || dst_cls>=H5T_NCLASSES) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
-		     "illegal source or destination data type class");
-   }
-   if (!func) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
-		     "no soft conversion function specified");
-   }
-   
-   /* Add function to end of master list */
-   if (H5T_nsoft_g>=H5T_asoft_g) {
-      H5T_asoft_g = MAX (32, 2*H5T_asoft_g);
-      H5T_soft_g = H5MM_xrealloc (H5T_soft_g, H5T_asoft_g*sizeof(H5T_soft_t));
-   }
-   H5T_soft_g[H5T_nsoft_g].src = src_cls;
-   H5T_soft_g[H5T_nsoft_g].dst = dst_cls;
-   H5T_soft_g[H5T_nsoft_g].func = func;
-   H5T_nsoft_g++;
-
-   /* Replace soft functions of all appropriate paths */
-   for (i=0; i<H5T_npath_g; i++) {
-      H5T_path_t *path = H5T_path_g + i;
-
-      /*
-       * Type conversion functions are app-level, so we need to convert the
-       * data type temporarily to an object id before we query the functions
-       * capabilities.
-       */
-      if (path->src->type!=src_cls || path->dst->type!=dst_cls) continue;
-      if ((src_id = H5Aregister_atom (H5_DATATYPE, H5T_copy (path->src)))<0 ||
-	  (dst_id = H5Aregister_atom (H5_DATATYPE, H5T_copy (path->dst)))<0) {
-	 HRETURN_ERROR (H5E_DATATYPE, H5E_CANTREGISTER, FAIL,
-			"unable to register data types for conv query");
-      }
-      if ((func)(src_id, dst_id, 0, NULL, NULL)>=0) {
-	 path->soft = func;
-      }
-      H5A_dec_ref (src_id);
-      H5A_dec_ref (dst_id);
-      H5ECLEAR;
-   }
-
-   FUNC_LEAVE (SUCCEED);
+    intn                    i;
+    hid_t                   src_id, dst_id;
+
+    FUNC_ENTER(H5Tregister_soft, FAIL);
+
+    /* Check args */
+    if (src_cls < 0 || src_cls >= H5T_NCLASSES ||
+        dst_cls < 0 || dst_cls >= H5T_NCLASSES) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
+                      "illegal source or destination data type class");
+    }
+    if (!func) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
+                      "no soft conversion function specified");
+    }
+    /* Add function to end of master list */
+    if (H5T_nsoft_g >= H5T_asoft_g) {
+        H5T_asoft_g = MAX(32, 2 * H5T_asoft_g);
+        H5T_soft_g = H5MM_xrealloc(H5T_soft_g, H5T_asoft_g * sizeof(H5T_soft_t));
+    }
+    H5T_soft_g[H5T_nsoft_g].src = src_cls;
+    H5T_soft_g[H5T_nsoft_g].dst = dst_cls;
+    H5T_soft_g[H5T_nsoft_g].func = func;
+    H5T_nsoft_g++;
+
+    /* Replace soft functions of all appropriate paths */
+    for (i = 0; i < H5T_npath_g; i++) {
+        H5T_path_t             *path = H5T_path_g + i;
+
+        /*
+         * Type conversion functions are app-level, so we need to convert the
+         * data type temporarily to an object id before we query the functions
+         * capabilities.
+         */
+        if (path->src->type != src_cls || path->dst->type != dst_cls)
+            continue;
+        if ((src_id = H5Aregister_atom(H5_DATATYPE, H5T_copy(path->src))) < 0 ||
+        (dst_id = H5Aregister_atom(H5_DATATYPE, H5T_copy(path->dst))) < 0) {
+            HRETURN_ERROR(H5E_DATATYPE, H5E_CANTREGISTER, FAIL,
+                          "unable to register data types for conv query");
+        }
+        if ((func) (src_id, dst_id, 0, NULL, NULL) >= 0) {
+            path->soft = func;
+        }
+        H5A_dec_ref(src_id);
+        H5A_dec_ref(dst_id);
+        H5ECLEAR;
+    }
+
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tunregister
+ * Function:    H5Tunregister
  *
- * Purpose:	Removes FUNC from all conversion paths.  If FUNC is
- *		registered as the soft conversion function of a path then it
- *		is replaced with some other soft conversion function from the
- *		master soft list if one applies.
+ * Purpose:     Removes FUNC from all conversion paths.  If FUNC is
+ *              registered as the soft conversion function of a path then it
+ *              is replaced with some other soft conversion function from the
+ *              master soft list if one applies.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Tuesday, January 13, 1998
  *
  * Modifications:
@@ -2256,82 +2175,78 @@ H5Tregister_soft (H5T_class_t src_cls, H5T_class_t dst_cls, H5T_conv_t func)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Tunregister (H5T_conv_t func)
+H5Tunregister(H5T_conv_t func)
 {
-   intn		i, j;
-   H5T_path_t	*path = NULL;
-   hid_t	src_id, dst_id;
-
-   FUNC_ENTER (H5Tunregister, FAIL);
-
-   /* Check args */
-   if (!func) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no conversion function");
-   }
-
-   /* Remove function from master soft list */
-   for (i=H5T_nsoft_g-1; i>=0; --i) {
-      if (H5T_soft_g[i].func==func) {
-	 HDmemmove (H5T_soft_g+i, H5T_soft_g+i+1,
-		    (H5T_nsoft_g-(i+1))*sizeof(H5T_soft_t));
-	 --H5T_nsoft_g;
-      }
-   }
-   
-   /* Remove function from all conversion paths */
-   for (i=0; i<H5T_npath_g; i++) {
-      path = H5T_path_g + i;
-
-      /* Reset hard function */
-      if (path->hard==func) {
-	 path->hard = NULL;
-      }
-
-      /* Reset soft function */
-      if (path->soft==func) {
-	 path->soft = NULL;
-	 for (j=H5T_nsoft_g-1; j>=0 && !path->soft; --j) {
-	    if (path->src->type!=H5T_soft_g[j].src ||
-		path->dst->type!=H5T_soft_g[j].dst) {
-	       continue;
-	    }
-
-	    /*
-	     * Conversion functions are app-level, so temporarily create
-	     * object id's for the data types.
-	     */
-	    if ((src_id=H5Aregister_atom (H5_DATATYPE,
-					  H5T_copy (path->src)))<0 ||
-		(dst_id=H5Aregister_atom (H5_DATATYPE,
-					  H5T_copy (path->dst)))<0) {
-	       HRETURN_ERROR (H5E_DATATYPE, H5E_CANTREGISTER, FAIL,
-			      "unable to register conv types for query");
-	    }
-	    if ((H5T_soft_g[j].func)(src_id, dst_id, 0, NULL, NULL)>=0) {
-	       path->soft = H5T_soft_g[j].func;
-	    }
-	    H5A_dec_ref (src_id);
-	    H5A_dec_ref (dst_id);
-	    H5ECLEAR;
-	 }
-      }
-   }
-
-   FUNC_LEAVE (SUCCEED);
+    intn                    i, j;
+    H5T_path_t             *path = NULL;
+    hid_t                   src_id, dst_id;
+
+    FUNC_ENTER(H5Tunregister, FAIL);
+
+    /* Check args */
+    if (!func) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no conversion function");
+    }
+    /* Remove function from master soft list */
+    for (i = H5T_nsoft_g - 1; i >= 0; --i) {
+        if (H5T_soft_g[i].func == func) {
+            HDmemmove(H5T_soft_g + i, H5T_soft_g + i + 1,
+                      (H5T_nsoft_g - (i + 1)) * sizeof(H5T_soft_t));
+            --H5T_nsoft_g;
+        }
+    }
+
+    /* Remove function from all conversion paths */
+    for (i = 0; i < H5T_npath_g; i++) {
+        path = H5T_path_g + i;
+
+        /* Reset hard function */
+        if (path->hard == func) {
+            path->hard = NULL;
+        }
+        /* Reset soft function */
+        if (path->soft == func) {
+            path->soft = NULL;
+            for (j = H5T_nsoft_g - 1; j >= 0 && !path->soft; --j) {
+                if (path->src->type != H5T_soft_g[j].src ||
+                    path->dst->type != H5T_soft_g[j].dst) {
+                    continue;
+                }
+                /*
+                 * Conversion functions are app-level, so temporarily create
+                 * object id's for the data types.
+                 */
+                if ((src_id = H5Aregister_atom(H5_DATATYPE,
+                                               H5T_copy(path->src))) < 0 ||
+                    (dst_id = H5Aregister_atom(H5_DATATYPE,
+                                               H5T_copy(path->dst))) < 0) {
+                    HRETURN_ERROR(H5E_DATATYPE, H5E_CANTREGISTER, FAIL,
+                                  "unable to register conv types for query");
+                }
+                if ((H5T_soft_g[j].func) (src_id, dst_id, 0, NULL, NULL) >= 0) {
+                    path->soft = H5T_soft_g[j].func;
+                }
+                H5A_dec_ref(src_id);
+                H5A_dec_ref(dst_id);
+                H5ECLEAR;
+            }
+        }
+    }
+
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Tfind
+ * Function:    H5Tfind
  *
- * Purpose:	Finds a conversion function that can handle a conversion from
- *		type SRC_ID to type DST_ID.
+ * Purpose:     Finds a conversion function that can handle a conversion from
+ *              type SRC_ID to type DST_ID.
  *
- * Return:	Success:	A pointer to a suitable conversion function.
+ * Return:      Success:        A pointer to a suitable conversion function.
  *
- *		Failure:	NULL
+ *              Failure:        NULL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Tuesday, January 13, 1998
  *
  * Modifications:
@@ -2339,156 +2254,141 @@ H5Tunregister (H5T_conv_t func)
  *-------------------------------------------------------------------------
  */
 H5T_conv_t
-H5Tfind (hid_t src_id, hid_t dst_id)
+H5Tfind(hid_t src_id, hid_t dst_id)
 {
-   H5T_conv_t	ret_value = NULL;
-   H5T_t	*src=NULL, *dst=NULL;
-   
-   FUNC_ENTER (H5Tfind, NULL);
-
-   /* Check args */
-   if (H5_DATATYPE!=H5Aatom_group (src_id) ||
-       NULL==(src=H5Aatom_object (src_id)) ||
-       H5_DATATYPE!=H5Aatom_group (dst_id) ||
-       NULL==(dst=H5Aatom_object (dst_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, NULL, "not a data type");
-   }
-
-   /* Find it */
-   if (NULL==(ret_value = H5T_find (src, dst))) {
-      HRETURN_ERROR (H5E_DATATYPE, H5E_NOTFOUND, NULL,
-		     "conversion function not found");
-   }
-
-   FUNC_LEAVE (ret_value);
+    H5T_conv_t              ret_value = NULL;
+    H5T_t                  *src = NULL, *dst = NULL;
+
+    FUNC_ENTER(H5Tfind, NULL);
+
+    /* Check args */
+    if (H5_DATATYPE != H5Aatom_group(src_id) ||
+        NULL == (src = H5Aatom_object(src_id)) ||
+        H5_DATATYPE != H5Aatom_group(dst_id) ||
+        NULL == (dst = H5Aatom_object(dst_id))) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, NULL, "not a data type");
+    }
+    /* Find it */
+    if (NULL == (ret_value = H5T_find(src, dst))) {
+        HRETURN_ERROR(H5E_DATATYPE, H5E_NOTFOUND, NULL,
+                      "conversion function not found");
+    }
+    FUNC_LEAVE(ret_value);
 }
 
-
-
-
-
 /*-------------------------------------------------------------------------
  * API functions are above; library-private functions are below...
  *------------------------------------------------------------------------- 
  */
-
-
-
-
-
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5T_create
+ * Function:    H5T_create
  *
- * Purpose:	Creates a new data type and initializes it to reasonable
- *		values.  The new data type is SIZE bytes and an instance of
- *		the class TYPE.
+ * Purpose:     Creates a new data type and initializes it to reasonable
+ *              values.  The new data type is SIZE bytes and an instance of
+ *              the class TYPE.
  *
- * Return:	Success:	Pointer to the new type.
+ * Return:      Success:        Pointer to the new type.
  *
- *		Failure:	NULL
+ *              Failure:        NULL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Friday, December  5, 1997
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
-H5T_t *
-H5T_create (H5T_class_t type, size_t size)
+H5T_t                  *
+H5T_create(H5T_class_t type, size_t size)
 {
-   H5T_t	*dt = NULL;
-   
-   FUNC_ENTER (H5T_create, NULL);
-
-   assert (size>0);
-
-   switch (type) {
-   case H5T_INTEGER:
-   case H5T_FLOAT:
-   case H5T_TIME:
-   case H5T_STRING:
-   case H5T_BITFIELD:
-   case H5T_OPAQUE:
-      HRETURN_ERROR (H5E_DATATYPE, H5E_UNSUPPORTED, NULL,
-		     "type class is not appropriate - use H5Tcopy()");
-
-   case H5T_COMPOUND:
-      dt = H5MM_xcalloc (1, sizeof(H5T_t));
-      dt->type = type;
-      break;
-
-   default:
-      HRETURN_ERROR (H5E_INTERNAL, H5E_UNSUPPORTED, NULL,
-		     "unknown data type class");
-   }
-
-   dt->size = size;
-   FUNC_LEAVE (dt);
+    H5T_t                  *dt = NULL;
+
+    FUNC_ENTER(H5T_create, NULL);
+
+    assert(size > 0);
+
+    switch (type) {
+    case H5T_INTEGER:
+    case H5T_FLOAT:
+    case H5T_TIME:
+    case H5T_STRING:
+    case H5T_BITFIELD:
+    case H5T_OPAQUE:
+        HRETURN_ERROR(H5E_DATATYPE, H5E_UNSUPPORTED, NULL,
+                      "type class is not appropriate - use H5Tcopy()");
+
+    case H5T_COMPOUND:
+        dt = H5MM_xcalloc(1, sizeof(H5T_t));
+        dt->type = type;
+        break;
+
+    default:
+        HRETURN_ERROR(H5E_INTERNAL, H5E_UNSUPPORTED, NULL,
+                      "unknown data type class");
+    }
+
+    dt->size = size;
+    FUNC_LEAVE(dt);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5T_copy
+ * Function:    H5T_copy
  *
- * Purpose:	Copies datatype OLD_DT.  The resulting data type is not
- *		locked.
+ * Purpose:     Copies datatype OLD_DT.  The resulting data type is not
+ *              locked.
  *
- * Return:	Success:	Pointer to a new copy of the OLD_DT argument.
+ * Return:      Success:        Pointer to a new copy of the OLD_DT argument.
  *
- *		Failure:	NULL
+ *              Failure:        NULL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Thursday, December  4, 1997
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
-H5T_t *
-H5T_copy (const H5T_t *old_dt)
+H5T_t                  *
+H5T_copy(const H5T_t *old_dt)
 {
-   H5T_t	*new_dt = NULL;
-   intn		i;
-   char		*s;
-   
-   FUNC_ENTER (H5T_copy, NULL);
-
-   /* check args */
-   assert (old_dt);
-
-   /* copy */
-   new_dt = H5MM_xcalloc (1, sizeof(H5T_t));
-   *new_dt = *old_dt;
-   new_dt->locked = FALSE;
-   
-   if (H5T_COMPOUND==new_dt->type) {
-      new_dt->u.compnd.memb = H5MM_xmalloc (new_dt->u.compnd.nmembs *
-					    sizeof(H5T_member_t));
-      HDmemcpy (new_dt->u.compnd.memb, old_dt->u.compnd.memb,
-		new_dt->u.compnd.nmembs * sizeof(H5T_member_t));
-      for (i=0; i<new_dt->u.compnd.nmembs; i++) {
-	 s = new_dt->u.compnd.memb[i].name;
-	 new_dt->u.compnd.memb[i].name = H5MM_xstrdup (s);
-      }
-   }
-   
-   FUNC_LEAVE (new_dt);
+    H5T_t                  *new_dt = NULL;
+    intn                    i;
+    char                   *s;
+
+    FUNC_ENTER(H5T_copy, NULL);
+
+    /* check args */
+    assert(old_dt);
+
+    /* copy */
+    new_dt = H5MM_xcalloc(1, sizeof(H5T_t));
+    *new_dt = *old_dt;
+    new_dt->locked = FALSE;
+
+    if (H5T_COMPOUND == new_dt->type) {
+        new_dt->u.compnd.memb = H5MM_xmalloc(new_dt->u.compnd.nmembs *
+                                             sizeof(H5T_member_t));
+        HDmemcpy(new_dt->u.compnd.memb, old_dt->u.compnd.memb,
+                 new_dt->u.compnd.nmembs * sizeof(H5T_member_t));
+        for (i = 0; i < new_dt->u.compnd.nmembs; i++) {
+            s = new_dt->u.compnd.memb[i].name;
+            new_dt->u.compnd.memb[i].name = H5MM_xstrdup(s);
+        }
+    }
+    FUNC_LEAVE(new_dt);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5T_close
+ * Function:    H5T_close
  *
- * Purpose:	Frees a data type and all associated memory.
+ * Purpose:     Frees a data type and all associated memory.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, December  8, 1997
  *
  * Modifications:
@@ -2496,40 +2396,38 @@ H5T_copy (const H5T_t *old_dt)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5T_close (H5T_t *dt)
+H5T_close(H5T_t *dt)
 {
-   intn		i;
-   
-   FUNC_ENTER (H5T_close, FAIL);
-
-   assert (dt);
-   assert (!dt->locked);
-
-   if (dt && H5T_COMPOUND==dt->type) {
-      for (i=0; i<dt->u.compnd.nmembs; i++) {
-	 H5MM_xfree (dt->u.compnd.memb[i].name);
-      }
-      H5MM_xfree (dt->u.compnd.memb);
-      H5MM_xfree (dt);
-      
-   } else if (dt) {
-      H5MM_xfree (dt);
-   }
-
-   FUNC_LEAVE (SUCCEED);
-}
+    intn                    i;
+
+    FUNC_ENTER(H5T_close, FAIL);
+
+    assert(dt);
+    assert(!dt->locked);
 
+    if (dt && H5T_COMPOUND == dt->type) {
+        for (i = 0; i < dt->u.compnd.nmembs; i++) {
+            H5MM_xfree(dt->u.compnd.memb[i].name);
+        }
+        H5MM_xfree(dt->u.compnd.memb);
+        H5MM_xfree(dt);
+
+    } else if (dt) {
+        H5MM_xfree(dt);
+    }
+    FUNC_LEAVE(SUCCEED);
+}
 
 /*-------------------------------------------------------------------------
- * Function:	H5T_is_atomic
+ * Function:    H5T_is_atomic
  *
- * Purpose:	Determines if a data type is an atomic type.
+ * Purpose:     Determines if a data type is an atomic type.
  *
- * Return:	Success:	TRUE, FALSE
+ * Return:      Success:        TRUE, FALSE
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
@@ -2537,28 +2435,27 @@ H5T_close (H5T_t *dt)
  *-------------------------------------------------------------------------
  */
 hbool_t
-H5T_is_atomic (const H5T_t *dt)
+H5T_is_atomic(const H5T_t *dt)
 {
-   FUNC_ENTER (H5T_is_atomic, FAIL);
+    FUNC_ENTER(H5T_is_atomic, FAIL);
 
-   assert (dt);
+    assert(dt);
 
-   FUNC_LEAVE (H5T_COMPOUND==dt->type ? FALSE : TRUE);
+    FUNC_LEAVE(H5T_COMPOUND == dt->type ? FALSE : TRUE);
 }
-
 
 /*-------------------------------------------------------------------------
- * 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
+ * Programmer:  Robb Matzke
  *              Tuesday, December  9, 1997
  *
  * Modifications:
@@ -2566,30 +2463,29 @@ H5T_is_atomic (const H5T_t *dt)
  *-------------------------------------------------------------------------
  */
 size_t
-H5T_get_size (const H5T_t *dt)
+H5T_get_size(const H5T_t *dt)
 {
-   FUNC_ENTER (H5T_get_size, 0);
+    FUNC_ENTER(H5T_get_size, 0);
 
-   /* check args */
-   assert (dt);
+    /* check args */
+    assert(dt);
 
-   FUNC_LEAVE (dt->size);
+    FUNC_LEAVE(dt->size);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5T_insert
+ * Function:    H5T_insert
  *
- * Purpose:	Adds a new MEMBER to the compound data type PARENT.  The new
- *		member will have a NAME that is unique within PARENT and an
- *		instance of PARENT will have the member begin at byte offset
- *		OFFSET from the beginning.
+ * Purpose:     Adds a new MEMBER to the compound data type PARENT.  The new
+ *              member will have a NAME that is unique within PARENT and an
+ *              instance of PARENT will have the member begin at byte offset
+ *              OFFSET from the beginning.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Monday, December  8, 1997
  *
  * Modifications:
@@ -2597,73 +2493,71 @@ H5T_get_size (const H5T_t *dt)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5T_insert (H5T_t *parent, const char *name, off_t offset, const H5T_t *member)
+H5T_insert(H5T_t *parent, const char *name, off_t offset, const H5T_t *member)
 {
-   intn		i;
-   H5T_t	*tmp = NULL;
-   
-   FUNC_ENTER (H5T_insert, FAIL);
-
-   /* check args */
-   assert (parent && H5T_COMPOUND==parent->type);
-   assert (!parent->locked);
-   assert (member);
-   assert (name && *name);
-
-   /* Does NAME already exist in PARENT? */
-   for (i=0; i<parent->u.compnd.nmembs; i++) {
-      if (!HDstrcmp (parent->u.compnd.memb[i].name, name)) {
-	 HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINSERT, FAIL,
-			"member name is not unique");
-      }
-   }
-   
-   /* Does the new member overlap any existing member ? */
-   for (i=0; i<parent->u.compnd.nmembs; i++) {
-      if ((offset<parent->u.compnd.memb[i].offset &&
-	   offset+member->size>parent->u.compnd.memb[i].offset) ||
-	  (parent->u.compnd.memb[i].offset<offset &&
-	   parent->u.compnd.memb[i].offset+
-	   parent->u.compnd.memb[i].type.size > offset)) {
-	 HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINSERT, FAIL,
-			"member overlaps with another member");
-      }
-   }
-   
-   /* Increase member array if necessary */
-   if (parent->u.compnd.nmembs>=parent->u.compnd.nalloc) {
-      parent->u.compnd.nalloc += H5T_COMPND_INC;
-      parent->u.compnd.memb = H5MM_xrealloc (parent->u.compnd.memb,
-					     (parent->u.compnd.nalloc*
-					      sizeof(H5T_member_t)));
-   }
-
-   /* Add member to end of member array */
-   i = parent->u.compnd.nmembs;
-   parent->u.compnd.memb[i].name = H5MM_xstrdup (name);
-   parent->u.compnd.memb[i].offset = offset;
-   parent->u.compnd.memb[i].ndims = 0; /*defaults to scalar*/
-   
-   tmp = H5T_copy (member);
-   parent->u.compnd.memb[i].type = *tmp;
-   H5MM_xfree (tmp);
-
-   parent->u.compnd.nmembs++;
-   FUNC_LEAVE (SUCCEED);
+    intn                    i;
+    H5T_t                  *tmp = NULL;
+
+    FUNC_ENTER(H5T_insert, FAIL);
+
+    /* check args */
+    assert(parent && H5T_COMPOUND == parent->type);
+    assert(!parent->locked);
+    assert(member);
+    assert(name && *name);
+
+    /* Does NAME already exist in PARENT? */
+    for (i = 0; i < parent->u.compnd.nmembs; i++) {
+        if (!HDstrcmp(parent->u.compnd.memb[i].name, name)) {
+            HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINSERT, FAIL,
+                          "member name is not unique");
+        }
+    }
+
+    /* Does the new member overlap any existing member ? */
+    for (i = 0; i < parent->u.compnd.nmembs; i++) {
+        if ((offset < parent->u.compnd.memb[i].offset &&
+             offset + member->size > parent->u.compnd.memb[i].offset) ||
+            (parent->u.compnd.memb[i].offset < offset &&
+             parent->u.compnd.memb[i].offset +
+             parent->u.compnd.memb[i].type.size > offset)) {
+            HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINSERT, FAIL,
+                          "member overlaps with another member");
+        }
+    }
+
+    /* Increase member array if necessary */
+    if (parent->u.compnd.nmembs >= parent->u.compnd.nalloc) {
+        parent->u.compnd.nalloc += H5T_COMPND_INC;
+        parent->u.compnd.memb = H5MM_xrealloc(parent->u.compnd.memb,
+                                              (parent->u.compnd.nalloc *
+                                               sizeof(H5T_member_t)));
+    }
+    /* Add member to end of member array */
+    i = parent->u.compnd.nmembs;
+    parent->u.compnd.memb[i].name = H5MM_xstrdup(name);
+    parent->u.compnd.memb[i].offset = offset;
+    parent->u.compnd.memb[i].ndims = 0;         /*defaults to scalar */
+
+    tmp = H5T_copy(member);
+    parent->u.compnd.memb[i].type = *tmp;
+    H5MM_xfree(tmp);
+
+    parent->u.compnd.nmembs++;
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5T_pack
+ * Function:    H5T_pack
  *
- * Purpose:	Recursively packs a compound data type by removing padding
- *		bytes. This is done in place (that is, destructively).
+ * Purpose:     Recursively packs a compound data type by removing padding
+ *              bytes. This is done in place (that is, destructively).
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
@@ -2671,52 +2565,50 @@ H5T_insert (H5T_t *parent, const char *name, off_t offset, const H5T_t *member)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5T_pack (H5T_t *dt)
+H5T_pack(H5T_t *dt)
 {
-   int		i;
-   size_t	offset;
-   
-   FUNC_ENTER (H5T_pack, FAIL);
-
-   assert (dt);
-   assert (!dt->locked);
-
-   if (H5T_COMPOUND==dt->type) {
-      /* Recursively pack the members */
-      for (i=0; i<dt->u.compnd.nmembs; i++) {
-	 if (H5T_pack (&(dt->u.compnd.memb[i].type))<0) {
-	    HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, FAIL,
-			   "unable to pack part of a compound data type");
-	 }
-      }
-
-      /* Remove padding between members */
-      H5T_sort_by_offset (dt);
-      for (i=0, offset=0; i<dt->u.compnd.nmembs; i++) {
-	 dt->u.compnd.memb[i].offset = offset;
-	 offset += dt->u.compnd.memb[i].type.size;
-      }
-
-      /* Change total size */
-      dt->size = MAX (1, offset);
-   }
-
-   FUNC_LEAVE (SUCCEED);
+    int                     i;
+    size_t                  offset;
+
+    FUNC_ENTER(H5T_pack, FAIL);
+
+    assert(dt);
+    assert(!dt->locked);
+
+    if (H5T_COMPOUND == dt->type) {
+        /* Recursively pack the members */
+        for (i = 0; i < dt->u.compnd.nmembs; i++) {
+            if (H5T_pack(&(dt->u.compnd.memb[i].type)) < 0) {
+                HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, FAIL,
+                              "unable to pack part of a compound data type");
+            }
+        }
+
+        /* Remove padding between members */
+        H5T_sort_by_offset(dt);
+        for (i = 0, offset = 0; i < dt->u.compnd.nmembs; i++) {
+            dt->u.compnd.memb[i].offset = offset;
+            offset += dt->u.compnd.memb[i].type.size;
+        }
+
+        /* Change total size */
+        dt->size = MAX(1, offset);
+    }
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5T_sort_by_offset
+ * Function:    H5T_sort_by_offset
  *
- * Purpose:	Sorts the members of a compound data type by their offsets.
- *		This even works for locked data types since it doesn't change
- *		the value of the type.
+ * Purpose:     Sorts the members of a compound data type by their offsets.
+ *              This even works for locked data types since it doesn't change
+ *              the value of the type.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
@@ -2724,54 +2616,52 @@ H5T_pack (H5T_t *dt)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5T_sort_by_offset (H5T_t *dt)
+H5T_sort_by_offset(H5T_t *dt)
 {
-   int		i, j, nmembs;
-   hbool_t	swapped;
-   
-   FUNC_ENTER (H5T_sort_by_offset, FAIL);
-
-   /* Check args */
-   assert (dt);
-   assert (H5T_COMPOUND==dt->type);
-
-   /* Use a bubble sort because we can short circuit */
-   nmembs = dt->u.compnd.nmembs;
-   for (i=nmembs-1, swapped=TRUE; i>0 && swapped; --i) {
-      for (j=0, swapped=FALSE; j<i; j++) {
-	 if (dt->u.compnd.memb[j].offset>dt->u.compnd.memb[j+1].offset) {
-	    H5T_member_t tmp = dt->u.compnd.memb[j];
-	    dt->u.compnd.memb[j] = dt->u.compnd.memb[j+1];
-	    dt->u.compnd.memb[j+1] = tmp;
-	    swapped = 1;
-	 }
-      }
-   }
+    int                     i, j, nmembs;
+    hbool_t                 swapped;
+
+    FUNC_ENTER(H5T_sort_by_offset, FAIL);
+
+    /* Check args */
+    assert(dt);
+    assert(H5T_COMPOUND == dt->type);
+
+    /* Use a bubble sort because we can short circuit */
+    nmembs = dt->u.compnd.nmembs;
+    for (i = nmembs - 1, swapped = TRUE; i > 0 && swapped; --i) {
+        for (j = 0, swapped = FALSE; j < i; j++) {
+            if (dt->u.compnd.memb[j].offset > dt->u.compnd.memb[j + 1].offset) {
+                H5T_member_t            tmp = dt->u.compnd.memb[j];
+                dt->u.compnd.memb[j] = dt->u.compnd.memb[j + 1];
+                dt->u.compnd.memb[j + 1] = tmp;
+                swapped = 1;
+            }
+        }
+    }
 
 #ifndef NDEBUG
-   /* I never trust a sort :-) */
-   for (i=0; i<dt->u.compnd.nmembs-1; i++) {
-      assert (dt->u.compnd.memb[i].offset<dt->u.compnd.memb[i+1].offset);
-   }
+    /* I never trust a sort :-) */
+    for (i = 0; i < dt->u.compnd.nmembs - 1; i++) {
+        assert(dt->u.compnd.memb[i].offset < dt->u.compnd.memb[i + 1].offset);
+    }
 #endif
 
-   FUNC_LEAVE (SUCCEED);
+    FUNC_LEAVE(SUCCEED);
 }
-
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5T_cmp
+ * Function:    H5T_cmp
  *
- * Purpose:	Compares two data types.
+ * Purpose:     Compares two data types.
  *
- * Return:	Success:	0 if DT1 and DT2 are equal.
- *				<0 if DT1 is less than DT2.
- * 				>0 if DT1 is greater than DT2.
+ * Return:      Success:        0 if DT1 and DT2 are equal.
+ *                              <0 if DT1 is less than DT2.
+ *                              >0 if DT1 is greater than DT2.
  *
- *		Failure:	0, never fails
+ *              Failure:        0, never fails
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, December 10, 1997
  *
  * Modifications:
@@ -2779,213 +2669,264 @@ H5T_sort_by_offset (H5T_t *dt)
  *-------------------------------------------------------------------------
  */
 intn
-H5T_cmp (const H5T_t *dt1, const H5T_t *dt2)
+H5T_cmp(const H5T_t *dt1, const H5T_t *dt2)
 {
-   intn		*idx1=NULL, *idx2=NULL;
-   intn		ret_value = 0;
-   intn		i, j, tmp;
-   hbool_t	swapped;
-   
-   FUNC_ENTER (H5T_equal, 0);
-
-   /* check args */
-   assert (dt1);
-   assert (dt2);
-
-   /* the easy case */
-   if (dt1==dt2) HGOTO_DONE (0);
-
-   /* compare */
-   if (dt1->type < dt2->type) HGOTO_DONE (-1);
-   if (dt1->type > dt2->type) HGOTO_DONE (1);
-
-   if (dt1->size < dt2->size) HGOTO_DONE (-1);
-   if (dt1->size > dt2->size) HGOTO_DONE (1);
-
-   if (H5T_COMPOUND==dt1->type) {
-      /*
-       * Compound data types...
-       */
-      if (dt1->u.compnd.nmembs < dt2->u.compnd.nmembs) HGOTO_DONE (-1);
-      if (dt1->u.compnd.nmembs > dt2->u.compnd.nmembs) HGOTO_DONE (1);
-
-      /* Build an index for each type so the names are sorted */
-      idx1 = H5MM_xmalloc (dt1->u.compnd.nmembs * sizeof(intn));
-      idx2 = H5MM_xmalloc (dt1->u.compnd.nmembs * sizeof(intn));
-      for (i=0; i<dt1->u.compnd.nmembs; i++) idx1[i] = idx2[i] = i;
-      for (i=dt1->u.compnd.nmembs-1, swapped=TRUE; swapped && i>=0; --i) {
-	 for (j=0, swapped=FALSE; j<i; j++) {
-	    if (HDstrcmp (dt1->u.compnd.memb[idx1[j]].name,
-			  dt1->u.compnd.memb[idx1[j+1]].name)>0) {
-	       tmp = idx1[j];
-	       idx1[j] = idx1[j+1];
-	       idx1[j+1] = tmp;
-	       swapped = TRUE;
-	    }
-	 }
-      }
-      for (i=dt1->u.compnd.nmembs-1, swapped=TRUE; swapped && i>=0; --i) {
-	 for (j=0, swapped=FALSE; j<i; j++) {
-	    if (HDstrcmp (dt2->u.compnd.memb[idx2[j]].name,
-			  dt2->u.compnd.memb[idx2[j+1]].name)>0) {
-	       tmp = idx2[j];
-	       idx2[j] = idx2[j+1];
-	       idx2[j+1] = tmp;
-	       swapped = TRUE;
-	    }
-	 }
-      }
-      
+    intn                   *idx1 = NULL, *idx2 = NULL;
+    intn                    ret_value = 0;
+    intn                    i, j, tmp;
+    hbool_t                 swapped;
+
+    FUNC_ENTER(H5T_equal, 0);
+
+    /* check args */
+    assert(dt1);
+    assert(dt2);
+
+    /* the easy case */
+    if (dt1 == dt2)
+        HGOTO_DONE(0);
+
+    /* compare */
+    if (dt1->type < dt2->type)
+        HGOTO_DONE(-1);
+    if (dt1->type > dt2->type)
+        HGOTO_DONE(1);
+
+    if (dt1->size < dt2->size)
+        HGOTO_DONE(-1);
+    if (dt1->size > dt2->size)
+        HGOTO_DONE(1);
+
+    if (H5T_COMPOUND == dt1->type) {
+        /*
+         * Compound data types...
+         */
+        if (dt1->u.compnd.nmembs < dt2->u.compnd.nmembs)
+            HGOTO_DONE(-1);
+        if (dt1->u.compnd.nmembs > dt2->u.compnd.nmembs)
+            HGOTO_DONE(1);
+
+        /* Build an index for each type so the names are sorted */
+        idx1 = H5MM_xmalloc(dt1->u.compnd.nmembs * sizeof(intn));
+        idx2 = H5MM_xmalloc(dt1->u.compnd.nmembs * sizeof(intn));
+        for (i = 0; i < dt1->u.compnd.nmembs; i++)
+            idx1[i] = idx2[i] = i;
+        for (i = dt1->u.compnd.nmembs - 1, swapped = TRUE; swapped && i >= 0; --i) {
+            for (j = 0, swapped = FALSE; j < i; j++) {
+                if (HDstrcmp(dt1->u.compnd.memb[idx1[j]].name,
+                             dt1->u.compnd.memb[idx1[j + 1]].name) > 0) {
+                    tmp = idx1[j];
+                    idx1[j] = idx1[j + 1];
+                    idx1[j + 1] = tmp;
+                    swapped = TRUE;
+                }
+            }
+        }
+        for (i = dt1->u.compnd.nmembs - 1, swapped = TRUE; swapped && i >= 0; --i) {
+            for (j = 0, swapped = FALSE; j < i; j++) {
+                if (HDstrcmp(dt2->u.compnd.memb[idx2[j]].name,
+                             dt2->u.compnd.memb[idx2[j + 1]].name) > 0) {
+                    tmp = idx2[j];
+                    idx2[j] = idx2[j + 1];
+                    idx2[j + 1] = tmp;
+                    swapped = TRUE;
+                }
+            }
+        }
+
 #ifndef NDEBUG
-      /* I don't quite trust the code above yet :-)  --RPM */
-      for (i=0; i<dt1->u.compnd.nmembs; i++) {
-	 assert (HDstrcmp (dt1->u.compnd.memb[idx1[i]].name,
-			   dt1->u.compnd.memb[idx1[i+1]].name));
-	 assert (HDstrcmp (dt2->u.compnd.memb[idx2[i]].name,
-			   dt2->u.compnd.memb[idx2[i+1]].name));
-      }
+        /* I don't quite trust the code above yet :-)  --RPM */
+        for (i = 0; i < dt1->u.compnd.nmembs; i++) {
+            assert(HDstrcmp(dt1->u.compnd.memb[idx1[i]].name,
+                            dt1->u.compnd.memb[idx1[i + 1]].name));
+            assert(HDstrcmp(dt2->u.compnd.memb[idx2[i]].name,
+                            dt2->u.compnd.memb[idx2[i + 1]].name));
+        }
 #endif
 
-      /* Compare the members */
-      for (i=0; i<dt1->u.compnd.nmembs; i++) {
-	 tmp = HDstrcmp (dt1->u.compnd.memb[idx1[i]].name,
-			 dt2->u.compnd.memb[idx2[i]].name);
-	 if (tmp<0) HGOTO_DONE (-1);
-	 if (tmp>0) HGOTO_DONE (1);
-
-	 if (dt1->u.compnd.memb[idx1[i]].offset <
-	     dt2->u.compnd.memb[idx2[i]].offset) HGOTO_DONE (-1);
-	 if (dt1->u.compnd.memb[idx1[i]].offset >
-	     dt2->u.compnd.memb[idx2[i]].offset) HGOTO_DONE (1);
-
-	 if (dt1->u.compnd.memb[idx1[i]].ndims <
-	     dt2->u.compnd.memb[idx2[i]].ndims) HGOTO_DONE (-1);
-	 if (dt1->u.compnd.memb[idx1[i]].ndims >
-	     dt2->u.compnd.memb[idx2[i]].ndims) HGOTO_DONE (1);
-
-	 for (j=0; j<dt1->u.compnd.memb[idx1[i]].ndims; j++) {
-	    if (dt1->u.compnd.memb[idx1[i]].dim[j] <
-		dt2->u.compnd.memb[idx2[i]].dim[j]) HGOTO_DONE (-1);
-	    if (dt1->u.compnd.memb[idx1[i]].dim[j] >
-		dt2->u.compnd.memb[idx2[i]].dim[j]) HGOTO_DONE (1);
-	 }
-	 
-	 for (j=0; j<dt1->u.compnd.memb[idx1[i]].ndims; j++) {
-	    if (dt1->u.compnd.memb[idx1[i]].perm[j] <
-		dt2->u.compnd.memb[idx2[i]].perm[j]) HGOTO_DONE (-1);
-	    if (dt1->u.compnd.memb[idx1[i]].perm[j] >
-		dt2->u.compnd.memb[idx2[i]].perm[j]) HGOTO_DONE (1);
-	 }
-
-	 tmp = H5T_cmp (&(dt1->u.compnd.memb[idx1[i]].type),
-			&(dt2->u.compnd.memb[idx2[i]].type));
-	 if (tmp<0) HGOTO_DONE (-1);
-	 if (tmp>0) HGOTO_DONE (1);
-      }
-      
-   } else {
-      /*
-       * Atomic data types...
-       */
-      if (dt1->u.atomic.order < dt2->u.atomic.order) HGOTO_DONE (-1);
-      if (dt1->u.atomic.order > dt2->u.atomic.order) HGOTO_DONE (1);
-
-      if (dt1->u.atomic.prec < dt2->u.atomic.prec) HGOTO_DONE (-1);
-      if (dt1->u.atomic.prec > dt2->u.atomic.prec) HGOTO_DONE (1);
-
-      if (dt1->u.atomic.offset < dt2->u.atomic.offset) HGOTO_DONE (-1);
-      if (dt1->u.atomic.offset > dt2->u.atomic.offset) HGOTO_DONE (1);
-      
-      if (dt1->u.atomic.lsb_pad < dt2->u.atomic.lsb_pad) HGOTO_DONE (-1);
-      if (dt1->u.atomic.lsb_pad > dt2->u.atomic.lsb_pad) HGOTO_DONE (1);
-      
-      if (dt1->u.atomic.msb_pad < dt2->u.atomic.msb_pad) HGOTO_DONE (-1);
-      if (dt1->u.atomic.msb_pad > dt2->u.atomic.msb_pad) HGOTO_DONE (1);
-
-      switch (dt1->type) {
-      case H5T_INTEGER:
-	 if (dt1->u.atomic.u.i.sign < dt2->u.atomic.u.i.sign) HGOTO_DONE (-1);
-	 if (dt1->u.atomic.u.i.sign > dt2->u.atomic.u.i.sign) HGOTO_DONE (1);
-	 break;
-
-      case H5T_FLOAT:
-	 if (dt1->u.atomic.u.f.sign < dt2->u.atomic.u.f.sign) HGOTO_DONE (-1);
-	 if (dt1->u.atomic.u.f.sign > dt2->u.atomic.u.f.sign) HGOTO_DONE (1);
-	 
-	 if (dt1->u.atomic.u.f.epos < dt2->u.atomic.u.f.epos) HGOTO_DONE (-1);
-	 if (dt1->u.atomic.u.f.epos > dt2->u.atomic.u.f.epos) HGOTO_DONE (1);
-	 
-	 if (dt1->u.atomic.u.f.esize <
-	     dt2->u.atomic.u.f.esize) HGOTO_DONE (-1);
-	 if (dt1->u.atomic.u.f.esize >
-	     dt2->u.atomic.u.f.esize) HGOTO_DONE (1);
-	 
-	 if (dt1->u.atomic.u.f.ebias <
-	     dt2->u.atomic.u.f.ebias) HGOTO_DONE (-1);
-	 if (dt1->u.atomic.u.f.ebias >
-	     dt2->u.atomic.u.f.ebias) HGOTO_DONE (1);
-	 
-	 if (dt1->u.atomic.u.f.mpos < dt2->u.atomic.u.f.mpos) HGOTO_DONE (-1);
-	 if (dt1->u.atomic.u.f.mpos > dt2->u.atomic.u.f.mpos) HGOTO_DONE (1);
-	 
-	 if (dt1->u.atomic.u.f.msize <
-	     dt2->u.atomic.u.f.msize) HGOTO_DONE (-1);
-	 if (dt1->u.atomic.u.f.msize >
-	     dt2->u.atomic.u.f.msize) HGOTO_DONE (1);
-	 
-	 if (dt1->u.atomic.u.f.norm < dt2->u.atomic.u.f.norm) HGOTO_DONE (-1);
-	 if (dt1->u.atomic.u.f.norm > dt2->u.atomic.u.f.norm) HGOTO_DONE (1);
-	 
-	 if (dt1->u.atomic.u.f.pad < dt2->u.atomic.u.f.pad) HGOTO_DONE (-1);
-	 if (dt1->u.atomic.u.f.pad > dt2->u.atomic.u.f.pad) HGOTO_DONE (1);
-
-	 break;
-
-      case H5T_TIME:
-	 /*void*/
-	 break;
-
-      case H5T_STRING:
-	 if (dt1->u.atomic.u.s.cset < dt1->u.atomic.u.s.cset) HGOTO_DONE (-1);
-	 if (dt1->u.atomic.u.s.cset > dt1->u.atomic.u.s.cset) HGOTO_DONE (1);
-	 
-	 if (dt1->u.atomic.u.s.pad < dt1->u.atomic.u.s.pad) HGOTO_DONE (-1);
-	 if (dt1->u.atomic.u.s.pad > dt1->u.atomic.u.s.pad) HGOTO_DONE (1);
-
-	 break;
-	 
-      case H5T_BITFIELD:
-	 /*void*/
-	 break;
-
-      case H5T_OPAQUE:
-	 /*void*/
-	 break;
-
-      default:
-	 assert ("not implemented yet" && 0);
-      }
-   }
-
- done:
-   H5MM_xfree (idx1);
-   H5MM_xfree (idx2);
-
-   FUNC_LEAVE (ret_value);
+        /* Compare the members */
+        for (i = 0; i < dt1->u.compnd.nmembs; i++) {
+            tmp = HDstrcmp(dt1->u.compnd.memb[idx1[i]].name,
+                           dt2->u.compnd.memb[idx2[i]].name);
+            if (tmp < 0)
+                HGOTO_DONE(-1);
+            if (tmp > 0)
+                HGOTO_DONE(1);
+
+            if (dt1->u.compnd.memb[idx1[i]].offset <
+                dt2->u.compnd.memb[idx2[i]].offset)
+                HGOTO_DONE(-1);
+            if (dt1->u.compnd.memb[idx1[i]].offset >
+                dt2->u.compnd.memb[idx2[i]].offset)
+                HGOTO_DONE(1);
+
+            if (dt1->u.compnd.memb[idx1[i]].ndims <
+                dt2->u.compnd.memb[idx2[i]].ndims)
+                HGOTO_DONE(-1);
+            if (dt1->u.compnd.memb[idx1[i]].ndims >
+                dt2->u.compnd.memb[idx2[i]].ndims)
+                HGOTO_DONE(1);
+
+            for (j = 0; j < dt1->u.compnd.memb[idx1[i]].ndims; j++) {
+                if (dt1->u.compnd.memb[idx1[i]].dim[j] <
+                    dt2->u.compnd.memb[idx2[i]].dim[j])
+                    HGOTO_DONE(-1);
+                if (dt1->u.compnd.memb[idx1[i]].dim[j] >
+                    dt2->u.compnd.memb[idx2[i]].dim[j])
+                    HGOTO_DONE(1);
+            }
+
+            for (j = 0; j < dt1->u.compnd.memb[idx1[i]].ndims; j++) {
+                if (dt1->u.compnd.memb[idx1[i]].perm[j] <
+                    dt2->u.compnd.memb[idx2[i]].perm[j])
+                    HGOTO_DONE(-1);
+                if (dt1->u.compnd.memb[idx1[i]].perm[j] >
+                    dt2->u.compnd.memb[idx2[i]].perm[j])
+                    HGOTO_DONE(1);
+            }
+
+            tmp = H5T_cmp(&(dt1->u.compnd.memb[idx1[i]].type),
+                          &(dt2->u.compnd.memb[idx2[i]].type));
+            if (tmp < 0)
+                HGOTO_DONE(-1);
+            if (tmp > 0)
+                HGOTO_DONE(1);
+        }
+
+    } else {
+        /*
+         * Atomic data types...
+         */
+        if (dt1->u.atomic.order < dt2->u.atomic.order)
+            HGOTO_DONE(-1);
+        if (dt1->u.atomic.order > dt2->u.atomic.order)
+            HGOTO_DONE(1);
+
+        if (dt1->u.atomic.prec < dt2->u.atomic.prec)
+            HGOTO_DONE(-1);
+        if (dt1->u.atomic.prec > dt2->u.atomic.prec)
+            HGOTO_DONE(1);
+
+        if (dt1->u.atomic.offset < dt2->u.atomic.offset)
+            HGOTO_DONE(-1);
+        if (dt1->u.atomic.offset > dt2->u.atomic.offset)
+            HGOTO_DONE(1);
+
+        if (dt1->u.atomic.lsb_pad < dt2->u.atomic.lsb_pad)
+            HGOTO_DONE(-1);
+        if (dt1->u.atomic.lsb_pad > dt2->u.atomic.lsb_pad)
+            HGOTO_DONE(1);
+
+        if (dt1->u.atomic.msb_pad < dt2->u.atomic.msb_pad)
+            HGOTO_DONE(-1);
+        if (dt1->u.atomic.msb_pad > dt2->u.atomic.msb_pad)
+            HGOTO_DONE(1);
+
+        switch (dt1->type) {
+        case H5T_INTEGER:
+            if (dt1->u.atomic.u.i.sign < dt2->u.atomic.u.i.sign)
+                HGOTO_DONE(-1);
+            if (dt1->u.atomic.u.i.sign > dt2->u.atomic.u.i.sign)
+                HGOTO_DONE(1);
+            break;
+
+        case H5T_FLOAT:
+            if (dt1->u.atomic.u.f.sign < dt2->u.atomic.u.f.sign)
+                HGOTO_DONE(-1);
+            if (dt1->u.atomic.u.f.sign > dt2->u.atomic.u.f.sign)
+                HGOTO_DONE(1);
+
+            if (dt1->u.atomic.u.f.epos < dt2->u.atomic.u.f.epos)
+                HGOTO_DONE(-1);
+            if (dt1->u.atomic.u.f.epos > dt2->u.atomic.u.f.epos)
+                HGOTO_DONE(1);
+
+            if (dt1->u.atomic.u.f.esize <
+                dt2->u.atomic.u.f.esize)
+                HGOTO_DONE(-1);
+            if (dt1->u.atomic.u.f.esize >
+                dt2->u.atomic.u.f.esize)
+                HGOTO_DONE(1);
+
+            if (dt1->u.atomic.u.f.ebias <
+                dt2->u.atomic.u.f.ebias)
+                HGOTO_DONE(-1);
+            if (dt1->u.atomic.u.f.ebias >
+                dt2->u.atomic.u.f.ebias)
+                HGOTO_DONE(1);
+
+            if (dt1->u.atomic.u.f.mpos < dt2->u.atomic.u.f.mpos)
+                HGOTO_DONE(-1);
+            if (dt1->u.atomic.u.f.mpos > dt2->u.atomic.u.f.mpos)
+                HGOTO_DONE(1);
+
+            if (dt1->u.atomic.u.f.msize <
+                dt2->u.atomic.u.f.msize)
+                HGOTO_DONE(-1);
+            if (dt1->u.atomic.u.f.msize >
+                dt2->u.atomic.u.f.msize)
+                HGOTO_DONE(1);
+
+            if (dt1->u.atomic.u.f.norm < dt2->u.atomic.u.f.norm)
+                HGOTO_DONE(-1);
+            if (dt1->u.atomic.u.f.norm > dt2->u.atomic.u.f.norm)
+                HGOTO_DONE(1);
+
+            if (dt1->u.atomic.u.f.pad < dt2->u.atomic.u.f.pad)
+                HGOTO_DONE(-1);
+            if (dt1->u.atomic.u.f.pad > dt2->u.atomic.u.f.pad)
+                HGOTO_DONE(1);
+
+            break;
+
+        case H5T_TIME:
+            /*void */
+            break;
+
+        case H5T_STRING:
+            if (dt1->u.atomic.u.s.cset < dt1->u.atomic.u.s.cset)
+                HGOTO_DONE(-1);
+            if (dt1->u.atomic.u.s.cset > dt1->u.atomic.u.s.cset)
+                HGOTO_DONE(1);
+
+            if (dt1->u.atomic.u.s.pad < dt1->u.atomic.u.s.pad)
+                HGOTO_DONE(-1);
+            if (dt1->u.atomic.u.s.pad > dt1->u.atomic.u.s.pad)
+                HGOTO_DONE(1);
+
+            break;
+
+        case H5T_BITFIELD:
+            /*void */
+            break;
+
+        case H5T_OPAQUE:
+            /*void */
+            break;
+
+        default:
+            assert("not implemented yet" && 0);
+        }
+    }
+
+  done:
+    H5MM_xfree(idx1);
+    H5MM_xfree(idx2);
+
+    FUNC_LEAVE(ret_value);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5T_find
+ * Function:    H5T_find
  *
- * Purpose:	Finds a conversion function for the specified path.
+ * Purpose:     Finds a conversion function for the specified path.
  *
- * Return:	Success:	A pointer to an appropriate conversion
- *				function.
+ * Return:      Success:        A pointer to an appropriate conversion
+ *                              function.
  *
- *		Failure:	NULL
+ *              Failure:        NULL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January 14, 1998
  *
  * Modifications:
@@ -2993,143 +2934,142 @@ H5T_cmp (const H5T_t *dt1, const H5T_t *dt2)
  *-------------------------------------------------------------------------
  */
 H5T_conv_t
-H5T_find (const H5T_t *src, const H5T_t *dst)
+H5T_find(const H5T_t *src, const H5T_t *dst)
 {
-   H5T_path_t	*path = NULL;
-   H5T_conv_t	ret_value = NULL;
-   
-   FUNC_ENTER (H5T_find, NULL);
-
-   /* Check args */
-   assert (src);
-   assert (dst);
-
-   /* No-op case */
-   if (0==H5T_cmp (src, dst)) HRETURN (H5T_conv_noop);
-
-   /* Find it */
-   if (NULL==(path=H5T_path_find (src, dst, TRUE))) {
-      HRETURN_ERROR (H5E_DATATYPE, H5E_CANTINIT, NULL,
-		     "unable to create conversion path");
-   }
-   ret_value = path->hard;
-   if (!ret_value) ret_value = path->soft;
-
-   if (!ret_value) {
-      HRETURN_ERROR (H5E_DATATYPE, H5E_NOTFOUND, NULL,
-		     "no conversion function for that path");
-   }
-
-   FUNC_LEAVE (ret_value);
+    H5T_path_t             *path = NULL;
+    H5T_conv_t              ret_value = NULL;
+
+    FUNC_ENTER(H5T_find, NULL);
+
+    /* Check args */
+    assert(src);
+    assert(dst);
+
+    /* No-op case */
+    if (0 == H5T_cmp(src, dst))
+        HRETURN(H5T_conv_noop);
+
+    /* Find it */
+    if (NULL == (path = H5T_path_find(src, dst, TRUE))) {
+        HRETURN_ERROR(H5E_DATATYPE, H5E_CANTINIT, NULL,
+                      "unable to create conversion path");
+    }
+    ret_value = path->hard;
+    if (!ret_value)
+        ret_value = path->soft;
+
+    if (!ret_value) {
+        HRETURN_ERROR(H5E_DATATYPE, H5E_NOTFOUND, NULL,
+                      "no conversion function for that path");
+    }
+    FUNC_LEAVE(ret_value);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5T_path_find
+ * Function:    H5T_path_find
  *
- * Purpose:	Finds the path which converts type SRC_ID to type DST_ID.  If
- *		the path isn't found and CREATE is non-zero then a new path
- *		is created.
+ * Purpose:     Finds the path which converts type SRC_ID to type DST_ID.  If
+ *              the path isn't found and CREATE is non-zero then a new path
+ *              is created.
  *
- * Return:	Success:	Pointer to the path, valid until the path
- *				database is modified.
+ * Return:      Success:        Pointer to the path, valid until the path
+ *                              database is modified.
  *
- *		Failure:	NULL
+ *              Failure:        NULL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Tuesday, January 13, 1998
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
-H5T_path_t *
-H5T_path_find (const H5T_t *src, const H5T_t *dst, hbool_t create)
+H5T_path_t             *
+H5T_path_find(const H5T_t *src, const H5T_t *dst, hbool_t create)
 {
-   intn		lt = 0;			/*left edge (inclusive)		*/
-   intn		rt = H5T_npath_g;	/*right edge (exclusive)	*/
-   intn		md = 0;			/*middle			*/
-   intn		cmp = -1;		/*comparison result		*/
-   H5T_path_t	*path = NULL;		/*path found			*/
-   int		i;
-   hid_t	src_id, dst_id;
-   
-   FUNC_ENTER (H5T_path_find, NULL);
-
-   /* Check args */
-   assert (src);
-   assert (dst);
-
-   /* Binary search */
-   while (lt<rt) {
-      md = (lt+rt)/2;
-
-      cmp = H5T_cmp (src, H5T_path_g[md].src);
-      if (0==cmp) cmp = H5T_cmp (dst, H5T_path_g[md].dst);
-
-      if (cmp<0) {
-	 rt = md;
-      } else if (cmp>0) {
-	 lt = md+1;
-      } else {
-	 HRETURN (H5T_path_g+md);
-      }
-   }
-   
-   /* Insert */
-   if (create) {
-      if (H5T_npath_g>=H5T_apath_g) {
-	 H5T_apath_g = MAX (64, 2*H5T_apath_g);
-	 H5T_path_g = H5MM_xrealloc (H5T_path_g,
-				     H5T_apath_g*sizeof(H5T_path_t));
-      }
-      if (cmp>0) md++;
-
-      /* make room */
-      HDmemmove (H5T_path_g+md+1, H5T_path_g+md,
-		 (H5T_npath_g-md)*sizeof(H5T_path_t));
-      H5T_npath_g++;
-
-      /* insert */
-      path = H5T_path_g + md;
-      HDmemset (path, 0, sizeof(H5T_path_t));
-      path->src = H5T_copy (src);
-      path->dst = H5T_copy (dst);
-
-      /* Locate soft function */
-      for (i=H5T_nsoft_g-1; i>=0 && !path->soft; --i) {
-	 if (src->type!=H5T_soft_g[i].src || dst->type!=H5T_soft_g[i].dst) {
-	    continue;
-	 }
-	 
-	 if ((src_id=H5Aregister_atom (H5_DATATYPE, H5T_copy (path->src)))<0 ||
-	     (dst_id=H5Aregister_atom (H5_DATATYPE, H5T_copy (path->dst)))<0) {
-	    HRETURN_ERROR (H5E_DATATYPE, H5E_CANTREGISTER, NULL,
-			   "unable to register conv types for query");
-	 }
-	 if ((H5T_soft_g[i].func)(src_id, dst_id, 0, NULL, NULL)>=0) {
-	    path->soft = H5T_soft_g[i].func;
-	 }
-	 H5A_dec_ref (src_id);
-	 H5A_dec_ref (dst_id);
-	 H5ECLEAR;
-      }
-   }
-
-   FUNC_LEAVE (path);
+    intn                    lt = 0;     /*left edge (inclusive)         */
+    intn                    rt = H5T_npath_g;   /*right edge (exclusive)        */
+    intn                    md = 0;     /*middle                        */
+    intn                    cmp = -1;   /*comparison result             */
+    H5T_path_t             *path = NULL;        /*path found                    */
+    int                     i;
+    hid_t                   src_id, dst_id;
+
+    FUNC_ENTER(H5T_path_find, NULL);
+
+    /* Check args */
+    assert(src);
+    assert(dst);
+
+    /* Binary search */
+    while (lt < rt) {
+        md = (lt + rt) / 2;
+
+        cmp = H5T_cmp(src, H5T_path_g[md].src);
+        if (0 == cmp)
+            cmp = H5T_cmp(dst, H5T_path_g[md].dst);
+
+        if (cmp < 0) {
+            rt = md;
+        } else if (cmp > 0) {
+            lt = md + 1;
+        } else {
+            HRETURN(H5T_path_g + md);
+        }
+    }
+
+    /* Insert */
+    if (create) {
+        if (H5T_npath_g >= H5T_apath_g) {
+            H5T_apath_g = MAX(64, 2 * H5T_apath_g);
+            H5T_path_g = H5MM_xrealloc(H5T_path_g,
+                                       H5T_apath_g * sizeof(H5T_path_t));
+        }
+        if (cmp > 0)
+            md++;
+
+        /* make room */
+        HDmemmove(H5T_path_g + md + 1, H5T_path_g + md,
+                  (H5T_npath_g - md) * sizeof(H5T_path_t));
+        H5T_npath_g++;
+
+        /* insert */
+        path = H5T_path_g + md;
+        HDmemset(path, 0, sizeof(H5T_path_t));
+        path->src = H5T_copy(src);
+        path->dst = H5T_copy(dst);
+
+        /* Locate soft function */
+        for (i = H5T_nsoft_g - 1; i >= 0 && !path->soft; --i) {
+            if (src->type != H5T_soft_g[i].src || dst->type != H5T_soft_g[i].dst) {
+                continue;
+            }
+            if ((src_id = H5Aregister_atom(H5_DATATYPE, H5T_copy(path->src))) < 0 ||
+                (dst_id = H5Aregister_atom(H5_DATATYPE, H5T_copy(path->dst))) < 0) {
+                HRETURN_ERROR(H5E_DATATYPE, H5E_CANTREGISTER, NULL,
+                              "unable to register conv types for query");
+            }
+            if ((H5T_soft_g[i].func) (src_id, dst_id, 0, NULL, NULL) >= 0) {
+                path->soft = H5T_soft_g[i].func;
+            }
+            H5A_dec_ref(src_id);
+            H5A_dec_ref(dst_id);
+            H5ECLEAR;
+        }
+    }
+    FUNC_LEAVE(path);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5T_debug
+ * Function:    H5T_debug
  *
- * Purpose:	Prints information about a data type.
+ * Purpose:     Prints information about a data type.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, January  7, 1998
  *
  * Modifications:
@@ -3137,153 +3077,150 @@ H5T_path_find (const H5T_t *src, const H5T_t *dst, hbool_t create)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5T_debug (H5T_t *dt, FILE *stream)
+H5T_debug(H5T_t *dt, FILE * stream)
 {
-   const char	*s = "";
-   int		i, j;
-   uint64	tmp;
-
-   FUNC_ENTER (H5T_debug, FAIL);
-
-   /* Check args */
-   assert (dt);
-   assert (stream);
-
-   switch (dt->type) {
-   case H5T_INTEGER:
-      s = "int";
-      break;
-   case H5T_FLOAT:
-      s = "float";
-      break;
-   case H5T_TIME:
-      s = "time";
-      break;
-   case H5T_STRING:
-      s = "str";
-      break;
-   case H5T_BITFIELD:
-      s = "bits";
-      break;
-   case H5T_OPAQUE:
-      s = "opaque";
-      break;
-   case H5T_COMPOUND:
-      s = "struct";
-      break;
-   default:
-      s = "";
-      break;
-   }
-
-   fprintf (stream, "%s%s {nbytes=%d",
-	    s, dt->locked?"[!]":"", dt->size);
-
-   if (H5T_is_atomic (dt)) {
-      switch (dt->u.atomic.order) {
-      case H5T_ORDER_BE:
-	 s = "BE";
-	 break;
-      case H5T_ORDER_LE:
-	 s = "LE";
-	 break;
-      case H5T_ORDER_VAX:
-	 s = "VAX";
-	 break;
-      case H5T_ORDER_NONE:
-	 s = "NONE";
-	 break;
-      default:
-	 s = "order?";
-	 break;
-      }
-      fprintf (stream, ", %s", s);
-
-      if (dt->u.atomic.offset) {
-	 fprintf (stream, ", offset=%lu",
-		  (unsigned long)(dt->u.atomic.offset));
-      }
-      if (dt->u.atomic.prec!=8*dt->size) {
-	 fprintf (stream, ", prec=%lu",
-		  (unsigned long)(dt->u.atomic.prec));
-      }
-
-      switch (dt->type) {
-      case H5T_INTEGER:
-	 switch (dt->u.atomic.u.i.sign) {
-	 case H5T_SGN_NONE:
-	    s = "unsigned";
-	    break;
-	 case H5T_SGN_2:
-	    s = NULL;
-	    break;
-	 default:
-	    s = "sign?";
-	    break;
-	 }
-	 if (s) fprintf (stream, ", %s", s);
-	 break;
-
-      case H5T_FLOAT:
-	 switch (dt->u.atomic.u.f.norm) {
-	 case H5T_NORM_IMPLIED:
-	    s = "implied";
-	    break;
-	 case H5T_NORM_MSBSET:
-	    s = "msbset";
-	    break;
-	 case H5T_NORM_NONE:
-	    s = "no-norm";
-	    break;
-	 default:
-	    s = "norm?";
-	    break;
-	 }
-	 fprintf (stream, ", sign=%lu+1",
-		  (unsigned long)(dt->u.atomic.u.f.sign));
-	 fprintf (stream, ", mant=%lu+%lu (%s)",
-		  (unsigned long)(dt->u.atomic.u.f.mpos),
-		  (unsigned long)(dt->u.atomic.u.f.msize), s);
-	 fprintf (stream, ", exp=%lu+%lu",
-		  (unsigned long)(dt->u.atomic.u.f.epos),
-		  (unsigned long)(dt->u.atomic.u.f.esize));
-	 tmp = dt->u.atomic.u.f.ebias >> 32;
-	 if (tmp) {
-	    uintn hi = tmp;
-	    uintn lo = dt->u.atomic.u.f.ebias & 0xffffffff;
-	    fprintf (stream, " bias=0x%08x%08x", hi, lo);
-	 } else {
-	    uintn lo = dt->u.atomic.u.f.ebias & 0xffffffff;
-	    fprintf (stream, " bias=0x%08x", lo);
-	 }
-	 break;
-
-      default:
-	 /* No additional info */
-	 break;
-      }
-   } else {
-      for (i=0; i<dt->u.compnd.nmembs; i++) {
-	 fprintf (stream, "\n\"%s\" @%lu",
-		  dt->u.compnd.memb[i].name,
-		  (unsigned long)(dt->u.compnd.memb[i].offset));
-	 if (dt->u.compnd.memb[i].ndims) {
-	    fprintf (stream, "[");
-	    for (j=0; j<dt->u.compnd.memb[i].ndims; j++) {
-	       fprintf (stream, "%s%d", j?", ":"",
-			dt->u.compnd.memb[i].dim[j]);
-	    }
-	    fprintf (stream, "]");
-	 }
-	 fprintf (stream, " ");
-	 H5T_debug (&(dt->u.compnd.memb[i].type), stream);
-      }
-      fprintf (stream, "\n");
-   }
-   fprintf (stream, "}");
-
-   FUNC_LEAVE (SUCCEED);
+    const char             *s = "";
+    int                     i, j;
+    uint64                  tmp;
+
+    FUNC_ENTER(H5T_debug, FAIL);
+
+    /* Check args */
+    assert(dt);
+    assert(stream);
+
+    switch (dt->type) {
+    case H5T_INTEGER:
+        s = "int";
+        break;
+    case H5T_FLOAT:
+        s = "float";
+        break;
+    case H5T_TIME:
+        s = "time";
+        break;
+    case H5T_STRING:
+        s = "str";
+        break;
+    case H5T_BITFIELD:
+        s = "bits";
+        break;
+    case H5T_OPAQUE:
+        s = "opaque";
+        break;
+    case H5T_COMPOUND:
+        s = "struct";
+        break;
+    default:
+        s = "";
+        break;
+    }
+
+    fprintf(stream, "%s%s {nbytes=%d",
+            s, dt->locked ? "[!]" : "", dt->size);
+
+    if (H5T_is_atomic(dt)) {
+        switch (dt->u.atomic.order) {
+        case H5T_ORDER_BE:
+            s = "BE";
+            break;
+        case H5T_ORDER_LE:
+            s = "LE";
+            break;
+        case H5T_ORDER_VAX:
+            s = "VAX";
+            break;
+        case H5T_ORDER_NONE:
+            s = "NONE";
+            break;
+        default:
+            s = "order?";
+            break;
+        }
+        fprintf(stream, ", %s", s);
+
+        if (dt->u.atomic.offset) {
+            fprintf(stream, ", offset=%lu",
+                    (unsigned long) (dt->u.atomic.offset));
+        }
+        if (dt->u.atomic.prec != 8 * dt->size) {
+            fprintf(stream, ", prec=%lu",
+                    (unsigned long) (dt->u.atomic.prec));
+        }
+        switch (dt->type) {
+        case H5T_INTEGER:
+            switch (dt->u.atomic.u.i.sign) {
+            case H5T_SGN_NONE:
+                s = "unsigned";
+                break;
+            case H5T_SGN_2:
+                s = NULL;
+                break;
+            default:
+                s = "sign?";
+                break;
+            }
+            if (s)
+                fprintf(stream, ", %s", s);
+            break;
+
+        case H5T_FLOAT:
+            switch (dt->u.atomic.u.f.norm) {
+            case H5T_NORM_IMPLIED:
+                s = "implied";
+                break;
+            case H5T_NORM_MSBSET:
+                s = "msbset";
+                break;
+            case H5T_NORM_NONE:
+                s = "no-norm";
+                break;
+            default:
+                s = "norm?";
+                break;
+            }
+            fprintf(stream, ", sign=%lu+1",
+                    (unsigned long) (dt->u.atomic.u.f.sign));
+            fprintf(stream, ", mant=%lu+%lu (%s)",
+                    (unsigned long) (dt->u.atomic.u.f.mpos),
+                    (unsigned long) (dt->u.atomic.u.f.msize), s);
+            fprintf(stream, ", exp=%lu+%lu",
+                    (unsigned long) (dt->u.atomic.u.f.epos),
+                    (unsigned long) (dt->u.atomic.u.f.esize));
+            tmp = dt->u.atomic.u.f.ebias >> 32;
+            if (tmp) {
+                uintn                   hi = tmp;
+                uintn                   lo = dt->u.atomic.u.f.ebias & 0xffffffff;
+                fprintf(stream, " bias=0x%08x%08x", hi, lo);
+            } else {
+                uintn                   lo = dt->u.atomic.u.f.ebias & 0xffffffff;
+                fprintf(stream, " bias=0x%08x", lo);
+            }
+            break;
+
+        default:
+            /* No additional info */
+            break;
+        }
+    } else {
+        for (i = 0; i < dt->u.compnd.nmembs; i++) {
+            fprintf(stream, "\n\"%s\" @%lu",
+                    dt->u.compnd.memb[i].name,
+                    (unsigned long) (dt->u.compnd.memb[i].offset));
+            if (dt->u.compnd.memb[i].ndims) {
+                fprintf(stream, "[");
+                for (j = 0; j < dt->u.compnd.memb[i].ndims; j++) {
+                    fprintf(stream, "%s%d", j ? ", " : "",
+                            dt->u.compnd.memb[i].dim[j]);
+                }
+                fprintf(stream, "]");
+            }
+            fprintf(stream, " ");
+            H5T_debug(&(dt->u.compnd.memb[i].type), stream);
+        }
+        fprintf(stream, "\n");
+    }
+    fprintf(stream, "}");
+
+    FUNC_LEAVE(SUCCEED);
 }
-
-	 
-