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

1 files changed, 509 insertions, 535 deletions

diff --git a/src/H5P.c b/src/H5P.c
index b7266ce..4ea8117 100644
--- a/src/H5P.c
+++ b/src/H5P.c
@@ -11,26 +11,25 @@
 ****************************************************************************/
 
 #ifdef RCSID
-static char RcsId[] = "@(#)$Revision$";
+static char             RcsId[] = "@(#)$Revision$";
 #endif
 
 /* $Id$ */
 
+#include <H5private.h>          /* Generic Functions                      */
+#include <H5Aprivate.h>         /* Atom Functions                 */
+#include <H5Eprivate.h>         /* Error handling                 */
+#include <H5MMprivate.h>        /* Memory Management functions            */
+#include <H5Oprivate.h>         /*object headers                  */
+#include <H5Pprivate.h>         /* Data-space functions                   */
 
-#include <H5private.h>  	/* Generic Functions			*/
-#include <H5Aprivate.h> 	/* Atom Functions			*/
-#include <H5Eprivate.h> 	/* Error handling			*/
-#include <H5MMprivate.h> 	/* Memory Management functions		*/
-#include <H5Oprivate.h>		/*object headers			*/
-#include <H5Pprivate.h> 	/* Data-space functions			*/
-
-#define PABLO_MASK	H5P_mask
+#define PABLO_MASK      H5P_mask
 
 /* Interface initialization */
-static intn interface_initialize_g = FALSE;
-#define INTERFACE_INIT	H5P_init_interface
-static herr_t H5P_init_interface (void);
-static void H5P_term_interface (void);
+static intn             interface_initialize_g = FALSE;
+#define INTERFACE_INIT  H5P_init_interface
+static herr_t           H5P_init_interface(void);
+static void             H5P_term_interface(void);
 
 /*--------------------------------------------------------------------------
 NAME
@@ -45,19 +44,18 @@ DESCRIPTION
 
 --------------------------------------------------------------------------*/
 static herr_t
-H5P_init_interface (void)
+H5P_init_interface(void)
 {
-   herr_t ret_value = SUCCEED;
-   FUNC_ENTER (H5P_init_interface, FAIL);
-
-   /* Initialize the atom group for the file IDs */
-   if ((ret_value=H5Ainit_group (H5_DATASPACE, H5A_DATASPACEID_HASHSIZE,
-				 H5P_RESERVED_ATOMS,
-				 (herr_t (*)(void*))H5P_close))!=FAIL) {
-      ret_value=H5_add_exit(&H5P_term_interface);
-   }
-
-   FUNC_LEAVE (ret_value);
+    herr_t                  ret_value = SUCCEED;
+    FUNC_ENTER(H5P_init_interface, FAIL);
+
+    /* Initialize the atom group for the file IDs */
+    if ((ret_value = H5Ainit_group(H5_DATASPACE, H5A_DATASPACEID_HASHSIZE,
+                                   H5P_RESERVED_ATOMS,
+                                 (herr_t (*)(void *)) H5P_close)) != FAIL) {
+        ret_value = H5_add_exit(&H5P_term_interface);
+    }
+    FUNC_LEAVE(ret_value);
 }
 
 /*--------------------------------------------------------------------------
@@ -78,24 +76,23 @@ H5P_init_interface (void)
  REVISION LOG
 --------------------------------------------------------------------------*/
 static void
-H5P_term_interface (void)
+H5P_term_interface(void)
 {
-   H5Adestroy_group (H5_DATASPACE);
+    H5Adestroy_group(H5_DATASPACE);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Pcreate
+ * Function:    H5Pcreate
  *
- * Purpose:	Creates a new data space object and opens it for access.
+ * Purpose:     Creates a new data space object and opens it for access.
  *
- * Return:	Success:	The ID for the new data space object.
+ * Return:      Success:        The ID for the new data space object.
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
  * Errors:
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Tuesday, December  9, 1997
  *
  * Modifications:
@@ -103,62 +100,59 @@ H5P_term_interface (void)
  *-------------------------------------------------------------------------
  */
 hid_t
-H5Pcreate (H5P_class_t type)
+H5Pcreate(H5P_class_t type)
 {
-   H5P_t	*ds = NULL;
-   hid_t	ret_value = FAIL;
-   
-   FUNC_ENTER (H5Pcreate, FAIL);
-   H5ECLEAR;
+    H5P_t                  *ds = NULL;
+    hid_t                   ret_value = FAIL;
 
-   ds = H5MM_xcalloc (1, sizeof(H5P_t));
-   ds->type = type;
-   
-   switch (type) {
-   case H5P_SCALAR:
-      /*void*/
-      break;
-      
-   case H5P_SIMPLE:
-      ds->u.simple.rank = 0;
-      break;
-
-   case H5P_COMPLEX:
-      HGOTO_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
-		   "complex types are not supported yet");
-
-   default:
-      HGOTO_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL,
-		   "unknown data space type");
-   }
-
-   /* Register the new data space and get an ID for it */
-   if ((ret_value = H5Aregister_atom (H5_DATASPACE, ds))<0) {
-      HGOTO_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL,
-		   "unable to register data space for ID");
-   }
-
- done:
-   if (ret_value<0) {
-      H5MM_xfree (ds);
-   }
-
-   FUNC_LEAVE (ret_value);
-}
+    FUNC_ENTER(H5Pcreate, FAIL);
+    H5ECLEAR;
 
+    ds = H5MM_xcalloc(1, sizeof(H5P_t));
+    ds->type = type;
+
+    switch (type) {
+    case H5P_SCALAR:
+        /*void */
+        break;
+
+    case H5P_SIMPLE:
+        ds->u.simple.rank = 0;
+        break;
+
+    case H5P_COMPLEX:
+        HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+                    "complex types are not supported yet");
+
+    default:
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL,
+                    "unknown data space type");
+    }
+
+    /* Register the new data space and get an ID for it */
+    if ((ret_value = H5Aregister_atom(H5_DATASPACE, ds)) < 0) {
+        HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL,
+                    "unable to register data space for ID");
+    }
+  done:
+    if (ret_value < 0) {
+        H5MM_xfree(ds);
+    }
+    FUNC_LEAVE(ret_value);
+}
 
 /*-------------------------------------------------------------------------
- * Function:	H5Pclose
+ * Function:    H5Pclose
  *
- * Purpose:	Release access to a data space object.
+ * Purpose:     Release access to a data space object.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
  * Errors:
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Tuesday, December  9, 1997
  *
  * Modifications:
@@ -166,36 +160,33 @@ H5Pcreate (H5P_class_t type)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5Pclose (hid_t space_id)
+H5Pclose(hid_t space_id)
 {
-   FUNC_ENTER (H5Pclose, FAIL);
-   H5ECLEAR;
-
-   /* check args */
-   if (H5_DATASPACE!=H5Aatom_group (space_id) ||
-       NULL==H5Aatom_object (space_id)) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
-   }
-   
-   /* When the reference count reaches zero the resources are freed */
-   if (H5A_dec_ref (space_id)<0) {
-      HRETURN_ERROR (H5E_ATOM, H5E_BADATOM, FAIL, "problem freeing id");
-   }
+    FUNC_ENTER(H5Pclose, FAIL);
+    H5ECLEAR;
 
-   FUNC_LEAVE (SUCCEED);
+    /* check args */
+    if (H5_DATASPACE != H5Aatom_group(space_id) ||
+        NULL == H5Aatom_object(space_id)) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
+    }
+    /* When the reference count reaches zero the resources are freed */
+    if (H5A_dec_ref(space_id) < 0) {
+        HRETURN_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "problem freeing id");
+    }
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5P_close
+ * Function:    H5P_close
  *
- * Purpose:	Releases all memory associated with a data space.
+ * Purpose:     Releases all memory associated with a data space.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Tuesday, December  9, 1997
  *
  * Modifications:
@@ -203,116 +194,114 @@ H5Pclose (hid_t space_id)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5P_close (H5P_t *ds)
+H5P_close(H5P_t *ds)
 {
-   FUNC_ENTER (H5P_close, FAIL);
-
-   assert (ds);
-
-   switch (ds->type) {
-   case H5P_SCALAR:
-      /*void*/
-      break;
-      
-   case H5P_SIMPLE:
-      H5MM_xfree (ds->u.simple.size);
-      H5MM_xfree (ds->u.simple.max);
-      H5MM_xfree (ds->u.simple.perm);
-      break;
-
-   case H5P_COMPLEX:
-      /* nothing */
-      break;
-
-   default:
-      assert ("unknown data space type" && 0);
-      break;
-   }
-   H5MM_xfree (ds);
-   
-   FUNC_LEAVE (SUCCEED);
-}
+    FUNC_ENTER(H5P_close, FAIL);
+
+    assert(ds);
+
+    switch (ds->type) {
+    case H5P_SCALAR:
+        /*void */
+        break;
+
+    case H5P_SIMPLE:
+        H5MM_xfree(ds->u.simple.size);
+        H5MM_xfree(ds->u.simple.max);
+        H5MM_xfree(ds->u.simple.perm);
+        break;
+
+    case H5P_COMPLEX:
+        /* nothing */
+        break;
 
+    default:
+        assert("unknown data space type" && 0);
+        break;
+    }
+    H5MM_xfree(ds);
+
+    FUNC_LEAVE(SUCCEED);
+}
 
 /*-------------------------------------------------------------------------
- * Function:	H5P_copy
+ * Function:    H5P_copy
  *
- * Purpose:	Copies a data space.
+ * Purpose:     Copies a data space.
  *
- * Return:	Success:	A pointer to a new copy of SRC
+ * Return:      Success:        A pointer to a new copy of SRC
  *
- *		Failure:	NULL
+ *              Failure:        NULL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Thursday, December  4, 1997
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
-H5P_t *
-H5P_copy (const H5P_t *src)
+H5P_t                  *
+H5P_copy(const H5P_t *src)
 {
-   H5P_t	*dst = NULL;
-   int		i;
-   
-   FUNC_ENTER (H5P_copy, NULL);
-
-   dst = H5MM_xmalloc (sizeof(H5P_t));
-   *dst = *src;
-
-   switch (dst->type) {
-   case H5P_SCALAR:
-      /*void*/
-      break;
-      
-   case H5P_SIMPLE:
-      if (dst->u.simple.size) {
-	 dst->u.simple.size = H5MM_xmalloc (dst->u.simple.rank *
-					    sizeof(dst->u.simple.size[0]));
-	 for (i=0; i<dst->u.simple.rank; i++) {
-	    dst->u.simple.size[i] = src->u.simple.size[i];
-	 }
-      }
-      if (dst->u.simple.max) {
-	 dst->u.simple.max = H5MM_xmalloc (dst->u.simple.rank *
-					   sizeof(dst->u.simple.max[0]));
-	 for (i=0; i<dst->u.simple.rank; i++) {
-	    dst->u.simple.max[i] = src->u.simple.max[i];
-	 }
-      }
-      if (dst->u.simple.perm) {
-	 dst->u.simple.perm = H5MM_xmalloc (dst->u.simple.rank *
-					    sizeof(dst->u.simple.perm[0]));
-	 for (i=0; i<dst->u.simple.rank; i++) {
-	    dst->u.simple.perm[i] = src->u.simple.perm[i];
-	 }
-      }
-      break;
-
-   case H5P_COMPLEX:
-      /*void*/
-      break;
-
-   default:
-      assert ("unknown data space type" && 0);
-      break;
-   }
-
-   FUNC_LEAVE (dst);
+    H5P_t                  *dst = NULL;
+    int                     i;
+
+    FUNC_ENTER(H5P_copy, NULL);
+
+    dst = H5MM_xmalloc(sizeof(H5P_t));
+    *dst = *src;
+
+    switch (dst->type) {
+    case H5P_SCALAR:
+        /*void */
+        break;
+
+    case H5P_SIMPLE:
+        if (dst->u.simple.size) {
+            dst->u.simple.size = H5MM_xmalloc(dst->u.simple.rank *
+                                              sizeof(dst->u.simple.size[0]));
+            for (i = 0; i < dst->u.simple.rank; i++) {
+                dst->u.simple.size[i] = src->u.simple.size[i];
+            }
+        }
+        if (dst->u.simple.max) {
+            dst->u.simple.max = H5MM_xmalloc(dst->u.simple.rank *
+                                             sizeof(dst->u.simple.max[0]));
+            for (i = 0; i < dst->u.simple.rank; i++) {
+                dst->u.simple.max[i] = src->u.simple.max[i];
+            }
+        }
+        if (dst->u.simple.perm) {
+            dst->u.simple.perm = H5MM_xmalloc(dst->u.simple.rank *
+                                              sizeof(dst->u.simple.perm[0]));
+            for (i = 0; i < dst->u.simple.rank; i++) {
+                dst->u.simple.perm[i] = src->u.simple.perm[i];
+            }
+        }
+        break;
+
+    case H5P_COMPLEX:
+        /*void */
+        break;
+
+    default:
+        assert("unknown data space type" && 0);
+        break;
+    }
+
+    FUNC_LEAVE(dst);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5Pget_npoints
+ * Function:    H5Pget_npoints
  *
- * Purpose:	Determines how many data points a data set has.
+ * Purpose:     Determines how many data points a data set has.
  *
- * Return:	Success:	Number of data points in the data set.
+ * Return:      Success:        Number of data points in the data set.
  *
- *		Failure:	0
+ *              Failure:        0
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Tuesday, December  9, 1997
  *
  * Modifications:
@@ -320,36 +309,34 @@ H5P_copy (const H5P_t *src)
  *-------------------------------------------------------------------------
  */
 size_t
-H5Pget_npoints (hid_t space_id)
+H5Pget_npoints(hid_t space_id)
 {
-   H5P_t	*ds = NULL;
-   size_t	ret_value = 0;
-
-   FUNC_ENTER(H5Pget_npoints, 0);
-   H5ECLEAR;
+    H5P_t                  *ds = NULL;
+    size_t                  ret_value = 0;
 
-   /* check args */
-   if (H5_DATASPACE!=H5Aatom_group (space_id) ||
-       NULL==(ds=H5Aatom_object (space_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, 0, "not a data space");
-   }
+    FUNC_ENTER(H5Pget_npoints, 0);
+    H5ECLEAR;
 
-   ret_value = H5P_get_npoints (ds);
+    /* check args */
+    if (H5_DATASPACE != H5Aatom_group(space_id) ||
+        NULL == (ds = H5Aatom_object(space_id))) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, 0, "not a data space");
+    }
+    ret_value = H5P_get_npoints(ds);
 
-   FUNC_LEAVE (ret_value);
+    FUNC_LEAVE(ret_value);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5P_get_npoints
+ * Function:    H5P_get_npoints
  *
- * Purpose:	Determines how many data points a data set has.
+ * Purpose:     Determines how many data points a data set has.
  *
- * Return:	Success:	Number of data points in the data set.
+ * Return:      Success:        Number of data points in the data set.
  *
- *		Failure:	0
+ *              Failure:        0
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Tuesday, December  9, 1997
  *
  * Modifications:
@@ -357,51 +344,50 @@ H5Pget_npoints (hid_t space_id)
  *-------------------------------------------------------------------------
  */
 size_t
-H5P_get_npoints (const H5P_t *ds)
+H5P_get_npoints(const H5P_t *ds)
 {
-   size_t	ret_value = 0;
-   intn		i;
-   
-   FUNC_ENTER(H5P_get_npoints, 0);
+    size_t                  ret_value = 0;
+    intn                    i;
 
-   /* check args */
-   assert (ds);
+    FUNC_ENTER(H5P_get_npoints, 0);
 
-   switch (ds->type) {
-   case H5P_SCALAR:
-      ret_value = 1;
-      break;
+    /* check args */
+    assert(ds);
 
-   case H5P_SIMPLE:
-      for (ret_value=1, i=0; i<ds->u.simple.rank; i++) {
-	 ret_value *= ds->u.simple.size[i];
-      }
-      break;
+    switch (ds->type) {
+    case H5P_SCALAR:
+        ret_value = 1;
+        break;
 
-   case H5P_COMPLEX:
-      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, 0,
-		     "complex data spaces are not supported yet");
+    case H5P_SIMPLE:
+        for (ret_value = 1, i = 0; i < ds->u.simple.rank; i++) {
+            ret_value *= ds->u.simple.size[i];
+        }
+        break;
 
-   default:
-      assert ("unknown data space class" && 0);
-      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, 0,
-		     "internal error (unknown data space class)");
-   }
+    case H5P_COMPLEX:
+        HRETURN_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, 0,
+                      "complex data spaces are not supported yet");
 
-   FUNC_LEAVE (ret_value);
-}
+    default:
+        assert("unknown data space class" && 0);
+        HRETURN_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, 0,
+                      "internal error (unknown data space class)");
+    }
 
+    FUNC_LEAVE(ret_value);
+}
 
 /*-------------------------------------------------------------------------
- * Function:	H5Pget_ndims
+ * Function:    H5Pget_ndims
  *
- * Purpose:	Determines the dimensionality of a data space.
+ * Purpose:     Determines the dimensionality of a data space.
  *
- * Return:	Success:	The number of dimensions in a data space.
+ * Return:      Success:        The number of dimensions in a data space.
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Thursday, December 11, 1997
  *
  * Modifications:
@@ -409,37 +395,35 @@ H5P_get_npoints (const H5P_t *ds)
  *-------------------------------------------------------------------------
  */
 intn
-H5Pget_ndims (hid_t space_id)
+H5Pget_ndims(hid_t space_id)
 {
-   H5P_t	*ds = NULL;
-   size_t	ret_value = 0;
-
-   FUNC_ENTER(H5Pget_ndims, FAIL);
-   H5ECLEAR;
+    H5P_t                  *ds = NULL;
+    size_t                  ret_value = 0;
 
-   /* check args */
-   if (H5_DATASPACE!=H5Aatom_group (space_id) ||
-       NULL==(ds=H5Aatom_object (space_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
-   }
+    FUNC_ENTER(H5Pget_ndims, FAIL);
+    H5ECLEAR;
 
-   ret_value = H5P_get_ndims (ds);
+    /* check args */
+    if (H5_DATASPACE != H5Aatom_group(space_id) ||
+        NULL == (ds = H5Aatom_object(space_id))) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
+    }
+    ret_value = H5P_get_ndims(ds);
 
-   FUNC_LEAVE (ret_value);
+    FUNC_LEAVE(ret_value);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5P_get_ndims
+ * Function:    H5P_get_ndims
  *
- * Purpose:	Returns the number of dimensions in a data space.
+ * Purpose:     Returns the number of dimensions in a data space.
  *
- * Return:	Success:	Non-negative number of dimensions.  Zero
- *				implies a scalar.
+ * Return:      Success:        Non-negative number of dimensions.  Zero
+ *                              implies a scalar.
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Thursday, December 11, 1997
  *
  * Modifications:
@@ -447,50 +431,49 @@ H5Pget_ndims (hid_t space_id)
  *-------------------------------------------------------------------------
  */
 intn
-H5P_get_ndims (const H5P_t *ds)
+H5P_get_ndims(const H5P_t *ds)
 {
-   intn		ret_value = FAIL;
-   
-   FUNC_ENTER (H5P_get_ndims, FAIL);
+    intn                    ret_value = FAIL;
 
-   /* check args */
-   assert (ds);
+    FUNC_ENTER(H5P_get_ndims, FAIL);
 
-   switch (ds->type) {
-   case H5P_SCALAR:
-      ret_value = 0;
-      break;
+    /* check args */
+    assert(ds);
 
-   case H5P_SIMPLE:
-      ret_value = ds->u.simple.rank;
-      break;
+    switch (ds->type) {
+    case H5P_SCALAR:
+        ret_value = 0;
+        break;
 
-   case H5P_COMPLEX:
-      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
-		     "complex data spaces are not supported yet");
+    case H5P_SIMPLE:
+        ret_value = ds->u.simple.rank;
+        break;
 
-   default:
-      assert ("unknown data space class" && 0);
-      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
-		     "internal error (unknown data space class)");
-   }
+    case H5P_COMPLEX:
+        HRETURN_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+                      "complex data spaces are not supported yet");
 
-   FUNC_LEAVE (ret_value);
-}
+    default:
+        assert("unknown data space class" && 0);
+        HRETURN_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+                      "internal error (unknown data space class)");
+    }
 
+    FUNC_LEAVE(ret_value);
+}
 
 /*-------------------------------------------------------------------------
- * Function:	H5Pget_dims
+ * Function:    H5Pget_dims
  *
- * Purpose:	Returns the size in each dimension of a data space DS through
- *		the DIMS argument.
+ * Purpose:     Returns the size in each dimension of a data space DS through
+ *              the DIMS argument.
  *
- * Return:	Success:	Number of dimensions, the same value as
- *				returned by H5Pget_ndims().
+ * Return:      Success:        Number of dimensions, the same value as
+ *                              returned by H5Pget_ndims().
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Thursday, December 11, 1997
  *
  * Modifications:
@@ -498,42 +481,39 @@ H5P_get_ndims (const H5P_t *ds)
  *-------------------------------------------------------------------------
  */
 intn
-H5Pget_dims (hid_t space_id, size_t dims[]/*out*/)
+H5Pget_dims(hid_t space_id, size_t dims[] /*out */ )
 {
-   
-   H5P_t	*ds = NULL;
-   size_t	ret_value = 0;
-
-   FUNC_ENTER(H5Pget_dims, FAIL);
-   H5ECLEAR;
-
-   /* check args */
-   if (H5_DATASPACE!=H5Aatom_group (space_id) ||
-       NULL==(ds=H5Aatom_object (space_id))) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
-   }
-   if (!dims) {
-      HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "no output buffer");
-   }
-   
 
-   ret_value = H5P_get_dims (ds, dims);
+    H5P_t                  *ds = NULL;
+    size_t                  ret_value = 0;
 
-   FUNC_LEAVE (ret_value);
-}
+    FUNC_ENTER(H5Pget_dims, FAIL);
+    H5ECLEAR;
 
+    /* check args */
+    if (H5_DATASPACE != H5Aatom_group(space_id) ||
+        NULL == (ds = H5Aatom_object(space_id))) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
+    }
+    if (!dims) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no output buffer");
+    }
+    ret_value = H5P_get_dims(ds, dims);
+
+    FUNC_LEAVE(ret_value);
+}
 
 /*-------------------------------------------------------------------------
- * Function:	H5P_get_dims
+ * Function:    H5P_get_dims
  *
- * Purpose:	Returns the size in each dimension of a data space.  This
- *		function may not be meaningful for all types of data spaces.
+ * Purpose:     Returns the size in each dimension of a data space.  This
+ *              function may not be meaningful for all types of data spaces.
  *
- * Return:	Success:	Number of dimensions.  Zero implies scalar.
+ * Return:      Success:        Number of dimensions.  Zero implies scalar.
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Thursday, December 11, 1997
  *
  * Modifications:
@@ -541,54 +521,53 @@ H5Pget_dims (hid_t space_id, size_t dims[]/*out*/)
  *-------------------------------------------------------------------------
  */
 intn
-H5P_get_dims (const H5P_t *ds, size_t dims[])
+H5P_get_dims(const H5P_t *ds, size_t dims[])
 {
-   intn		ret_value = FAIL;
-   intn		i;
-   
-   FUNC_ENTER (H5P_get_dims, FAIL);
-
-   /* check args */
-   assert (ds);
-   assert (dims);
-
-   switch (ds->type) {
-   case H5P_SCALAR:
-      ret_value = 0;
-      break;
-
-   case H5P_SIMPLE:
-      ret_value = ds->u.simple.rank;
-      for (i=0; i<ret_value; i++) {
-	 dims[i] = ds->u.simple.size[i];
-      }
-      break;
-
-   case H5P_COMPLEX:
-      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
-		     "complex data spaces are not supported yet");
-
-   default:
-      assert ("unknown data space class" && 0);
-      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
-		     "internal error (unknown data space class)");
-   }
-
-   FUNC_LEAVE (ret_value);
-}
+    intn                    ret_value = FAIL;
+    intn                    i;
 
+    FUNC_ENTER(H5P_get_dims, FAIL);
+
+    /* check args */
+    assert(ds);
+    assert(dims);
+
+    switch (ds->type) {
+    case H5P_SCALAR:
+        ret_value = 0;
+        break;
+
+    case H5P_SIMPLE:
+        ret_value = ds->u.simple.rank;
+        for (i = 0; i < ret_value; i++) {
+            dims[i] = ds->u.simple.size[i];
+        }
+        break;
+
+    case H5P_COMPLEX:
+        HRETURN_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+                      "complex data spaces are not supported yet");
+
+    default:
+        assert("unknown data space class" && 0);
+        HRETURN_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+                      "internal error (unknown data space class)");
+    }
+
+    FUNC_LEAVE(ret_value);
+}
 
 /*-------------------------------------------------------------------------
- * Function:	H5P_modify
+ * Function:    H5P_modify
  *
- * Purpose:	Updates a data space by writing a message to an object
- *		header.
+ * Purpose:     Updates a data space by writing a message to an object
+ *              header.
  *
- * Return:	Success:	SUCCEED
+ * Return:      Success:        SUCCEED
  *
- *		Failure:	FAIL
+ *              Failure:        FAIL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Tuesday, December  9, 1997
  *
  * Modifications:
@@ -596,92 +575,89 @@ H5P_get_dims (const H5P_t *ds, size_t dims[])
  *-------------------------------------------------------------------------
  */
 herr_t
-H5P_modify (H5F_t *f, H5G_entry_t *ent, const H5P_t *ds)
+H5P_modify(H5F_t *f, H5G_entry_t *ent, const H5P_t *ds)
 {
-   FUNC_ENTER (H5O_modify, FAIL);
-
-   assert (f);
-   assert (ent);
-   assert (ds);
-
-   switch (ds->type) {
-   case H5P_SCALAR:
-      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
-		     "scalar data spaces are not implemented yet");
-
-   case H5P_SIMPLE:
-      if (H5O_modify (ent, H5O_SDSPACE, 0, 0, &(ds->u.simple))<0) {
-	 HRETURN_ERROR (H5E_DATASPACE, H5E_CANTINIT, FAIL,
-			"can't update simple data space message");
-      }
-      break;
-
-   case H5P_COMPLEX:
-      HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
-		     "complex data spaces are not implemented yet");
-
-   default:
-      assert ("unknown data space class" && 0);
-      break;
-   }
-
-   FUNC_LEAVE (SUCCEED);
+    FUNC_ENTER(H5O_modify, FAIL);
+
+    assert(f);
+    assert(ent);
+    assert(ds);
+
+    switch (ds->type) {
+    case H5P_SCALAR:
+        HRETURN_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+                      "scalar data spaces are not implemented yet");
+
+    case H5P_SIMPLE:
+        if (H5O_modify(ent, H5O_SDSPACE, 0, 0, &(ds->u.simple)) < 0) {
+            HRETURN_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL,
+                          "can't update simple data space message");
+        }
+        break;
+
+    case H5P_COMPLEX:
+        HRETURN_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+                      "complex data spaces are not implemented yet");
+
+    default:
+        assert("unknown data space class" && 0);
+        break;
+    }
+
+    FUNC_LEAVE(SUCCEED);
 }
-
 
 /*-------------------------------------------------------------------------
- * Function:	H5P_read
+ * Function:    H5P_read
  *
- * Purpose:	Reads the data space from an object header.
+ * Purpose:     Reads the data space from an object header.
  *
- * Return:	Success:	Pointer to a new data space.
+ * Return:      Success:        Pointer to a new data space.
  *
- *		Failure:	NULL
+ *              Failure:        NULL
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Tuesday, December  9, 1997
  *
  * Modifications:
  *
  *-------------------------------------------------------------------------
  */
-H5P_t *
-H5P_read (H5F_t *f, H5G_entry_t *ent)
+H5P_t                  *
+H5P_read(H5F_t *f, H5G_entry_t *ent)
 {
-   H5P_t	*ds = NULL;
-   
-   FUNC_ENTER (H5P_read, NULL);
+    H5P_t                  *ds = NULL;
 
-   /* check args */
-   assert (f);
-   assert (ent);
+    FUNC_ENTER(H5P_read, NULL);
 
-   ds = H5MM_xcalloc (1, sizeof(H5P_t));
+    /* check args */
+    assert(f);
+    assert(ent);
 
-   if (H5O_read (ent, H5O_SDSPACE, 0, &(ds->u.simple))) {
-      ds->type = H5P_SIMPLE;
-      
-   } else {
-      ds->type = H5P_SCALAR;
-   }
+    ds = H5MM_xcalloc(1, sizeof(H5P_t));
 
-   FUNC_LEAVE (ds);
-}
+    if (H5O_read(ent, H5O_SDSPACE, 0, &(ds->u.simple))) {
+        ds->type = H5P_SIMPLE;
 
+    } else {
+        ds->type = H5P_SCALAR;
+    }
 
+    FUNC_LEAVE(ds);
+}
 
 /*-------------------------------------------------------------------------
- * Function:	H5P_cmp
+ * Function:    H5P_cmp
  *
- * Purpose:	Compares two data spaces.
+ * Purpose:     Compares two data spaces.
  *
- * Return:	Success:	0 if DS1 and DS2 are the same.
- *				<0 if DS1 is less than DS2.
- * 				>0 if DS1 is greater than DS2.
+ * Return:      Success:        0 if DS1 and DS2 are the same.
+ *                              <0 if DS1 is less than DS2.
+ *                              >0 if DS1 is greater than DS2.
  *
- *		Failure:	0, never fails
+ *              Failure:        0, never fails
  *
- * Programmer:	Robb Matzke
+ * Programmer:  Robb Matzke
  *              Wednesday, December 10, 1997
  *
  * Modifications:
@@ -689,51 +665,58 @@ H5P_read (H5F_t *f, H5G_entry_t *ent)
  *-------------------------------------------------------------------------
  */
 intn
-H5P_cmp (const H5P_t *ds1, const H5P_t *ds2)
+H5P_cmp(const H5P_t *ds1, const H5P_t *ds2)
 {
-   intn		i;
-   
-   FUNC_ENTER (H5P_cmp, 0);
-
-   /* check args */
-   assert (ds1);
-   assert (ds2);
-
-   /* compare */
-   if (ds1->type < ds2->type) HRETURN (-1);
-   if (ds1->type > ds2->type) HRETURN (1);
-
-   switch (ds1->type) {
-   case H5P_SIMPLE:
-      if (ds1->u.simple.rank < ds2->u.simple.rank) HRETURN (-1);
-      if (ds1->u.simple.rank > ds2->u.simple.rank) HRETURN (1);
-
-      /* don't compare flags */
-
-      for (i=0; i<ds1->u.simple.rank; i++) {
-	 if (ds1->u.simple.size[i] < ds2->u.simple.size[i]) HRETURN (-1);
-	 if (ds1->u.simple.size[i] > ds2->u.simple.size[i]) HRETURN (1);
-      }
-
-      /* don't compare max dimensions */
-      
-      for (i=0; i<ds1->u.simple.rank; i++) {
-	 if ((ds1->u.simple.perm?ds1->u.simple.perm[i]:i) <
-	     (ds2->u.simple.perm?ds2->u.simple.perm[i]:i)) HRETURN (-1);
-	 if ((ds1->u.simple.perm?ds2->u.simple.perm[i]:i) >
-	     (ds2->u.simple.perm?ds2->u.simple.perm[i]:i)) HRETURN (1);
-      }
-
-      break;
-
-   default:
-      assert ("not implemented yet" && 0);
-   }
-
-   FUNC_LEAVE (0);
+    intn                    i;
+
+    FUNC_ENTER(H5P_cmp, 0);
+
+    /* check args */
+    assert(ds1);
+    assert(ds2);
+
+    /* compare */
+    if (ds1->type < ds2->type)
+        HRETURN(-1);
+    if (ds1->type > ds2->type)
+        HRETURN(1);
+
+    switch (ds1->type) {
+    case H5P_SIMPLE:
+        if (ds1->u.simple.rank < ds2->u.simple.rank)
+            HRETURN(-1);
+        if (ds1->u.simple.rank > ds2->u.simple.rank)
+            HRETURN(1);
+
+        /* don't compare flags */
+
+        for (i = 0; i < ds1->u.simple.rank; i++) {
+            if (ds1->u.simple.size[i] < ds2->u.simple.size[i])
+                HRETURN(-1);
+            if (ds1->u.simple.size[i] > ds2->u.simple.size[i])
+                HRETURN(1);
+        }
+
+        /* don't compare max dimensions */
+
+        for (i = 0; i < ds1->u.simple.rank; i++) {
+            if ((ds1->u.simple.perm ? ds1->u.simple.perm[i] : i) <
+                (ds2->u.simple.perm ? ds2->u.simple.perm[i] : i))
+                HRETURN(-1);
+            if ((ds1->u.simple.perm ? ds2->u.simple.perm[i] : i) >
+                (ds2->u.simple.perm ? ds2->u.simple.perm[i] : i))
+                HRETURN(1);
+        }
+
+        break;
+
+    default:
+        assert("not implemented yet" && 0);
+    }
+
+    FUNC_LEAVE(0);
 }
 
-
 /*--------------------------------------------------------------------------
  NAME
     H5P_is_simple
@@ -749,9 +732,9 @@ H5P_cmp (const H5P_t *ds1, const H5P_t *ds2)
     has orthogonal, evenly spaced dimensions.
 --------------------------------------------------------------------------*/
 hbool_t
-H5P_is_simple (const H5P_t *sdim)
+H5P_is_simple(const H5P_t *sdim)
 {
-    hbool_t ret_value = BFAIL;
+    hbool_t                 ret_value = BFAIL;
 
     FUNC_ENTER(H5P_is_simple, UFAIL);
 
@@ -759,8 +742,7 @@ H5P_is_simple (const H5P_t *sdim)
     H5ECLEAR;
 
     assert(sdim);
-    ret_value=sdim->type==H5P_SIMPLE ? BTRUE : BFALSE; /* Currently all dataspaces are simple, but check anyway */
-
+    ret_value = sdim->type == H5P_SIMPLE ? BTRUE : BFALSE;      /* Currently all dataspaces are simple, but check anyway */
 
     FUNC_LEAVE(ret_value);
 }
@@ -779,29 +761,27 @@ H5P_is_simple (const H5P_t *sdim)
         This function determines the if a dataspace is "simple". ie. if it
     has orthogonal, evenly spaced dimensions.
 --------------------------------------------------------------------------*/
-hbool_t H5Pis_simple(hid_t sid)
+hbool_t 
+H5Pis_simple(hid_t sid)
 {
-    H5P_t *space=NULL;      /* dataspace to modify */
-    hbool_t        ret_value = BFAIL;
+    H5P_t                  *space = NULL;       /* dataspace to modify */
+    hbool_t                 ret_value = BFAIL;
 
     FUNC_ENTER(H5Pis_simple, BFAIL);
 
     /* Clear errors and check args and all the boring stuff. */
     H5ECLEAR;
 
-    if((space=H5Aatom_object(sid))==NULL)
+    if ((space = H5Aatom_object(sid)) == NULL)
         HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "not a data space");
 
-    ret_value=H5P_is_simple(space);
+    ret_value = H5P_is_simple(space);
 
-done:
-  if(ret_value == BFAIL)
-    { /* Error condition cleanup */
-
-    } /* end if */
+  done:
+    if (ret_value == BFAIL) {   /* Error condition cleanup */
 
+    }                           /* end if */
     /* Normal function cleanup */
-
     FUNC_LEAVE(ret_value);
 }
 
@@ -827,11 +807,11 @@ done:
     be unlimited in size.
 --------------------------------------------------------------------------*/
 herr_t
-H5Pset_space (hid_t sid, intn rank, const size_t *dims)
+H5Pset_space(hid_t sid, intn rank, const size_t *dims)
 {
-    H5P_t *space=NULL;      /* dataspace to modify */
-    intn u;                    /* local counting variable */
-    herr_t        ret_value = SUCCEED;
+    H5P_t                  *space = NULL;       /* dataspace to modify */
+    intn                    u;  /* local counting variable */
+    herr_t                  ret_value = SUCCEED;
 
     FUNC_ENTER(H5Pset_space, FAIL);
 
@@ -839,82 +819,76 @@ H5Pset_space (hid_t sid, intn rank, const size_t *dims)
     H5ECLEAR;
 
     /* Get the object */
-    if((space=H5Aatom_object(sid))==NULL)
+    if ((space = H5Aatom_object(sid)) == NULL)
         HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "not a data space");
-    if(rank>0 && dims==NULL)
+    if (rank > 0 && dims == NULL)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid rank");
 
     /* shift out of the previous state to a "simple" dataspace */
-    switch(space->type)
-      {
-        case H5P_SIMPLE:
-            /* do nothing */
-            break;
-
-        case H5P_COMPLEX:
-            /*
-	     * eventually this will destroy whatever "complex" dataspace info
-	     * is retained, right now it's an error
-	     */
-            /* Fall through to report error */
-
-        default:
-            HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL,
-			"unknown data space class");
-      } /* end switch */
-    space->type=H5P_SIMPLE;
-
-    if(rank==0)
-      { /* scalar variable */
-        space->u.simple.rank=0;      /* set to scalar rank */
-        space->u.simple.dim_flags=0; /* no maximum dimensions or dimension permutations */
-        if(space->u.simple.size!=NULL)
-            space->u.simple.size=H5MM_xfree(space->u.simple.size);
-        if(space->u.simple.max!=NULL)
-            space->u.simple.max=H5MM_xfree(space->u.simple.max);
-        if(space->u.simple.perm!=NULL)
-            space->u.simple.max=H5MM_xfree(space->u.simple.perm);
-      } /* end if */
-    else 
-      {
+    switch (space->type) {
+    case H5P_SIMPLE:
+        /* do nothing */
+        break;
+
+    case H5P_COMPLEX:
+        /*
+         * eventually this will destroy whatever "complex" dataspace info
+         * is retained, right now it's an error
+         */
+        /* Fall through to report error */
+
+    default:
+        HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL,
+                    "unknown data space class");
+    }                           /* end switch */
+    space->type = H5P_SIMPLE;
+
+    if (rank == 0) {            /* scalar variable */
+        space->u.simple.rank = 0;       /* set to scalar rank */
+        space->u.simple.dim_flags = 0;  /* no maximum dimensions or dimension permutations */
+        if (space->u.simple.size != NULL)
+            space->u.simple.size = H5MM_xfree(space->u.simple.size);
+        if (space->u.simple.max != NULL)
+            space->u.simple.max = H5MM_xfree(space->u.simple.max);
+        if (space->u.simple.perm != NULL)
+            space->u.simple.max = H5MM_xfree(space->u.simple.perm);
+    }
+    /* end if */ 
+    else {
         /* Reset the dataspace flags */
-        space->u.simple.dim_flags=0;
+        space->u.simple.dim_flags = 0;
 
         /* Free the old space for now */
-        if(space->u.simple.size!=NULL)
-            space->u.simple.size=H5MM_xfree(space->u.simple.size);
-        if(space->u.simple.max!=NULL)
-            space->u.simple.max=H5MM_xfree(space->u.simple.max);
-        if(space->u.simple.perm!=NULL)
-            space->u.simple.perm=H5MM_xfree(space->u.simple.perm);
+        if (space->u.simple.size != NULL)
+            space->u.simple.size = H5MM_xfree(space->u.simple.size);
+        if (space->u.simple.max != NULL)
+            space->u.simple.max = H5MM_xfree(space->u.simple.max);
+        if (space->u.simple.perm != NULL)
+            space->u.simple.perm = H5MM_xfree(space->u.simple.perm);
 
         /* Set the rank and copy the dims */
-        space->u.simple.rank=rank;
-        space->u.simple.size = H5MM_xcalloc (rank, sizeof(size_t));
-        HDmemcpy(space->u.simple.size,dims,sizeof(size_t)*rank);
+        space->u.simple.rank = rank;
+        space->u.simple.size = H5MM_xcalloc(rank, sizeof(size_t));
+        HDmemcpy(space->u.simple.size, dims, sizeof(size_t) * rank);
 
         /* check if there are unlimited dimensions and create the maximum dims array */
-        for(u=0; u<rank; u++)
-            if(dims[u]==0)
-              {
-                if(u>0)
-		   HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, 
-			       "unlimited dimensions not in the lowest "
-			       "dimensionality");
-                space->u.simple.max = H5MM_xcalloc (rank, sizeof(size_t));
-                HDmemcpy(space->u.simple.max,dims,sizeof(size_t)*rank);
-                space->u.simple.dim_flags|=H5P_VALID_MAX;
+        for (u = 0; u < rank; u++)
+            if (dims[u] == 0) {
+                if (u > 0)
+                    HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+                                "unlimited dimensions not in the lowest "
+                                "dimensionality");
+                space->u.simple.max = H5MM_xcalloc(rank, sizeof(size_t));
+                HDmemcpy(space->u.simple.max, dims, sizeof(size_t) * rank);
+                space->u.simple.dim_flags |= H5P_VALID_MAX;
                 break;
-              } /* end if */
-      } /* end else */
+            }                   /* end if */
+    }                           /* end else */
 
-done:
-  if(ret_value == FAIL)
-    { /* Error condition cleanup */
-
-    } /* end if */
+  done:
+    if (ret_value == FAIL) {    /* Error condition cleanup */
 
+    }                           /* end if */
     /* Normal function cleanup */
-
     FUNC_LEAVE(ret_value);
 }