[svn-r296] Switched prefix for dataspaces from H5P to H5S

1 files changed, 1294 insertions, 0 deletions

diff --git a/src/H5S.c b/src/H5S.c
new file mode 100644
index 0000000..c6f03b2
--- /dev/null
+++ b/src/H5S.c
@@ -0,0 +1,1294 @@
+/****************************************************************************
+* NCSA HDF                                                                 *
+* Software Development Group                                               *
+* National Center for Supercomputing Applications                          *
+* University of Illinois at Urbana-Champaign                               *
+* 605 E. Springfield, Champaign IL 61820                                   *
+*                                                                          *
+* For conditions of distribution and use, see the accompanying             *
+* hdf/COPYING file.                                                        *
+*                                                                          *
+****************************************************************************/
+
+#ifdef RCSID
+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 <H5Sprivate.h>         /* Data-space functions                   */
+
+/* Interface initialization */
+#define PABLO_MASK      H5S_mask
+#define INTERFACE_INIT  H5S_init_interface
+static intn             interface_initialize_g = FALSE;
+static herr_t           H5S_init_interface(void);
+static void             H5S_term_interface(void);
+
+
+/*--------------------------------------------------------------------------
+NAME
+   H5S_init_interface -- Initialize interface-specific information
+USAGE
+    herr_t H5S_init_interface()
+   
+RETURNS
+   SUCCEED/FAIL
+DESCRIPTION
+    Initializes any interface-specific data or routines.
+
+--------------------------------------------------------------------------*/
+static herr_t
+H5S_init_interface(void)
+{
+    herr_t                  ret_value = SUCCEED;
+    FUNC_ENTER(H5S_init_interface, FAIL);
+
+    /* Initialize the atom group for the file IDs */
+    if ((ret_value = H5A_init_group(H5_DATASPACE, H5A_DATASPACEID_HASHSIZE,
+				    H5S_RESERVED_ATOMS,
+				    (herr_t (*)(void *)) H5S_close)) != FAIL) {
+        ret_value = H5_add_exit(&H5S_term_interface);
+    }
+    FUNC_LEAVE(ret_value);
+}
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_term_interface
+ PURPOSE
+    Terminate various H5S objects
+ USAGE
+    void H5S_term_interface()
+ RETURNS
+    SUCCEED/FAIL
+ DESCRIPTION
+    Release the atom group and any other resources allocated.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+     Can't report errors...
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+static void
+H5S_term_interface(void)
+{
+    H5A_destroy_group(H5_DATASPACE);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:    H5Screate_simple
+ *
+ * Purpose:     Creates a new simple data space object and opens it for
+ *		access. The DIMS argument is the size of the simple dataset
+ *		and the MAXDIMS argument is the upper limit on the size of
+ *		the dataset.  MAXDIMS may be the null pointer in which case
+ *		the upper limit is the same as DIMS.  If an element of
+ *		MAXDIMS is zero then the corresponding dimension is unlimited,
+ *		otherwise no element of MAXDIMS should be smaller than the
+ *		corresponding element of DIMS.
+ *
+ * Return:      Success:        The ID for the new simple data space object.
+ *
+ *              Failure:        FAIL
+ *
+ * Errors:
+ *
+ * Programmer:  Quincey Koziol
+ *              Tuesday, January  27, 1998
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+hid_t
+H5Screate_simple(int rank, const size_t *dims, const size_t *maxdims)
+{
+    H5S_t       *ds = NULL;
+    hid_t       ret_value = FAIL;
+    int		i;
+
+    FUNC_ENTER(H5Screate, FAIL);
+
+    /* Check arguments */
+    if (rank<0) {
+	HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
+		       "dimensionality cannot be negative");
+    }
+    if (!dims) {
+	HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
+		       "no dimensions specified");
+    }
+    if (maxdims) {
+	for (i=0; i<rank; i++) {
+	    if (maxdims[i] && maxdims[i]<dims[i]) {
+		HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
+			       "maxdims is smaller than dims");
+	    }
+	}
+    }
+
+    /* Create a new data space */
+    ds = H5MM_xcalloc(1, sizeof(H5S_t));
+#ifdef LATER /* QAK */
+    if(rank>0)  /* for creating simple dataspace */
+      {
+#endif /* LATER */
+        ds->type = H5S_SIMPLE;
+        ds->hslab_def = FALSE;    /* no hyperslab defined currently */
+
+        /* Initialize rank and dimensions */
+        ds->u.simple.rank = rank;
+
+        ds->u.simple.size = H5MM_xcalloc(1, rank*sizeof(size_t));
+        HDmemcpy(ds->u.simple.size, dims, rank*sizeof(size_t));
+
+        if (maxdims) {
+        ds->u.simple.max = H5MM_xcalloc(1, rank*sizeof(size_t));
+        HDmemcpy (ds->u.simple.max, maxdims, rank*sizeof(size_t));
+        }
+#ifdef LATER /* QAK */
+      } /* end if */
+    else /* rank==0, for scalar data space */
+      {
+        ds->type = H5S_SCALAR;
+      } /* end else */
+#endif /* LATER */
+    
+    /* Register the new data space and get an ID for it */
+    if ((ret_value = H5A_register(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:    H5Sclose
+ *
+ * Purpose:     Release access to a data space object.
+ *
+ * Return:      Success:        SUCCEED
+ *
+ *              Failure:        FAIL
+ *
+ * Errors:
+ *
+ * Programmer:  Robb Matzke
+ *              Tuesday, December  9, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5Sclose(hid_t space_id)
+{
+    FUNC_ENTER(H5Sclose, FAIL);
+
+    /* Check args */
+    if (H5_DATASPACE != H5A_group(space_id) ||
+        NULL == H5A_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:    H5S_close
+ *
+ * Purpose:     Releases all memory associated with a data space.
+ *
+ * Return:      Success:        SUCCEED
+ *
+ *              Failure:        FAIL
+ *
+ * Programmer:  Robb Matzke
+ *              Tuesday, December  9, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5S_close(H5S_t *ds)
+{
+    FUNC_ENTER(H5S_close, FAIL);
+
+    assert(ds);
+
+    switch (ds->type) {
+    case H5S_SCALAR:
+        /*void */
+        break;
+
+    case H5S_SIMPLE:
+        H5MM_xfree(ds->u.simple.size);
+        H5MM_xfree(ds->u.simple.max);
+        H5MM_xfree(ds->u.simple.perm);
+        break;
+
+    case H5S_COMPLEX:
+        /* nothing */
+        break;
+
+    default:
+        assert("unknown data space type" && 0);
+        break;
+    }
+    if(ds->hslab_def==TRUE) {
+        H5MM_xfree(ds->h.start);
+        H5MM_xfree(ds->h.count);
+        H5MM_xfree(ds->h.stride);
+    } /* end if */
+    H5MM_xfree(ds);
+
+    FUNC_LEAVE(SUCCEED);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	H5Scopy
+ *
+ * Purpose:	Copies a dataspace.
+ *
+ * Return:	Success:	ID of the new dataspace
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *              Friday, January 30, 1998
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+hid_t
+H5Scopy (hid_t space_id)
+{
+    H5S_t	*src = NULL;
+    H5S_t	*dst = NULL;
+    hid_t	ret_value = FAIL;
+    
+    FUNC_ENTER (H5Scopy, FAIL);
+
+    /* Check args */
+    if (H5_DATASPACE!=H5A_group (space_id) ||
+	NULL==(src=H5A_object (space_id))) {
+	HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
+    }
+
+    /* Copy */
+    if (NULL==(dst=H5S_copy (src))) {
+	HRETURN_ERROR (H5E_DATASPACE, H5E_CANTINIT, FAIL,
+		       "unable to copy data space");
+    }
+
+    /* Atomize */
+    if ((ret_value=H5A_register (H5_DATASPACE, dst))<0) {
+	HRETURN_ERROR (H5E_ATOM, H5E_CANTREGISTER, FAIL,
+		       "unable to register data space atom");
+    }
+
+    FUNC_LEAVE (ret_value);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:    H5S_copy
+ *
+ * Purpose:     Copies a data space.
+ *
+ * Return:      Success:        A pointer to a new copy of SRC
+ *
+ *              Failure:        NULL
+ *
+ * Programmer:  Robb Matzke
+ *              Thursday, December  4, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+H5S_t *
+H5S_copy(const H5S_t *src)
+{
+    H5S_t                  *dst = NULL;
+    int                     i;
+
+    FUNC_ENTER(H5S_copy, NULL);
+
+    dst = H5MM_xmalloc(sizeof(H5S_t));
+    *dst = *src;
+
+    switch (dst->type) {
+    case H5S_SCALAR:
+        /*void */
+        break;
+
+    case H5S_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 H5S_COMPLEX:
+        /*void */
+        break;
+
+    default:
+        assert("unknown data space type" && 0);
+        break;
+    }
+
+    FUNC_LEAVE(dst);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:    H5Sget_npoints
+ *
+ * Purpose:     Determines how many data points a data set has.
+ *
+ * Return:      Success:        Number of data points in the data set.
+ *
+ *              Failure:        0
+ *
+ * Programmer:  Robb Matzke
+ *              Tuesday, December  9, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+size_t
+H5Sget_npoints(hid_t space_id)
+{
+    H5S_t                  *ds = NULL;
+    size_t                  ret_value = 0;
+
+    FUNC_ENTER(H5Sget_npoints, 0);
+
+    /* Check args */
+    if (H5_DATASPACE != H5A_group(space_id) ||
+        NULL == (ds = H5A_object(space_id))) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, 0, "not a data space");
+    }
+    ret_value = H5S_get_npoints(ds);
+
+    FUNC_LEAVE(ret_value);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:    H5S_get_npoints
+ *
+ * Purpose:     Determines how many data points a data set has.
+ *
+ * Return:      Success:        Number of data points in the data set.
+ *
+ *              Failure:        0
+ *
+ * Programmer:  Robb Matzke
+ *              Tuesday, December  9, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+size_t
+H5S_get_npoints(const H5S_t *ds)
+{
+    size_t                  ret_value = 0;
+    intn                    i;
+
+    FUNC_ENTER(H5S_get_npoints, 0);
+
+    /* check args */
+    assert(ds);
+
+    switch (ds->type) {
+    case H5S_SCALAR:
+        ret_value = 1;
+        break;
+
+    case H5S_SIMPLE:
+	/*
+	 * Count the elements selected by the hypeslab if there is one,
+	 * otherwise count all the elements.
+	 */
+	if (ds->hslab_def) {
+	    for (ret_value=1, i=0; i<ds->u.simple.rank; i++) {
+		ret_value *= ds->h.count[i];
+	    }
+	} else {
+	    for (ret_value=1, i=0; i<ds->u.simple.rank; i++) {
+		ret_value *= ds->u.simple.size[i];
+	    }
+        }
+        break;
+
+    case H5S_COMPLEX:
+        HRETURN_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, 0,
+                      "complex data spaces are not supported yet");
+
+    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:    H5Sget_ndims
+ *
+ * Purpose:     Determines the dimensionality of a data space.
+ *
+ * Return:      Success:        The number of dimensions in a data space.
+ *
+ *              Failure:        FAIL
+ *
+ * Programmer:  Robb Matzke
+ *              Thursday, December 11, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+int
+H5Sget_ndims(hid_t space_id)
+{
+    H5S_t                  *ds = NULL;
+    intn                   ret_value = 0;
+
+    FUNC_ENTER(H5Sget_ndims, FAIL);
+
+    /* Check args */
+    if (H5_DATASPACE != H5A_group(space_id) ||
+        NULL == (ds = H5A_object(space_id))) {
+        HRETURN_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
+    }
+    ret_value = H5S_get_ndims(ds);
+
+    FUNC_LEAVE(ret_value);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:    H5S_get_ndims
+ *
+ * Purpose:     Returns the number of dimensions in a data space.
+ *
+ * Return:      Success:        Non-negative number of dimensions.  Zero
+ *                              implies a scalar.
+ *
+ *              Failure:        FAIL
+ *
+ * Programmer:  Robb Matzke
+ *              Thursday, December 11, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+intn
+H5S_get_ndims(const H5S_t *ds)
+{
+    intn                    ret_value = FAIL;
+
+    FUNC_ENTER(H5S_get_ndims, FAIL);
+
+    /* check args */
+    assert(ds);
+
+    switch (ds->type) {
+    case H5S_SCALAR:
+        ret_value = 0;
+        break;
+
+    case H5S_SIMPLE:
+        ret_value = ds->u.simple.rank;
+        break;
+
+    case H5S_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:    H5Sget_dims
+ *
+ * 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 H5Sget_ndims().
+ *
+ *              Failure:        FAIL
+ *
+ * Programmer:  Robb Matzke
+ *              Thursday, December 11, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+int
+H5Sget_dims(hid_t space_id, size_t dims[]/*out*/)
+{
+
+    H5S_t                  *ds = NULL;
+    intn                   ret_value = 0;
+
+    FUNC_ENTER(H5Sget_dims, FAIL);
+
+    /* Check args */
+    if (H5_DATASPACE != H5A_group(space_id) ||
+        NULL == (ds = H5A_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 = H5S_get_dims(ds, dims);
+
+    FUNC_LEAVE(ret_value);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:    H5S_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.
+ *
+ * Return:      Success:        Number of dimensions.  Zero implies scalar.
+ *
+ *              Failure:        FAIL
+ *
+ * Programmer:  Robb Matzke
+ *              Thursday, December 11, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+intn
+H5S_get_dims(const H5S_t *ds, size_t dims[])
+{
+    intn                    ret_value = FAIL;
+    intn                    i;
+
+    FUNC_ENTER(H5S_get_dims, FAIL);
+
+    /* check args */
+    assert(ds);
+    assert(dims);
+
+    switch (ds->type) {
+    case H5S_SCALAR:
+        ret_value = 0;
+        break;
+
+    case H5S_SIMPLE:
+        ret_value = ds->u.simple.rank;
+        for (i = 0; i < ret_value; i++) {
+            dims[i] = ds->u.simple.size[i];
+        }
+        break;
+
+    case H5S_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:    H5S_modify
+ *
+ * Purpose:     Updates a data space by writing a message to an object
+ *              header.
+ *
+ * Return:      Success:        SUCCEED
+ *
+ *              Failure:        FAIL
+ *
+ * Programmer:  Robb Matzke
+ *              Tuesday, December  9, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5S_modify(H5G_entry_t *ent, const H5S_t *ds)
+{
+    FUNC_ENTER(H5S_modify, FAIL);
+
+    assert(ent);
+    assert(ds);
+
+    switch (ds->type) {
+    case H5S_SCALAR:
+        HRETURN_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+                      "scalar data spaces are not implemented yet");
+
+    case H5S_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 H5S_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:    H5S_read
+ *
+ * Purpose:     Reads the data space from an object header.
+ *
+ * Return:      Success:        Pointer to a new data space.
+ *
+ *              Failure:        NULL
+ *
+ * Programmer:  Robb Matzke
+ *              Tuesday, December  9, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+H5S_t *
+H5S_read(H5F_t *f, H5G_entry_t *ent)
+{
+    H5S_t                  *ds = NULL;
+
+    FUNC_ENTER(H5S_read, NULL);
+
+    /* check args */
+    assert(f);
+    assert(ent);
+
+    ds = H5MM_xcalloc(1, sizeof(H5S_t));
+
+    if (H5O_read(ent, H5O_SDSPACE, 0, &(ds->u.simple))) {
+        ds->type = H5S_SIMPLE;
+
+    } else {
+        ds->type = H5S_SCALAR;
+    }
+
+    FUNC_LEAVE(ds);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:    H5S_cmp
+ *
+ * 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.
+ *
+ *              Failure:        0, never fails
+ *
+ * Programmer:  Robb Matzke
+ *              Wednesday, December 10, 1997
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+intn
+H5S_cmp(const H5S_t *ds1, const H5S_t *ds2)
+{
+    intn                    i;
+
+    FUNC_ENTER(H5S_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 H5S_SIMPLE:
+        if (ds1->u.simple.rank < ds2->u.simple.rank)
+            HRETURN(-1);
+        if (ds1->u.simple.rank > ds2->u.simple.rank)
+            HRETURN(1);
+
+        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);
+        }
+
+        /* Check if we should compare hyperslab definitions */
+        if(ds1->hslab_def==TRUE && ds2->hslab_def==TRUE) {
+            for (i = 0; i < ds1->u.simple.rank; i++) {
+                if (ds1->h.start[i] < ds2->h.start[i])
+                    HRETURN(-1);
+                if (ds1->h.start[i] > ds2->h.start[i])
+                    HRETURN(1);
+                if (ds1->h.count[i] < ds2->h.count[i])
+                    HRETURN(-1);
+                if (ds1->h.count[i] > ds2->h.count[i])
+                    HRETURN(1);
+                if (ds1->h.stride[i] < ds2->h.stride[i])
+                    HRETURN(-1);
+                if (ds1->h.stride[i] > ds2->h.stride[i])
+                    HRETURN(1);
+            }
+	} else {
+            if(ds1->hslab_def!=ds2->hslab_def)
+                HRETURN(ds1->hslab_def==TRUE ? 1 : -1);
+	}
+
+        break;
+
+    default:
+        assert("not implemented yet" && 0);
+    }
+
+    FUNC_LEAVE(0);
+}
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_is_simple
+ PURPOSE
+    Check if a dataspace is simple (internal)
+ USAGE
+    hbool_t H5S_is_simple(sdim)
+        H5S_t *sdim;            IN: Pointer to dataspace object to query
+ RETURNS
+    TRUE/FALSE/FAIL
+ DESCRIPTION
+        This function determines the if a dataspace is "simple". ie. if it
+    has orthogonal, evenly spaced dimensions.
+--------------------------------------------------------------------------*/
+hbool_t
+H5S_is_simple(const H5S_t *sdim)
+{
+    hbool_t                 ret_value = FAIL;
+
+    FUNC_ENTER(H5S_is_simple, FAIL);
+
+    /* Check args and all the boring stuff. */
+    assert(sdim);
+    ret_value = sdim->type == H5S_SIMPLE ? TRUE : FALSE;      /* Currently all dataspaces are simple, but check anyway */
+
+    FUNC_LEAVE(ret_value);
+}
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5Sis_simple
+ PURPOSE
+    Check if a dataspace is simple
+ USAGE
+    hbool_t H5Sis_simple(sid)
+        hid_t sid;            IN: ID of dataspace object to query
+ RETURNS
+    TRUE/FALSE/FAIL
+ DESCRIPTION
+        This function determines the if a dataspace is "simple". ie. if it
+    has orthogonal, evenly spaced dimensions.
+--------------------------------------------------------------------------*/
+hbool_t 
+H5Sis_simple(hid_t sid)
+{
+    H5S_t                  *space = NULL;       /* dataspace to modify */
+    hbool_t                 ret_value = FAIL;
+
+    FUNC_ENTER(H5Sis_simple, FAIL);
+
+    /* Check args and all the boring stuff. */
+    if ((space = H5A_object(sid)) == NULL)
+        HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "not a data space");
+
+    ret_value = H5S_is_simple(space);
+
+  done:
+    if (ret_value == FAIL) {   /* Error condition cleanup */
+
+    }                           /* end if */
+    /* Normal function cleanup */
+    FUNC_LEAVE(ret_value);
+}
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5Sset_space
+ PURPOSE
+    Determine the size of a dataspace
+ USAGE
+    herr_t H5Sset_space(sid, rank, dims)
+        hid_t sid;            IN: Dataspace object to query
+        intn rank;            IN: # of dimensions for the dataspace
+        const size_t *dims;   IN: Size of each dimension for the dataspace
+ RETURNS
+    SUCCEED/FAIL
+ DESCRIPTION
+        This function sets the number and size of each dimension in the
+    dataspace.  Setting RANK to a value of zero allows scalar objects to be
+    created.  Dimensions are specified from slowest to fastest changing in the
+    DIMS array (i.e. 'C' order).  Setting the size of a dimension to zero
+    indicates that the dimension is of unlimited size and should be allowed to
+    expand.  Currently, only the first dimension in the array (the slowest) may
+    be unlimited in size.
+--------------------------------------------------------------------------*/
+herr_t
+H5Sset_space(hid_t sid, int rank, const size_t *dims)
+{
+    H5S_t                  *space = NULL;       /* dataspace to modify */
+    intn                    u;  /* local counting variable */
+    herr_t                  ret_value = SUCCEED;
+
+    FUNC_ENTER(H5Sset_space, FAIL);
+
+    /* Check args */
+    if ((space = H5A_object(sid)) == NULL)
+        HRETURN_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "not a data space");
+    if (rank > 0 && dims == NULL)
+        HRETURN_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no dimensions specified");
+    if (rank<0)
+	HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "invalid rank");
+    if (dims) {
+	for (u=0; u<rank; u++) {
+	    if (dims[u]<=0) {
+		HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
+			       "invalid dimension size");
+	    }
+	}
+    }
+
+    /* shift out of the previous state to a "simple" dataspace */
+    switch (space->type) {
+    case H5S_SCALAR:
+    case H5S_SIMPLE:
+        /* do nothing */
+        break;
+
+    case H5S_COMPLEX:
+        /*
+         * eventually this will destroy whatever "complex" dataspace info
+         * is retained, right now it's an error
+         */
+        /* Fall through to report error */
+
+    default:
+        HRETURN_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL,
+		      "unknown data space class");
+    }
+    space->type = H5S_SIMPLE;
+
+    /* Reset hyperslab definition, if one is defined */
+    if(space->hslab_def==TRUE) {
+        H5MM_xfree(space->h.start);
+        H5MM_xfree(space->h.count);
+        H5MM_xfree(space->h.stride);
+        space->hslab_def=FALSE;
+    }
+
+    if (rank == 0) {            /* scalar variable */
+        space->type = H5S_SCALAR;
+        space->u.simple.rank = 0;       /* set to scalar rank */
+        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);
+    } else {
+        /* 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);
+
+        /* 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);
+
+    }
+    FUNC_LEAVE(ret_value);
+}
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5Sset_hyperslab
+ PURPOSE
+    Select a hyperslab from a simple dataspace
+ USAGE
+    herr_t H5Sset_hyperslab(sid, start, count, stride)
+        hid_t sid;            IN: Dataspace object to select hyperslab from
+        const int *start;  IN: Starting location for hyperslab to select
+        const size_t *count;  IN: Number of elements in hyperslab
+        const size_t *stride; IN: Packing of elements in hyperslab
+ RETURNS
+    SUCCEED/FAIL
+ DESCRIPTION
+        This function selects a hyperslab from a simple dataspace.  The stride
+    array may be used to sub-sample the hyperslab chosen, a value of 1 in each
+    position of the stride array selects contiguous elements in the array,
+    a value of 2 selects every other element, etc.  If the stride parameter is
+    set to NULL, a contiguous hyperslab is chosen.  The values in the start and
+    count arrays may be negative, to allow for selecting hyperslabs in chunked
+    datasets which extend in arbitrary directions.
+--------------------------------------------------------------------------*/
+herr_t
+H5Sset_hyperslab(hid_t sid, const int *start, const size_t *count, const size_t *stride)
+{
+    H5S_t                  *space = NULL;       /* dataspace to modify */
+    size_t                 *tmp_stride=NULL;    /* temp. copy of stride */
+    intn                    u;  /* local counting variable */
+    herr_t                  ret_value = SUCCEED;
+
+    FUNC_ENTER(H5Sset_hyperslab, FAIL);
+
+    /* Get the object */
+    if (H5_DATASPACE != H5A_group(sid) || (space = H5A_object(sid)) == NULL)
+        HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "not a data space");
+    if (start == NULL || count==NULL)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL,
+		    "invalid hyperslab selected");
+
+    /* We can't modify other types of dataspaces currently, so error out */
+    if (space->type!=H5S_SIMPLE)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL,
+		    "unknown dataspace type");
+
+    /* Set up stride values for later use */
+    tmp_stride= H5MM_xmalloc(space->u.simple.rank*sizeof(tmp_stride[0]));
+    for (u=0; u<space->u.simple.rank; u++) {
+        tmp_stride[u] = stride ? stride[u] : 1;
+    }
+
+    /* Range check arguments */
+    for (u=0; u<space->u.simple.rank; u++) {
+        if (start[u]<0 || start[u]>=space->u.simple.size[u]) {
+            HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL,
+			"hyperslab bounds out of range");
+	}
+	if (start[u]<0 ||
+	    start[u]+(count[u]*tmp_stride[u])>space->u.simple.size[u]) {
+            HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL,
+			"hyperslab bounds out of range");
+	}
+    }
+
+    /* Allocate space for the hyperslab information */
+    if (NULL==space->h.start) {
+        space->h.start= H5MM_xcalloc(space->u.simple.rank,sizeof(intn));
+        space->h.count= H5MM_xcalloc(space->u.simple.rank,sizeof(size_t));
+        space->h.stride= H5MM_xcalloc(space->u.simple.rank,sizeof(size_t));
+    }
+
+    /* Build hyperslab */
+    for(u=0; u<space->u.simple.rank; u++) {
+        space->h.start[u] = start[u];
+        space->h.count[u] = count[u];
+        space->h.stride[u] = tmp_stride[u];
+    }
+    space->hslab_def=TRUE;
+
+done:
+    if (ret_value == FAIL) {    /* Error condition cleanup */
+
+    }                           /* end if */
+
+    /* Normal function cleanup */
+    H5MM_xfree(tmp_stride);
+    FUNC_LEAVE(ret_value);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	H5Sget_hyperslab
+ *
+ * Purpose:	Retrieves information about the hyperslab from a simple data
+ *		space.  If no hyperslab has been defined then the hyperslab
+ *		is the same as the entire array.
+ *
+ * Return:	Success:	Hyperslab dimensionality.
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *              Wednesday, January 28, 1998
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+int
+H5Sget_hyperslab (hid_t sid, int offset[]/*out*/, size_t size[]/*out*/,
+		  size_t stride[]/*out*/)
+{
+    const H5S_t	*ds = NULL;
+    intn	ret_value = FAIL;
+    
+    FUNC_ENTER (H5Sget_hyperslab, FAIL);
+
+    /* Check args */
+    if (H5_DATASPACE!=H5A_group (sid) || NULL==(ds=H5A_object (sid))) {
+	HRETURN_ERROR (H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space");
+    }
+
+    /* Get hyperslab info */
+    if ((ret_value=H5S_get_hyperslab (ds, offset, size, stride))<0) {
+	HRETURN_ERROR (H5E_DATASPACE, H5E_CANTINIT, FAIL,
+		       "unable to retrieve hyperslab information");
+    }
+
+    FUNC_LEAVE (ret_value);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	H5S_get_hyperslab
+ *
+ * Purpose:	Retrieves information about the hyperslab from a simple data
+ *		space.  If no hyperslab has been defined then the hyperslab
+ *		is the same as the entire array.
+ *
+ * Return:	Success:	Hyperslab dimensionality.
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *              Wednesday, January 28, 1998
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+intn
+H5S_get_hyperslab (const H5S_t *ds, int offset[]/*out*/,
+		   size_t size[]/*out*/, size_t stride[]/*out*/)
+{
+    intn		i;
+    intn		ret_value = FAIL;
+    
+    FUNC_ENTER (H5S_get_hyperslab, FAIL);
+
+    /* Check args */
+    assert (ds);
+    switch (ds->type) {
+    case H5S_SCALAR:
+	break;
+
+    case H5S_SIMPLE:
+	if (ds->hslab_def) {
+	    for (i=0; i<ds->u.simple.rank; i++) {
+		if (offset) offset[i] = ds->h.start[i];
+		if (size) size[i] = ds->h.count[i];
+		if (stride) stride[i] = ds->h.stride[i];
+	    }
+	} else {
+	    for (i=0; i<ds->u.simple.rank; i++) {
+		if (offset) offset[i] = 0;
+		if (size) size[i] = ds->u.simple.size[i];
+		if (stride) stride[i] = 1;
+	    }
+	}
+	ret_value = ds->u.simple.rank;
+	break;
+
+    case H5S_COMPLEX:	/*fall through*/
+    default:
+	HRETURN_ERROR (H5E_DATASPACE, H5E_UNSUPPORTED, FAIL,
+		       "hyperslabs not supported for this type of space");
+    }
+
+    FUNC_LEAVE (ret_value);
+}
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5S_find
+ *
+ * Purpose:	Given two data spaces (MEM_SPACE and FILE_SPACE) this
+ *		function locates the data space conversion functions and
+ *		initializes CONV to point to them.  The CONV contains
+ *		function pointers for converting in either direction.
+ *
+ * Return:	Success:	Pointer to a data space conversion callback
+ *				list.
+ *
+ *		Failure:	NULL
+ *
+ * Programmer:	Robb Matzke
+ *              Wednesday, January 21, 1998
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+const H5S_conv_t *
+H5S_find (const H5S_t *mem_space, const H5S_t *file_space)
+{
+    static H5S_conv_t		_conv;
+    static const H5S_conv_t 	*conv = NULL;
+    
+    FUNC_ENTER (H5S_find, NULL);
+
+    /* Check args */
+    assert (mem_space && H5S_SIMPLE==mem_space->type);
+    assert (file_space && H5S_SIMPLE==file_space->type);
+
+    /*
+     * We can't do conversion if the source and destination select a
+     * different number of data points.
+     */
+    if (H5S_get_npoints (mem_space) != H5S_get_npoints (file_space)) {
+	HRETURN_ERROR (H5E_DATASPACE, H5E_BADRANGE, NULL,
+		       "memory and file data spaces are different sizes");
+    }
+
+    /*
+     * Initialize pointers.  This will eventually be a table lookup based
+     * on the source and destination data spaces, similar to H5T_find(), but
+     * for now we only support simple data spaces.
+     */
+    if (!conv) {
+	_conv.init = H5S_simp_init;
+	_conv.fgath = H5S_simp_fgath;
+	_conv.mscat = H5S_simp_mscat;
+	_conv.mgath = H5S_simp_mgath;
+	_conv.fscat = H5S_simp_fscat;
+	conv = &_conv;
+    }
+    
+    FUNC_LEAVE (conv);
+}
+
+/*-------------------------------------------------------------------------
+ * Function:	H5S_extend
+ *
+ * Purpose:	Extend the dimensions of a data space.
+ *
+ * Return:	Success:	Number of dimensions whose size increased.
+ *
+ *		Failure:	FAIL
+ *
+ * Programmer:	Robb Matzke
+ *              Friday, January 30, 1998
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+intn
+H5S_extend (H5S_t *space, const size_t *size)
+{
+    intn		i, ret_value=0;
+    
+    FUNC_ENTER (H5S_extend, FAIL);
+
+    /* Check args */
+    assert (space && H5S_SIMPLE==space->type);
+    assert (size);
+
+    for (i=0; i<space->u.simple.rank; i++) {
+	if (space->u.simple.size[i]<size[i]) {
+	    if (space->u.simple.max &&
+		H5S_UNLIMITED!=space->u.simple.max[i] &&
+		space->u.simple.max[i]<size[i]) {
+		HRETURN_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,
+			       "dimension cannot be increased");
+	    }
+	    ret_value++;
+	}
+    }
+
+    /* Update */
+    if (ret_value) {
+	for (i=0; i<space->u.simple.rank; i++) {
+	    if (space->u.simple.size[i]<size[i]) {
+		space->u.simple.size[i] = size[i];
+	    }
+	}
+    }
+
+    FUNC_LEAVE (ret_value);
+}
+