[svn-r8678] Purpose:

    Code cleanup & optimization

Description:
    Remove old structures that used a union to store information about the
dataspace extent and just store the information directly in the dataspace
extent itself.

    Remove ifdef'd references to permutation ordering in dataspaces.  We'll
definitely need more than this code if/when we implement this feature.

    Change allocation of dataspace information from calloc() to malloc().

Platforms tested:
    Solaris 2.7 (arabica)
    FreeBSD 4.10 (sleipnir) w/parallel
    Too minor to require h5committest

10 files changed, 186 insertions, 283 deletions

diff --git a/src/H5A.c b/src/H5A.c
index 72ec772..ec8ea87 100644
--- a/src/H5A.c
+++ b/src/H5A.c
@@ -1514,10 +1514,6 @@ H5A_copy(const H5A_t *old_attr)
         HDmemcpy(new_attr->data,old_attr->data,old_attr->data_size);
     } /* end if */
 
-#ifndef LATER
-    /* Copy the share info? */
-#endif
-
     /* Set the return value */
     ret_value=new_attr;
     
diff --git a/src/H5Osdspace.c b/src/H5Osdspace.c
index 9d76a29..0cfe6ba 100644
--- a/src/H5Osdspace.c
+++ b/src/H5Osdspace.c
@@ -115,45 +115,37 @@ H5O_sdspace_decode(H5F_t *f, hid_t UNUSED dxpl_id, const uint8_t *p, H5O_shared_
             HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, "wrong version number in data space message");
 
         /* Get rank */
-        sdim->u.simple.rank = *p++;
-        if (sdim->u.simple.rank>H5S_MAX_RANK)
+        sdim->rank = *p++;
+        if (sdim->rank>H5S_MAX_RANK)
             HGOTO_ERROR(H5E_OHDR, H5E_CANTINIT, NULL, "simple data space dimensionality is too large");
 
         /* Get dataspace flags for later */
         flags = *p++;
 
         /* Set the dataspace type to be simple or scalar as appropriate */
-        if(sdim->u.simple.rank>0)
+        if(sdim->rank>0)
             sdim->type = H5S_SIMPLE;
         else
             sdim->type = H5S_SCALAR;
 
         p += 5; /*reserved*/
 
-        if (sdim->u.simple.rank > 0) {
-            if (NULL==(sdim->u.simple.size=H5FL_ARR_MALLOC(hsize_t,sdim->u.simple.rank)))
+        if (sdim->rank > 0) {
+            if (NULL==(sdim->size=H5FL_ARR_MALLOC(hsize_t,sdim->rank)))
                 HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
-            for (i = 0; i < sdim->u.simple.rank; i++)
-                H5F_DECODE_LENGTH (f, p, sdim->u.simple.size[i]);
+            for (i = 0; i < sdim->rank; i++)
+                H5F_DECODE_LENGTH (f, p, sdim->size[i]);
             if (flags & H5S_VALID_MAX) {
-                if (NULL==(sdim->u.simple.max=H5FL_ARR_MALLOC(hsize_t,sdim->u.simple.rank)))
+                if (NULL==(sdim->max=H5FL_ARR_MALLOC(hsize_t,sdim->rank)))
                     HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
-                for (i = 0; i < sdim->u.simple.rank; i++)
-                    H5F_DECODE_LENGTH (f, p, sdim->u.simple.max[i]);
+                for (i = 0; i < sdim->rank; i++)
+                    H5F_DECODE_LENGTH (f, p, sdim->max[i]);
             }
-#ifdef LATER
-            if (flags & H5S_VALID_PERM) {
-                if (NULL==(sdim->u.simple.perm=H5FL_ARR_MALLOC(hsize_t,sdim->u.simple.rank)))
-                    HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
-                for (i = 0; i < sdim->u.simple.rank; i++)
-                    H5F_DECODE_LENGTH (f, p, sdim->u.simple.perm[i]);
-            }
-#endif /* LATER */
         }
 
         /* Compute the number of elements in the extent */
-        for(i=0, sdim->nelem=1; i<sdim->u.simple.rank; i++)
-            sdim->nelem*=sdim->u.simple.size[i];
+        for(i=0, sdim->nelem=1; i<sdim->rank; i++)
+            sdim->nelem*=sdim->size[i];
     }
 
     /* Set return value */
@@ -210,16 +202,12 @@ H5O_sdspace_encode(H5F_t *f, uint8_t *p, const void *mesg)
     assert(sdim);
 
     /* set flags */
-    if (sdim->u.simple.max)
+    if (sdim->max)
         flags |= H5S_VALID_MAX;
-#ifdef LATER
-    if (sdim->u.simple.perm)
-        flags |= H5S_VALID_PERM;
-#endif
 
     /* encode */
     *p++ = H5O_SDSPACE_VERSION;
-    *p++ = sdim->u.simple.rank;
+    *p++ = sdim->rank;
     *p++ = flags;
     *p++ = 0; /*reserved*/
     *p++ = 0; /*reserved*/
@@ -227,19 +215,13 @@ H5O_sdspace_encode(H5F_t *f, uint8_t *p, const void *mesg)
     *p++ = 0; /*reserved*/
     *p++ = 0; /*reserved*/
 
-    if (sdim->u.simple.rank > 0) {
-        for (u = 0; u < sdim->u.simple.rank; u++)
-            H5F_ENCODE_LENGTH (f, p, sdim->u.simple.size[u]);
+    if (sdim->rank > 0) {
+        for (u = 0; u < sdim->rank; u++)
+            H5F_ENCODE_LENGTH (f, p, sdim->size[u]);
         if (flags & H5S_VALID_MAX) {
-            for (u = 0; u < sdim->u.simple.rank; u++) 
-                H5F_ENCODE_LENGTH (f, p, sdim->u.simple.max[u]);
+            for (u = 0; u < sdim->rank; u++) 
+                H5F_ENCODE_LENGTH (f, p, sdim->max[u]);
         }
-#ifdef LATER
-        if (flags & H5S_VALID_PERM) {
-            for (u = 0; u < sdim->u.simple.rank; u++)
-                H5F_ENCODE_LENGTH (f, p, sdim->u.simple.perm[u]);
-        }
-#endif
     }
 
 done:
@@ -322,15 +304,10 @@ H5O_sdspace_size(H5F_t *f, const void *mesg)
     FUNC_ENTER_NOAPI(H5O_sdspace_size, 0);
 
     /* add in the dimension sizes */
-    ret_value += space->u.simple.rank * H5F_SIZEOF_SIZE (f);
+    ret_value += space->rank * H5F_SIZEOF_SIZE (f);
 
     /* add in the space for the maximum dimensions, if they are present */
-    ret_value += space->u.simple.max ? space->u.simple.rank * H5F_SIZEOF_SIZE (f) : 0;
-
-#ifdef LATER
-    /* add in the space for the dimension permutations, if they are present */
-    ret_value += space->u.simple.perm ? space->u.simple.rank * 4 : 0;
-#endif
+    ret_value += space->max ? space->rank * H5F_SIZEOF_SIZE (f) : 0;
 
 done:
     FUNC_LEAVE_NOAPI(ret_value);
@@ -434,38 +411,28 @@ H5O_sdspace_debug(H5F_t UNUSED *f, hid_t UNUSED dxpl_id, const void *mesg,
 
     HDfprintf(stream, "%*s%-*s %lu\n", indent, "", fwidth,
 	    "Rank:",
-	    (unsigned long) (sdim->u.simple.rank));
+	    (unsigned long) (sdim->rank));
     
-    if(sdim->u.simple.rank>0) {
+    if(sdim->rank>0) {
         HDfprintf(stream, "%*s%-*s {", indent, "", fwidth, "Dim Size:");
-        for (u = 0; u < sdim->u.simple.rank; u++)
-            HDfprintf (stream, "%s%Hu", u?", ":"", sdim->u.simple.size[u]);
+        for (u = 0; u < sdim->rank; u++)
+            HDfprintf (stream, "%s%Hu", u?", ":"", sdim->size[u]);
         HDfprintf (stream, "}\n");
         
         HDfprintf(stream, "%*s%-*s ", indent, "", fwidth, "Dim Max:");
-        if (sdim->u.simple.max) {
+        if (sdim->max) {
             HDfprintf (stream, "{");
-            for (u = 0; u < sdim->u.simple.rank; u++) {
-                if (H5S_UNLIMITED==sdim->u.simple.max[u]) {
+            for (u = 0; u < sdim->rank; u++) {
+                if (H5S_UNLIMITED==sdim->max[u]) {
                     HDfprintf (stream, "%sINF", u?", ":"");
                 } else {
-                    HDfprintf (stream, "%s%Hu", u?", ":"", sdim->u.simple.max[u]);
+                    HDfprintf (stream, "%s%Hu", u?", ":"", sdim->max[u]);
                 }
             }
             HDfprintf (stream, "}\n");
         } else {
             HDfprintf (stream, "CONSTANT\n");
         }
-
-#ifdef LATER
-        if (sdim->u.simple.perm) {
-            HDfprintf(stream, "%*s%-*s {", indent, "", fwidth, "Dim Perm:");
-            for (u = 0; u < sdim->u.simple.rank; u++) {
-                HDfprintf (stream, "%s%lu", u?", ":"",
-                     (unsigned long) (sdim->u.simple.perm[u]));
-            }
-        }
-#endif
     } /* end if */
 
 done:
diff --git a/src/H5S.c b/src/H5S.c
index 2f4ab8a..955b2a6 100644
--- a/src/H5S.c
+++ b/src/H5S.c
@@ -28,7 +28,6 @@ static H5S_t * H5S_create(H5S_class_t type);
 static herr_t H5S_set_extent_simple (H5S_t *space, unsigned rank,
     const hsize_t *dims, const hsize_t *max);
 static htri_t H5S_is_simple(const H5S_t *sdim);
-static herr_t H5S_release_simple(H5S_simple_t *simple);
 
 /* Interface initialization */
 #define PABLO_MASK	H5S_mask
@@ -301,8 +300,10 @@ H5S_create(H5S_class_t type)
     FUNC_ENTER_NOAPI(H5S_create, NULL);
 
     /* Create a new data space */
-    if((ret_value = H5FL_CALLOC(H5S_t))!=NULL) {
+    if((ret_value = H5FL_MALLOC(H5S_t))!=NULL) {
         ret_value->extent.type = type;
+        ret_value->extent.rank = 0;
+        ret_value->extent.size = ret_value->extent.max = NULL;
 
         switch(type) {
             case H5S_SCALAR:
@@ -316,8 +317,12 @@ H5S_create(H5S_class_t type)
                 break;
         } /* end switch */
 
+        /* Start with "all" selection */
         if(H5S_select_all(ret_value,0)<0)
             HGOTO_ERROR (H5E_DATASPACE, H5E_CANTSET, NULL, "unable to set all selection");
+
+        /* Reset common selection info pointer */
+        ret_value->select.sel_info.hslab=NULL;
     } /* end if */
 
 done:
@@ -396,28 +401,13 @@ H5S_extent_release(H5S_extent_t *extent)
 
     assert(extent);
 
-    /* release extent */
-    switch (extent->type) {
-        case H5S_NO_CLASS:
-            /*nothing needed */
-            break;
-
-        case H5S_SCALAR:
-            /*nothing needed */
-            break;
-
-        case H5S_SIMPLE:
-            ret_value=H5S_release_simple(&(extent->u.simple));
-            break;
-
-        case H5S_COMPLEX:
-            /* nothing yet */
-            break;
-
-        default:
-            assert("unknown dataspace (extent) type" && 0);
-            break;
-    }
+    /* Release extent */
+    if(extent->type==H5S_SIMPLE) {
+        if(extent->size)
+            H5FL_ARR_FREE(hsize_t,extent->size);
+        if(extent->max)
+            H5FL_ARR_FREE(hsize_t,extent->max);
+    } /* end if */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value);
@@ -499,41 +489,6 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5S_release_simple
- *
- * Purpose:	Releases all memory associated with a simple data space.
- *          (but doesn't free the simple space itself)
- *
- * Return:	Non-negative on success/Negative on failure
- *
- * Programmer:	Quincey Koziol
- *		Friday, April  17, 1998
- *
- * Modifications:
- *
- *-------------------------------------------------------------------------
- */
-static herr_t
-H5S_release_simple(H5S_simple_t *simple)
-{
-    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5S_release_simple);
-
-    assert(simple);
-
-    if(simple->size)
-        H5FL_ARR_FREE(hsize_t,simple->size);
-    if(simple->max)
-        H5FL_ARR_FREE(hsize_t,simple->max);
-#ifdef LATER
-    if(simple->perm)
-        H5FL_ARR_FREE(hsize_t,simple->perm);
-#endif /* LATER */
-
-    FUNC_LEAVE_NOAPI(SUCCEED);
-}
-
-
-/*-------------------------------------------------------------------------
  * Function:	H5Scopy
  *
  * Purpose:	Copies a dataspace.
@@ -645,29 +600,29 @@ H5S_extent_copy(H5S_extent_t *dst, const H5S_extent_t *src)
     /* Copy the regular fields */
     dst->type=src->type;
     dst->nelem=src->nelem;
-    dst->u.simple.rank=src->u.simple.rank;
+    dst->rank=src->rank;
 
     switch (src->type) {
         case H5S_SCALAR:
-            dst->u.simple.size=NULL;
-            dst->u.simple.max=NULL;
+            dst->size=NULL;
+            dst->max=NULL;
             break;
 
         case H5S_SIMPLE:
-            if (src->u.simple.size) {
-                dst->u.simple.size = H5FL_ARR_MALLOC(hsize_t,src->u.simple.rank);
-                for (u = 0; u < src->u.simple.rank; u++)
-                    dst->u.simple.size[u] = src->u.simple.size[u];
+            if (src->size) {
+                dst->size = H5FL_ARR_MALLOC(hsize_t,src->rank);
+                for (u = 0; u < src->rank; u++)
+                    dst->size[u] = src->size[u];
             }
             else
-                dst->u.simple.size=NULL;
-            if (src->u.simple.max) {
-                dst->u.simple.max = H5FL_ARR_MALLOC(hsize_t,src->u.simple.rank);
-                for (u = 0; u < src->u.simple.rank; u++)
-                    dst->u.simple.max[u] = src->u.simple.max[u];
+                dst->size=NULL;
+            if (src->max) {
+                dst->max = H5FL_ARR_MALLOC(hsize_t,src->rank);
+                for (u = 0; u < src->rank; u++)
+                    dst->max[u] = src->max[u];
             }
             else
-                dst->u.simple.max=NULL;
+                dst->max=NULL;
             break;
 
         case H5S_COMPLEX:
@@ -716,11 +671,6 @@ H5S_copy(const H5S_t *src, hbool_t share_selection)
     if (NULL==(dst = H5FL_MALLOC(H5S_t)))
         HGOTO_ERROR (H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed");
 
-#ifdef LATER
-    /* Copy the field in the struct */
-    *dst = *src;
-#endif /* LATER */
-
     /* Copy the source dataspace's extent */
     if (H5S_extent_copy(&(dst->extent),&(src->extent))<0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOPY, NULL, "can't copy extent");
@@ -851,19 +801,19 @@ H5S_get_npoints_max(const H5S_t *ds)
             break;
 
         case H5S_SIMPLE:
-            if (ds->extent.u.simple.max) {
-                for (ret_value=1, u=0; u<ds->extent.u.simple.rank; u++) {
-                    if (H5S_UNLIMITED==ds->extent.u.simple.max[u]) {
+            if (ds->extent.max) {
+                for (ret_value=1, u=0; u<ds->extent.rank; u++) {
+                    if (H5S_UNLIMITED==ds->extent.max[u]) {
                         ret_value = HSIZET_MAX;
                         break;
                     }
                     else
-                        ret_value *= ds->extent.u.simple.max[u];
+                        ret_value *= ds->extent.max[u];
                 }
             }
             else {
-                for (ret_value=1, u=0; u<ds->extent.u.simple.rank; u++)
-                    ret_value *= ds->extent.u.simple.size[u];
+                for (ret_value=1, u=0; u<ds->extent.rank; u++)
+                    ret_value *= ds->extent.size[u];
             }
             break;
 
@@ -950,7 +900,7 @@ H5S_get_simple_extent_ndims(const H5S_t *ds)
     switch (H5S_GET_EXTENT_TYPE(ds)) {
         case H5S_SCALAR:
         case H5S_SIMPLE:
-            ret_value = ds->extent.u.simple.rank;
+            ret_value = ds->extent.rank;
             break;
 
         case H5S_COMPLEX:
@@ -1043,15 +993,15 @@ H5S_get_simple_extent_dims(const H5S_t *ds, hsize_t dims[], hsize_t max_dims[])
             break;
 
         case H5S_SIMPLE:
-            ret_value = ds->extent.u.simple.rank;
+            ret_value = ds->extent.rank;
             for (i=0; i<ret_value; i++) {
                 if (dims)
-                    dims[i] = ds->extent.u.simple.size[i];
+                    dims[i] = ds->extent.size[i];
                 if (max_dims) {
-                    if (ds->extent.u.simple.max)
-                        max_dims[i] = ds->extent.u.simple.max[i];
+                    if (ds->extent.max)
+                        max_dims[i] = ds->extent.max[i];
                     else
-                        max_dims[i] = ds->extent.u.simple.size[i];
+                        max_dims[i] = ds->extent.size[i];
                 }
             }
             break;
@@ -1378,27 +1328,28 @@ H5S_set_extent_simple (H5S_t *space, unsigned rank, const hsize_t *dims,
     if (rank == 0) {		/* scalar variable */
         space->extent.type = H5S_SCALAR;
         space->extent.nelem = 1;
-        space->extent.u.simple.rank = 0;	/* set to scalar rank */
+        space->extent.rank = 0;	/* set to scalar rank */
     } else {
         hsize_t nelem;  /* Number of elements in extent */
         unsigned u;     /* Local index variable */
 
         space->extent.type = H5S_SIMPLE;
 
-        /* Set the rank and copy the dims */
-        space->extent.u.simple.rank = rank;
-        space->extent.u.simple.size = H5FL_ARR_MALLOC(hsize_t,rank);
-        HDmemcpy(space->extent.u.simple.size, dims, sizeof(hsize_t) * rank);
+        /* Set the rank and allocate space for the dims */
+        space->extent.rank = rank;
+        space->extent.size = H5FL_ARR_MALLOC(hsize_t,rank);
 
-        /* Compute the number of elements in the extent */
-        for(u=0, nelem=1; u<space->extent.u.simple.rank; u++)
-            nelem*=space->extent.u.simple.size[u];
+        /* Copy the dimensions & compute the number of elements in the extent */
+        for(u=0, nelem=1; u<space->extent.rank; u++) {
+            space->extent.size[u]=dims[u];
+            nelem*=dims[u];
+        } /* end for */
         space->extent.nelem = nelem;
 
         /* Copy the maximum dimensions if specified */
         if(max!=NULL) {
-            space->extent.u.simple.max = H5FL_ARR_MALLOC(hsize_t,rank);
-            HDmemcpy(space->extent.u.simple.max, max, sizeof(hsize_t) * rank);
+            space->extent.max = H5FL_ARR_MALLOC(hsize_t,rank);
+            HDmemcpy(space->extent.max, max, sizeof(hsize_t) * rank);
         } /* end if */
     }
 
@@ -1608,11 +1559,11 @@ H5S_extend (H5S_t *space, const hsize_t *size)
     assert (size);
 
     /* Check through all the dimensions to see if modifying the dataspace is allowed */
-    for (u=0; u<space->extent.u.simple.rank; u++) {
-        if (space->extent.u.simple.size[u]<size[u]) {
-            if (space->extent.u.simple.max &&
-                    H5S_UNLIMITED!=space->extent.u.simple.max[u] &&
-                    space->extent.u.simple.max[u]<size[u])
+    for (u=0; u<space->extent.rank; u++) {
+        if (space->extent.size[u]<size[u]) {
+            if (space->extent.max &&
+                    H5S_UNLIMITED!=space->extent.max[u] &&
+                    space->extent.max[u]<size[u])
                 HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL, "dimension cannot be increased");
             ret_value++;
         }
@@ -1623,11 +1574,11 @@ H5S_extend (H5S_t *space, const hsize_t *size)
         hsize_t nelem;  /* Number of elements in extent */
 
         /* Change the dataspace size & re-compute the number of elements in the extent */
-        for (u=0, nelem=1; u<space->extent.u.simple.rank; u++) {
-            if (space->extent.u.simple.size[u]<size[u])
-                space->extent.u.simple.size[u] = size[u];
+        for (u=0, nelem=1; u<space->extent.rank; u++) {
+            if (space->extent.size[u]<size[u])
+                space->extent.size[u] = size[u];
 
-            nelem*=space->extent.u.simple.size[u];
+            nelem*=space->extent.size[u];
         }
         space->extent.nelem = nelem;
 
@@ -1900,7 +1851,7 @@ H5Soffset_simple(hid_t space_id, const hssize_t *offset)
     /* Check args */
     if (NULL == (space = H5I_object_verify(space_id, H5I_DATASPACE)))
         HGOTO_ERROR(H5E_ATOM, H5E_BADATOM, FAIL, "not a data space");
-    if (space->extent.u.simple.rank==0 || H5S_GET_EXTENT_TYPE(space)==H5S_SCALAR)
+    if (space->extent.rank==0 || H5S_GET_EXTENT_TYPE(space)==H5S_SCALAR)
         HGOTO_ERROR(H5E_ATOM, H5E_UNSUPPORTED, FAIL, "can't set offset on scalar dataspace");
     if (offset == NULL)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "no offset specified");
@@ -1942,10 +1893,9 @@ H5S_set_extent( H5S_t *space, const hsize_t *size )
     assert( size);
 
     /* Verify that the dimensions being changed are allowed to change */
-    for ( u = 0; u < space->extent.u.simple.rank; u++ ) {
-        if ( space->extent.u.simple.max &&
-                 H5S_UNLIMITED != space->extent.u.simple.max[u] &&
-                 space->extent.u.simple.max[u]!=size[u] )
+    for ( u = 0; u < space->extent.rank; u++ ) {
+        if ( space->extent.max && H5S_UNLIMITED != space->extent.max[u] &&
+                 space->extent.max[u]!=size[u] )
              HGOTO_ERROR (H5E_ARGS, H5E_BADVALUE, FAIL,"dimension cannot be modified");
         ret_value++;
     } /* end for */
@@ -1988,9 +1938,9 @@ H5S_set_extent_real( H5S_t *space, const hsize_t *size )
     assert(size);
 
     /* Change the dataspace size & re-compute the number of elements in the extent */
-    for (u=0, nelem=1; u < space->extent.u.simple.rank; u++ ) {
-        space->extent.u.simple.size[u] = size[u];
-        nelem*=space->extent.u.simple.size[u];
+    for (u=0, nelem=1; u < space->extent.rank; u++ ) {
+        space->extent.size[u] = size[u];
+        nelem*=space->extent.size[u];
     } /* end for */
     space->extent.nelem = nelem;
 
diff --git a/src/H5Sall.c b/src/H5Sall.c
index 1058e07..8b53cb9 100644
--- a/src/H5Sall.c
+++ b/src/H5Sall.c
@@ -623,12 +623,12 @@ H5S_all_bounds(const H5S_t *space, hssize_t *start, hssize_t *end)
     assert(end);
 
     /* Get the dataspace extent rank */
-    rank=space->extent.u.simple.rank;
+    rank=space->extent.rank;
 
     /* Just copy over the complete extent */
     for(i=0; i<rank; i++) {
         start[i]=0;
-        H5_ASSIGN_OVERFLOW(end[i],space->extent.u.simple.size[i]-1,hsize_t,hssize_t);
+        H5_ASSIGN_OVERFLOW(end[i],space->extent.size[i]-1,hsize_t,hssize_t);
     } /* end for */
 
 done:
diff --git a/src/H5Shyper.c b/src/H5Shyper.c
index 91e55e6..0a2f084 100644
--- a/src/H5Shyper.c
+++ b/src/H5Shyper.c
@@ -201,8 +201,8 @@ H5S_hyper_print_diminfo(FILE *f, const H5S_t *space)
 {
     FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5S_hyper_print_diminfo);
 
-    H5S_hyper_print_diminfo_helper(f,"opt_diminfo",space->extent.u.simple.rank,space->select.sel_info.hslab->opt_diminfo);
-    H5S_hyper_print_diminfo_helper(f,"app_diminfo",space->extent.u.simple.rank,space->select.sel_info.hslab->app_diminfo);
+    H5S_hyper_print_diminfo_helper(f,"opt_diminfo",space->extent.rank,space->select.sel_info.hslab->opt_diminfo);
+    H5S_hyper_print_diminfo_helper(f,"app_diminfo",space->extent.rank,space->select.sel_info.hslab->app_diminfo);
 
     FUNC_LEAVE_NOAPI(SUCCEED);
 }
@@ -249,7 +249,7 @@ H5S_hyper_iter_init(H5S_sel_iter_t *iter, const H5S_t *space)
     iter->u.hyp.iter_rank=0;
 
     /* Get the rank of the dataspace */
-    rank=space->extent.u.simple.rank;
+    rank=space->extent.rank;
 
     /* Set the temporary pointer to the dimension information */
     tdiminfo=space->select.sel_info.hslab->opt_diminfo;
@@ -262,7 +262,7 @@ H5S_hyper_iter_init(H5S_sel_iter_t *iter, const H5S_t *space)
         unsigned cont_dim=0;        /* # of contiguous dimensions */
 
         /* Set the temporary pointer to the dataspace extent's dimension sizes */
-        mem_size=space->extent.u.simple.size;
+        mem_size=space->extent.size;
 
         /*
          * For a regular hyperslab to be contiguous up to some dimension, it
@@ -1715,27 +1715,27 @@ H5S_hyper_is_valid (const H5S_t *space)
         hssize_t end;      /* The high bound of a region in a dimension */
 
         /* Check each dimension */
-        for(u=0; u<space->extent.u.simple.rank; u++) {
+        for(u=0; u<space->extent.rank; u++) {
             /* if block or count is zero, then can skip the test since */
             /* no data point is chosen */
             if (diminfo[u].count && diminfo[u].block) {
                 /* Bounds check the start point in this dimension */
                 if((diminfo[u].start+space->select.offset[u])<0 ||
-                        (diminfo[u].start+space->select.offset[u])>=(hssize_t)space->extent.u.simple.size[u])
+                        (diminfo[u].start+space->select.offset[u])>=(hssize_t)space->extent.size[u])
                     HGOTO_DONE(FALSE)
 
                 /* Compute the largest location in this dimension */
                 end=diminfo[u].start+diminfo[u].stride*(diminfo[u].count-1)+(diminfo[u].block-1)+space->select.offset[u];
 
                 /* Bounds check the end point in this dimension */
-                if(end<0 || end>=(hssize_t)space->extent.u.simple.size[u])
+                if(end<0 || end>=(hssize_t)space->extent.size[u])
                     HGOTO_DONE(FALSE)
             } /* end if */
         } /* end for */
     } /* end if */
     else {
         /* Call the recursive routine to validate the span tree */
-        ret_value=H5S_hyper_is_valid_helper(space->select.sel_info.hslab->span_lst,space->select.offset,space->extent.u.simple.size,(hsize_t)0);
+        ret_value=H5S_hyper_is_valid_helper(space->select.sel_info.hslab->span_lst,space->select.offset,space->extent.size,(hsize_t)0);
     } /* end else */
 
 done:
@@ -1821,7 +1821,7 @@ H5S_get_select_hyper_nblocks(H5S_t *space)
     /* Check for a "regular" hyperslab selection */
     if(space->select.sel_info.hslab->diminfo_valid) {
         /* Check each dimension */
-        for(ret_value=1,u=0; u<space->extent.u.simple.rank; u++)
+        for(ret_value=1,u=0; u<space->extent.rank; u++)
             ret_value*=space->select.sel_info.hslab->app_diminfo[u].count;
     } /* end if */
     else
@@ -1909,14 +1909,14 @@ H5S_hyper_serial_size (const H5S_t *space)
     /* Check for a "regular" hyperslab selection */
     if(space->select.sel_info.hslab->diminfo_valid) {
         /* Check each dimension */
-        for(block_count=1,u=0; u<space->extent.u.simple.rank; u++)
+        for(block_count=1,u=0; u<space->extent.rank; u++)
             block_count*=space->select.sel_info.hslab->opt_diminfo[u].count;
-        ret_value+=8*block_count*space->extent.u.simple.rank;
+        ret_value+=8*block_count*space->extent.rank;
     } /* end if */
     else {
         /* Spin through hyperslab spans, adding 8 * rank bytes for each block */
         block_count=H5S_hyper_span_nblocks(space->select.sel_info.hslab->span_lst);
-        ret_value+=8*space->extent.u.simple.rank*block_count;
+        ret_value+=8*space->extent.rank*block_count;
     } /* end else */
 
 done:
@@ -2052,13 +2052,13 @@ H5S_hyper_serialize (const H5S_t *space, uint8_t *buf)
     buf+=4;             /* skip over space for length */
 
     /* Encode number of dimensions */
-    UINT32ENCODE(buf, (uint32_t)space->extent.u.simple.rank);
+    UINT32ENCODE(buf, (uint32_t)space->extent.rank);
     len+=4;
 
     /* Check for a "regular" hyperslab selection */
     if(space->select.sel_info.hslab->diminfo_valid) {
         /* Set some convienence values */
-        ndims=space->extent.u.simple.rank;
+        ndims=space->extent.rank;
         fast_dim=ndims-1;
         diminfo=space->select.sel_info.hslab->opt_diminfo;
 
@@ -2148,8 +2148,8 @@ H5S_hyper_serialize (const H5S_t *space, uint8_t *buf)
 
         /* Add 8 bytes times the rank for each hyperslab selected */
         H5_CHECK_OVERFLOW(block_count,hssize_t,hsize_t);
-        H5_CHECK_OVERFLOW((8*space->extent.u.simple.rank*(hsize_t)block_count),hsize_t,size_t);
-        len+=(size_t)(8*space->extent.u.simple.rank*block_count);
+        H5_CHECK_OVERFLOW((8*space->extent.rank*(hsize_t)block_count),hsize_t,size_t);
+        len+=(size_t)(8*space->extent.rank*block_count);
 
         /* Encode each hyperslab in selection */
         H5S_hyper_serialize_helper(space->select.sel_info.hslab->span_lst,start,end,(hsize_t)0,&buf);
@@ -2209,7 +2209,7 @@ H5S_hyper_deserialize (H5S_t *space, const uint8_t *buf)
     /* Deserialize slabs to select */
     buf+=16;    /* Skip over selection header */
     UINT32DECODE(buf,rank);  /* decode the rank of the point selection */
-    if(rank!=space->extent.u.simple.rank)
+    if(rank!=space->extent.rank)
         HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "rank of pointer does not match dataspace");
     UINT32DECODE(buf,num_elem);  /* decode the number of points */
 
@@ -2401,7 +2401,7 @@ H5S_get_select_hyper_blocklist(H5S_t *space, hbool_t internal, hsize_t startbloc
     /* Check for a "regular" hyperslab selection */
     if(space->select.sel_info.hslab->diminfo_valid) {
         /* Set some convienence values */
-        ndims=space->extent.u.simple.rank;
+        ndims=space->extent.rank;
         fast_dim=ndims-1;
 
         /* Check which set of dimension information to use */
@@ -2663,7 +2663,7 @@ H5S_hyper_bounds(const H5S_t *space, hssize_t *start, hssize_t *end)
     assert(end);
 
     /* Set the start and end arrays up */
-    rank=space->extent.u.simple.rank;
+    rank=space->extent.rank;
     for(i=0; i<rank; i++) {
         start[i]=HSSIZET_MAX;
         end[i]=HSSIZET_MIN;
@@ -2746,12 +2746,12 @@ H5S_hyper_is_contiguous(const H5S_t *space)
         small_contiguous=FALSE;	/* assume false initially */
 
         /* Check for a "large contigous" block */
-        for(u=0; u<space->extent.u.simple.rank; u++) {
+        for(u=0; u<space->extent.rank; u++) {
             if(diminfo[u].count>1) {
                 large_contiguous=FALSE;
                 break;
             } /* end if */
-            if(u>0 && diminfo[u].block!=space->extent.u.simple.size[u]) {
+            if(u>0 && diminfo[u].block!=space->extent.size[u]) {
                 large_contiguous=FALSE;
                 break;
             } /* end if */
@@ -2760,12 +2760,12 @@ H5S_hyper_is_contiguous(const H5S_t *space)
         /* If we didn't find a large contiguous block, check for a small one */
         if(large_contiguous==FALSE) {
             small_contiguous=TRUE;
-            for(u=0; u<space->extent.u.simple.rank; u++) {
+            for(u=0; u<space->extent.rank; u++) {
                 if(diminfo[u].count>1) {
                     small_contiguous=FALSE;
                     break;
                 } /* end if */
-                if(u<(space->extent.u.simple.rank-1) && diminfo[u].block!=1) {
+                if(u<(space->extent.rank-1) && diminfo[u].block!=1) {
                     small_contiguous=FALSE;
                     break;
                 } /* end if */
@@ -2814,7 +2814,7 @@ H5S_hyper_is_contiguous(const H5S_t *space)
                     } /* end if */
                     else {
                         /* If this span doesn't cover the entire dimension, then this selection isn't contiguous */
-                        if(((span->high-span->low)+1)!=(hssize_t)space->extent.u.simple.size[u]) {
+                        if(((span->high-span->low)+1)!=(hssize_t)space->extent.size[u]) {
                             large_contiguous=FALSE;
                             break;
                         } /* end if */
@@ -2852,7 +2852,7 @@ H5S_hyper_is_contiguous(const H5S_t *space)
                 } /* end if */
                 else {
                     /* If this span doesn't cover the entire dimension, then this selection isn't contiguous */
-                    if(u<(space->extent.u.simple.rank-1) && ((span->high-span->low)+1)!=1) {
+                    if(u<(space->extent.rank-1) && ((span->high-span->low)+1)!=1) {
                         small_contiguous=FALSE;
                         break;
                     } /* end if */
@@ -2918,7 +2918,7 @@ H5S_hyper_is_single(const H5S_t *space)
         ret_value=TRUE;	/* assume true and reset if the dimensions don't match */
 
         /* Check for a single block */
-        for(u=0; u<space->extent.u.simple.rank; u++) {
+        for(u=0; u<space->extent.rank; u++) {
             if(space->select.sel_info.hslab->opt_diminfo[u].count>1) {
                 ret_value=FALSE;
                 break;
@@ -3508,11 +3508,11 @@ H5S_hyper_convert(H5S_t *space)
                 unsigned u;                             /* Local index variable */
 
                 /* Fill in temporary information for the dimensions */
-                for(u=0; u<space->extent.u.simple.rank; u++) {
+                for(u=0; u<space->extent.rank; u++) {
                     tmp_start[u]=0;
                     tmp_stride[u]=1;
                     tmp_count[u]=1;
-                    tmp_block[u]=space->extent.u.simple.size[u];
+                    tmp_block[u]=space->extent.size[u];
                 } /* end for */
 
                 /* Convert to hyperslab selection */
@@ -3641,7 +3641,7 @@ H5S_hyper_intersect (H5S_t *space1, H5S_t *space2)
         HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "dataspace does not have span tree");
 
     /* Check that the dataspaces are both the same rank */
-    if(space1->extent.u.simple.rank!=space2->extent.u.simple.rank)
+    if(space1->extent.rank!=space2->extent.rank)
         HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "dataspace ranks don't match");
 
     /* Perform the span-by-span intersection check */
@@ -3868,7 +3868,7 @@ H5S_hyper_adjust(H5S_t *space, const hssize_t *offset)
 
     /* Subtract the offset from the "regular" coordinates, if they exist */
     if(space->select.sel_info.hslab->diminfo_valid) {
-        for(u=0; u<space->extent.u.simple.rank; u++) {
+        for(u=0; u<space->extent.rank; u++) {
             space->select.sel_info.hslab->opt_diminfo[u].start-=offset[u];
             assert(space->select.sel_info.hslab->opt_diminfo[u].start>=0);
         } /* end for */
@@ -3983,7 +3983,7 @@ H5S_hyper_move(H5S_t *space, const hssize_t *offset)
 
     /* Move to the offset with the "regular" coordinates, if they exist */
     if(space->select.sel_info.hslab->diminfo_valid) {
-        for(u=0; u<space->extent.u.simple.rank; u++) {
+        for(u=0; u<space->extent.rank; u++) {
             space->select.sel_info.hslab->opt_diminfo[u].start=offset[u];
             assert(space->select.sel_info.hslab->opt_diminfo[u].start>=0);
         } /* end for */
@@ -4037,7 +4037,7 @@ H5S_hyper_normalize_offset(H5S_t *space)
     /* (Technically, this check shouldn't be in the "hyperslab" routines...) */
     if(H5S_GET_SELECT_TYPE(space)!=H5S_SEL_ALL) {
         /* Invert the selection offset */
-        for(u=0; u<space->extent.u.simple.rank; u++)
+        for(u=0; u<space->extent.rank; u++)
             space->select.offset[u] =- space->select.offset[u];
 
         /* Call the existing 'adjust' routine */
@@ -4045,7 +4045,7 @@ H5S_hyper_normalize_offset(H5S_t *space)
             HGOTO_ERROR(H5E_DATASPACE, H5E_BADSELECT, FAIL, "can't perform hyperslab normalization");
 
         /* Zero out the selection offset */
-        for(u=0; u<space->extent.u.simple.rank; u++)
+        for(u=0; u<space->extent.rank; u++)
             space->select.offset[u] = 0;
     } /* end if */
 
@@ -5287,7 +5287,7 @@ H5S_hyper_rebuild (H5S_t *space)
         app_diminfo=space->select.sel_info.hslab->app_diminfo;
         while(span!=NULL) {
             /* Sanity check */
-            assert(curr_dim<space->extent.u.simple.rank);
+            assert(curr_dim<space->extent.rank);
 
             /* Recover the optimized dimension information */
             app_diminfo[curr_dim].start = diminfo[curr_dim].start = span->low;
@@ -5347,7 +5347,7 @@ H5S_hyper_generate_spans(H5S_t *space)
     assert(H5S_GET_SELECT_TYPE(space)==H5S_SEL_HYPERSLABS);
 
     /* Get the diminfo */
-    for(u=0; u<space->extent.u.simple.rank; u++) {
+    for(u=0; u<space->extent.rank; u++) {
         tmp_start[u]=space->select.sel_info.hslab->opt_diminfo[u].start;
         tmp_stride[u]=space->select.sel_info.hslab->opt_diminfo[u].stride;
         tmp_count[u]=space->select.sel_info.hslab->opt_diminfo[u].count;
@@ -5403,7 +5403,7 @@ H5S_generate_hyperslab (H5S_t *space, H5S_seloper_t op,
     assert(block);
     
     /* Generate span tree for new hyperslab information */
-    if((new_spans=H5S_hyper_make_spans(space->extent.u.simple.rank,start,stride,count,block))==NULL)
+    if((new_spans=H5S_hyper_make_spans(space->extent.rank,start,stride,count,block))==NULL)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't create hyperslab information");
 
     /* Generate list of blocks to add/remove based on selection operation */
@@ -5645,13 +5645,13 @@ H5S_select_hyperslab (H5S_t *space, H5S_seloper_t op,
     /*
      * Check for overlapping hyperslab blocks in new selection.
      */
-    for(u=0; u<space->extent.u.simple.rank; u++) {
+    for(u=0; u<space->extent.rank; u++) {
         if(count[u]>1 && stride[u]<block[u])
             HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hyperslab blocks overlap");
     } /* end for */
 
     /* Optimize hyperslab parameters to merge contiguous blocks, etc. */
-    for(u=0; u<space->extent.u.simple.rank; u++) {
+    for(u=0; u<space->extent.rank; u++) {
         /* contiguous hyperslabs have the block size equal to the stride */
         if(stride[u]==block[u]) {
             opt_count[u]=1;
@@ -5720,11 +5720,11 @@ H5S_select_hyperslab (H5S_t *space, H5S_seloper_t op,
                         hsize_t tmp_block[H5O_LAYOUT_NDIMS];    /* Temporary block information */
 
                         /* Fill in temporary information for the dimensions */
-                        for(u=0; u<space->extent.u.simple.rank; u++) {
+                        for(u=0; u<space->extent.rank; u++) {
                             tmp_start[u]=0;
                             tmp_stride[u]=1;
                             tmp_count[u]=1;
-                            tmp_block[u]=space->extent.u.simple.size[u];
+                            tmp_block[u]=space->extent.size[u];
                         } /* end for */
 
                         /* Convert to hyperslab selection */
@@ -5768,7 +5768,7 @@ H5S_select_hyperslab (H5S_t *space, H5S_seloper_t op,
 
         /* Save the diminfo */
         space->select.num_elem=1;
-        for(u=0; u<space->extent.u.simple.rank; u++) {
+        for(u=0; u<space->extent.rank; u++) {
             space->select.sel_info.hslab->app_diminfo[u].start = start[u];
             space->select.sel_info.hslab->app_diminfo[u].stride = stride[u];
             space->select.sel_info.hslab->app_diminfo[u].count = count[u];
@@ -5862,7 +5862,7 @@ H5Sselect_hyperslab(hid_t space_id, H5S_seloper_t op, const hssize_t start[],
         HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation");
     if(stride!=NULL) {
         /* Check for 0-sized strides */
-        for(u=0; u<space->extent.u.simple.rank; u++) {
+        for(u=0; u<space->extent.rank; u++) {
             if(stride[u]==0)
                 HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid stride==0 value");
         } /* end for */
@@ -5944,7 +5944,7 @@ H5S_hyper_get_seq_list_gen(const H5S_t *space,H5S_sel_iter_t *iter,
     assert(len);
 
     /* Set the rank of the fastest changing dimension */
-    ndims=space->extent.u.simple.rank;
+    ndims=space->extent.rank;
     fast_dim=(ndims-1);
 
     /* Get the pointers to the current span info and span nodes */
@@ -5962,7 +5962,7 @@ H5S_hyper_get_seq_list_gen(const H5S_t *space,H5S_sel_iter_t *iter,
     /* Compute the cumulative size of dataspace dimensions */
     for(i=fast_dim, acc=elem_size; i>=0; i--) {
         slab[i]=acc;
-        acc*=space->extent.u.simple.size[i];
+        acc*=space->extent.size[i];
     } /* end for */
 
     /* Set the offset of the first element iterated on */
@@ -6393,7 +6393,7 @@ H5S_hyper_get_seq_list_opt(const H5S_t *space,H5S_sel_iter_t *iter,
     tdiminfo=iter->u.hyp.diminfo;
 
     /* Check if this is a "flattened" regular hyperslab selection */
-    if(iter->u.hyp.iter_rank!=0 && iter->u.hyp.iter_rank<space->extent.u.simple.rank) {
+    if(iter->u.hyp.iter_rank!=0 && iter->u.hyp.iter_rank<space->extent.rank) {
         /* Set the aliases for a few important dimension ranks */
         ndims=iter->u.hyp.iter_rank;
         fast_dim=ndims-1;
@@ -6406,14 +6406,14 @@ H5S_hyper_get_seq_list_opt(const H5S_t *space,H5S_sel_iter_t *iter,
     } /* end if */
     else {
         /* Set the aliases for a few important dimension ranks */
-        ndims=space->extent.u.simple.rank;
+        ndims=space->extent.rank;
         fast_dim=ndims-1;
 
         /* Set the local copy of the selection offset */
         sel_off=space->select.offset;
 
         /* Set up the pointer to the size of the memory space */
-        mem_size=space->extent.u.simple.size;
+        mem_size=space->extent.size;
     } /* end else */
 
     /* initialize row sizes for each dimension */
diff --git a/src/H5Smpio.c b/src/H5Smpio.c
index 9f3d6ec..0316feb 100644
--- a/src/H5Smpio.c
+++ b/src/H5Smpio.c
@@ -249,7 +249,7 @@ H5S_mpio_hyper_type( const H5S_t *space, size_t elmt_size,
     /* make a local copy of the dimension info so we can operate with them */
 
     /* Check if this is a "flattened" regular hyperslab selection */
-    if(sel_iter.u.hyp.iter_rank!=0 && sel_iter.u.hyp.iter_rank<space->extent.u.simple.rank) {
+    if(sel_iter.u.hyp.iter_rank!=0 && sel_iter.u.hyp.iter_rank<space->extent.rank) {
         /* Flattened selection */
         rank=sel_iter.u.hyp.iter_rank;
         assert (rank >= 0 && rank<=H5S_MAX_RANK);	/* within array bounds */
@@ -283,7 +283,7 @@ H5S_mpio_hyper_type( const H5S_t *space, size_t elmt_size,
     } /* end if */
     else {
         /* Non-flattened selection */
-        rank = space->extent.u.simple.rank;
+        rank = space->extent.rank;
         assert (rank >= 0 && rank<=H5S_MAX_RANK);	/* within array bounds */
         if (0==rank)
             goto empty;
@@ -296,7 +296,7 @@ H5S_mpio_hyper_type( const H5S_t *space, size_t elmt_size,
             d[i].strid = diminfo[i].stride;
             d[i].block = diminfo[i].block;
             d[i].count = diminfo[i].count;
-            d[i].xtent = space->extent.u.simple.size[i];
+            d[i].xtent = space->extent.size[i];
 #ifdef H5Smpi_DEBUG
             HDfprintf(stderr, "%s: start=%Hd  stride=%Hu  count=%Hu  block=%Hu  xtent=%Hu",
                 FUNC, d[i].start, d[i].strid, d[i].count, d[i].block, d[i].xtent );
diff --git a/src/H5Spkg.h b/src/H5Spkg.h
index 72f9fd6..82bfec2 100644
--- a/src/H5Spkg.h
+++ b/src/H5Spkg.h
@@ -42,23 +42,14 @@
 /* 
  * Dataspace extent information
  */
-/* Simple extent container */
-typedef struct H5S_simple_t {
-    unsigned rank;         /* Number of dimensions */
-    hsize_t *size;      /* Current size of the dimensions */
-    hsize_t *max;       /* Maximum size of the dimensions */
-#ifdef LATER
-    hsize_t *perm;      /* Dimension permutation array */
-#endif /* LATER */
-} H5S_simple_t;
-
 /* Extent container */
 typedef struct {
     H5S_class_t	type;   /* Type of extent */
     hsize_t nelem;      /* Number of elements in extent */
-    union {
-        H5S_simple_t	simple;	/* Simple dimensionality information  */
-    } u;
+
+    unsigned rank;      /* Number of dimensions */
+    hsize_t *size;      /* Current size of the dimensions */
+    hsize_t *max;       /* Maximum size of the dimensions */
 } H5S_extent_t;
 
 /* 
@@ -227,7 +218,6 @@ H5_DLLVAR const H5S_select_class_t H5S_sel_none[1];
 H5_DLLVAR const H5S_select_class_t H5S_sel_point[1];
 
 /* Extent functions */
-H5_DLL herr_t H5S_close_simple(H5S_simple_t *simple);
 H5_DLL herr_t H5S_extent_release(H5S_extent_t *extent);
 H5_DLL herr_t H5S_extent_copy(H5S_extent_t *dst, const H5S_extent_t *src);
 
diff --git a/src/H5Spoint.c b/src/H5Spoint.c
index 9d0e0e2..2f0989b 100644
--- a/src/H5Spoint.c
+++ b/src/H5Spoint.c
@@ -407,11 +407,11 @@ H5S_point_add (H5S_t *space, H5S_seloper_t op, size_t num_elem, const hssize_t *
         if((new_node = H5FL_MALLOC(H5S_pnt_node_t))==NULL)
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate point node");
 
-        if((new_node->pnt = H5MM_malloc(space->extent.u.simple.rank*sizeof(hssize_t)))==NULL)
+        if((new_node->pnt = H5MM_malloc(space->extent.rank*sizeof(hssize_t)))==NULL)
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate coordinate information");
 
         /* Copy over the coordinates */
-        HDmemcpy(new_node->pnt,coord+(i*space->extent.u.simple.rank),(space->extent.u.simple.rank*sizeof(hssize_t)));
+        HDmemcpy(new_node->pnt,coord+(i*space->extent.rank),(space->extent.rank*sizeof(hssize_t)));
 
         /* Link into list */
         new_node->next=NULL;
@@ -612,9 +612,9 @@ H5S_point_copy(H5S_t *dst, const H5S_t *src, hbool_t UNUSED share_selection)
         /* Create each point */
         if((new_node=H5FL_MALLOC(H5S_pnt_node_t))==NULL)
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate point node");
-        if((new_node->pnt = H5MM_malloc(src->extent.u.simple.rank*sizeof(hssize_t)))==NULL)
+        if((new_node->pnt = H5MM_malloc(src->extent.rank*sizeof(hssize_t)))==NULL)
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate coordinate information");
-        HDmemcpy(new_node->pnt,curr->pnt,(src->extent.u.simple.rank*sizeof(hssize_t)));
+        HDmemcpy(new_node->pnt,curr->pnt,(src->extent.rank*sizeof(hssize_t)));
         new_node->next=NULL;
 
         /* Keep the order the same when copying */
@@ -668,10 +668,10 @@ H5S_point_is_valid (const H5S_t *space)
     curr=space->select.sel_info.pnt_lst->head;
     while(curr!=NULL) {
         /* Check each dimension */
-        for(u=0; u<space->extent.u.simple.rank; u++) {
+        for(u=0; u<space->extent.rank; u++) {
             /* Check if an offset has been defined */
             /* Bounds check the selected point + offset against the extent */
-            if(((curr->pnt[u]+space->select.offset[u])>(hssize_t)space->extent.u.simple.size[u])
+            if(((curr->pnt[u]+space->select.offset[u])>(hssize_t)space->extent.size[u])
                     || ((curr->pnt[u]+space->select.offset[u])<0)) {
                 ret_value=FALSE;
                 break;
@@ -764,7 +764,7 @@ H5S_point_serial_size (const H5S_t *space)
     curr=space->select.sel_info.pnt_lst->head;
     while(curr!=NULL) {
         /* Add 4 bytes times the rank for each element selected */
-        ret_value+=4*space->extent.u.simple.rank;
+        ret_value+=4*space->extent.rank;
         curr=curr->next;
     } /* end while */
 
@@ -813,7 +813,7 @@ H5S_point_serialize (const H5S_t *space, uint8_t *buf)
     buf+=4;             /* skip over space for length */
 
     /* Encode number of dimensions */
-    UINT32ENCODE(buf, (uint32_t)space->extent.u.simple.rank);
+    UINT32ENCODE(buf, (uint32_t)space->extent.rank);
     len+=4;
 
     /* Encode number of elements */
@@ -824,10 +824,10 @@ H5S_point_serialize (const H5S_t *space, uint8_t *buf)
     curr=space->select.sel_info.pnt_lst->head;
     while(curr!=NULL) {
         /* Add 4 bytes times the rank for each element selected */
-        len+=4*space->extent.u.simple.rank;
+        len+=4*space->extent.rank;
 
         /* Encode each point */
-        for(u=0; u<space->extent.u.simple.rank; u++)
+        for(u=0; u<space->extent.rank; u++)
             UINT32ENCODE(buf, (uint32_t)curr->pnt[u]);
 
         curr=curr->next;
@@ -879,7 +879,7 @@ H5S_point_deserialize (H5S_t *space, const uint8_t *buf)
     /* Deserialize points to select */
     buf+=16;    /* Skip over selection header */
     UINT32DECODE(buf,rank);  /* decode the rank of the point selection */
-    if(rank!=space->extent.u.simple.rank)
+    if(rank!=space->extent.rank)
         HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "rank of pointer does not match dataspace");
     UINT32DECODE(buf,num_elem);  /* decode the number of points */
 
@@ -946,7 +946,7 @@ H5S_get_select_elem_pointlist(H5S_t *space, hsize_t startpoint, hsize_t numpoint
     assert(buf);
 
     /* Get the dataspace extent rank */
-    rank=space->extent.u.simple.rank;
+    rank=space->extent.rank;
 
     /* Get the head of the point list */
     node=space->select.sel_info.pnt_lst->head;
@@ -1063,7 +1063,7 @@ H5S_point_bounds(const H5S_t *space, hssize_t *start, hssize_t *end)
     assert(end);
 
     /* Get the dataspace extent rank */
-    rank=space->extent.u.simple.rank;
+    rank=space->extent.rank;
 
     /* Set the start and end arrays up */
     for(i=0; i<rank; i++) {
diff --git a/src/H5Sprivate.h b/src/H5Sprivate.h
index 9e6d4b4..5dbb467 100644
--- a/src/H5Sprivate.h
+++ b/src/H5Sprivate.h
@@ -155,7 +155,7 @@ typedef struct H5S_conv_t {
 /* If the module using this macro is allowed access to the private variables, access them directly */
 #ifdef H5S_PACKAGE
 #define H5S_GET_EXTENT_TYPE(S)          ((S)->extent.type)
-#define H5S_GET_EXTENT_NDIMS(S)         ((S)->extent.u.simple.rank)
+#define H5S_GET_EXTENT_NDIMS(S)         ((S)->extent.rank)
 #define H5S_GET_EXTENT_NPOINTS(S)       ((S)->extent.nelem)
 #define H5S_GET_SELECT_NPOINTS(S)       ((S)->select.num_elem)
 #define H5S_GET_SELECT_TYPE(S)          ((S)->select.type->type)
diff --git a/src/H5Sselect.c b/src/H5Sselect.c
index 824d79a..ca6bb7d 100644
--- a/src/H5Sselect.c
+++ b/src/H5Sselect.c
@@ -82,11 +82,11 @@ H5S_select_offset(H5S_t *space, const hssize_t *offset)
 
     /* Check args */
     assert(space);
-    assert(space->extent.u.simple.rank);
+    assert(space->extent.rank);
     assert(offset);
 
     /* Copy the offset over */
-    HDmemcpy(space->select.offset,offset,sizeof(hssize_t)*space->extent.u.simple.rank);
+    HDmemcpy(space->select.offset,offset,sizeof(hssize_t)*space->extent.rank);
 
 done:
     FUNC_LEAVE_NOAPI(ret_value);
@@ -559,7 +559,7 @@ H5Sget_select_bounds(hid_t spaceid, hsize_t *start, hsize_t *end)
 
     if(ret_value>=0) {
         /* Copy over the start & end values */
-        for(u=0; u<space->extent.u.simple.rank; u++) {
+        for(u=0; u<space->extent.rank; u++) {
             H5_ASSIGN_OVERFLOW(start[u],tstart[u],hssize_t,hsize_t);
             H5_ASSIGN_OVERFLOW(end[u],tend[u],hssize_t,hsize_t);
         } /* end for */
@@ -783,11 +783,11 @@ H5S_select_iter_init(H5S_sel_iter_t *sel_iter, const H5S_t *space, size_t elmt_s
     /* Initialize common information */
 
     /* Save the dataspace's rank */
-    sel_iter->rank=space->extent.u.simple.rank;
+    sel_iter->rank=space->extent.rank;
 
     if(sel_iter->rank>0) {
         /* Point to the dataspace dimensions */
-        sel_iter->dims=space->extent.u.simple.size;
+        sel_iter->dims=space->extent.size;
     } /* end if */
     else
         sel_iter->dims = NULL;
@@ -1162,12 +1162,12 @@ H5S_select_iterate(void *buf, hid_t type_id, const H5S_t *space, H5D_operator_t
         HGOTO_ERROR (H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't get number of elements selected");
 
     /* Get the rank of the dataspace */
-    ndims=space->extent.u.simple.rank;
+    ndims=space->extent.rank;
 
     if (ndims > 0){
 	/* Copy the size of the space */
-	assert(space->extent.u.simple.size);
-	HDmemcpy(space_size, space->extent.u.simple.size, ndims*sizeof(hsize_t));
+	assert(space->extent.size);
+	HDmemcpy(space_size, space->extent.size, ndims*sizeof(hsize_t));
     }
     space_size[ndims]=elmt_size;
 
@@ -1342,7 +1342,7 @@ HDfprintf(stderr,"%s: Entering\n",FUNC);
     assert(space2);
 
     /* Check for different dimensionality */
-    if (space1->extent.u.simple.rank!=space2->extent.u.simple.rank)
+    if (space1->extent.rank!=space2->extent.rank)
         HGOTO_DONE(FALSE);
 
     /* Check for different number of elements selected */
@@ -1360,7 +1360,7 @@ HDfprintf(stderr,"%s: Entering\n",FUNC);
             HGOTO_ERROR (H5E_DATASPACE, H5E_CANTGET, FAIL, "unable to get dimensionality");
 
         /* Check that the sizes are the same */
-        for (u=0; u<space1->extent.u.simple.rank; u++)
+        for (u=0; u<space1->extent.rank; u++)
             if(dims1[u]!=dims2[u])
                 HGOTO_DONE(FALSE);
     } /* end if */
@@ -1371,7 +1371,7 @@ HDfprintf(stderr,"%s: Entering\n",FUNC);
             && (H5S_GET_SELECT_TYPE(space2)==H5S_SEL_HYPERSLABS && space2->select.sel_info.hslab->diminfo_valid)) {
 
         /* Check that the shapes are the same */
-        for (u=0; u<space1->extent.u.simple.rank; u++) {
+        for (u=0; u<space1->extent.rank; u++) {
             if(space1->select.sel_info.hslab->opt_diminfo[u].stride!=space2->select.sel_info.hslab->opt_diminfo[u].stride)
                 HGOTO_DONE(FALSE);
             if(space1->select.sel_info.hslab->opt_diminfo[u].count!=space2->select.sel_info.hslab->opt_diminfo[u].count)
@@ -1432,11 +1432,11 @@ else {
 #ifdef QAK
 {
     HDfprintf(stderr,"%s: iter1 start={",FUNC);
-    for(u=0; u<space1->extent.u.simple.rank; u++)
-        HDfprintf(stderr,"%Hd%s",start1[u],(u<(space1->extent.u.simple.rank-1) ? ", " : "}\n"));
+    for(u=0; u<space1->extent.rank; u++)
+        HDfprintf(stderr,"%Hd%s",start1[u],(u<(space1->extent.rank-1) ? ", " : "}\n"));
     HDfprintf(stderr,"%s: iter1 end={",FUNC);
-    for(u=0; u<space1->extent.u.simple.rank; u++)
-        HDfprintf(stderr,"%Hd%s",end1[u],(u<(space1->extent.u.simple.rank-1) ? ", " : "}\n"));
+    for(u=0; u<space1->extent.rank; u++)
+        HDfprintf(stderr,"%Hd%s",end1[u],(u<(space1->extent.rank-1) ? ", " : "}\n"));
 }
 #endif /* QAK */
             if(H5S_SELECT_ITER_BLOCK(&iter2,start2,end2)<0)
@@ -1444,18 +1444,18 @@ else {
 #ifdef QAK
 {
     HDfprintf(stderr,"%s: iter2 start={",FUNC);
-    for(u=0; u<space1->extent.u.simple.rank; u++)
-        HDfprintf(stderr,"%Hd%s",start2[u],(u<(space1->extent.u.simple.rank-1) ? ", " : "}\n"));
+    for(u=0; u<space1->extent.rank; u++)
+        HDfprintf(stderr,"%Hd%s",start2[u],(u<(space1->extent.rank-1) ? ", " : "}\n"));
     HDfprintf(stderr,"%s: iter2 end={",FUNC);
-    for(u=0; u<space1->extent.u.simple.rank; u++)
-        HDfprintf(stderr,"%Hd%s",end2[u],(u<(space1->extent.u.simple.rank-1) ? ", " : "}\n"));
+    for(u=0; u<space1->extent.rank; u++)
+        HDfprintf(stderr,"%Hd%s",end2[u],(u<(space1->extent.rank-1) ? ", " : "}\n"));
 }
 #endif /* QAK */
 
             /* The first block only compares the sizes and sets the relative offsets for later blocks */
             if(first_block) {
                 /* If the block sizes from each selection doesn't match, get out */
-                for (u=0; u<space1->extent.u.simple.rank; u++) {
+                for (u=0; u<space1->extent.rank; u++) {
                     if((end1[u]-start1[u])!=(end2[u]-start2[u]))
                         HGOTO_DONE(FALSE);
 
@@ -1469,7 +1469,7 @@ else {
             } /* end if */
             else {
                 /* Check over the blocks for each selection */
-                for (u=0; u<space1->extent.u.simple.rank; u++) {
+                for (u=0; u<space1->extent.rank; u++) {
                     /* Check if the blocks are in the same relative location */
                     if((start1[u]-off1[u])!=(start2[u]-off2[u]))
                         HGOTO_DONE(FALSE);