Revert "Merge pull request #1116 in HDFFV/hdf5 from ~HDFTEST/hdf5_hft:hdf5_1_10 to develop"

This reverts commit e9f476dad47ce593f13dacb77b1cc664d1f24e7b, reversing
changes made to 2ff00b1b937ebe36ac6ddf590c16a4c27fc0b053.

1 files changed, 96 insertions, 275 deletions

diff --git a/src/H5Shyper.c b/src/H5Shyper.c
index f2050b6..47eb573 100644
--- a/src/H5Shyper.c
+++ b/src/H5Shyper.c
@@ -28,12 +28,7 @@
 #include "H5Spkg.h"		/* Dataspace functions			*/
 #include "H5VMprivate.h"         /* Vector functions			*/
 
-/* Format version bounds for dataspace hyperslab selection */
-const unsigned H5O_sds_hyper_ver_bounds[] = {
-    H5S_HYPER_VERSION_1,    /* H5F_LIBVER_EARLIEST */
-    H5S_HYPER_VERSION_1,    /* H5F_LIBVER_V18 */
-    H5S_HYPER_VERSION_2     /* H5F_LIBVER_LATEST */
-};
+/* Local Macros */
 
 /* Local datatypes */
 
@@ -85,8 +80,8 @@ static herr_t H5S__hyper_get_seq_list(const H5S_t *space, unsigned flags,
     size_t *nseq, size_t *nbytes, hsize_t *off, size_t *len);
 static herr_t H5S__hyper_release(H5S_t *space);
 static htri_t H5S__hyper_is_valid(const H5S_t *space);
-static hssize_t H5S__hyper_serial_size(const H5S_t *space, H5F_t *f);
-static herr_t H5S__hyper_serialize(const H5S_t *space, uint8_t **p, H5F_t *f);
+static hssize_t H5S__hyper_serial_size(const H5S_t *space);
+static herr_t H5S__hyper_serialize(const H5S_t *space, uint8_t **p);
 static herr_t H5S__hyper_deserialize(H5S_t *space, uint32_t version, uint8_t flags,
     const uint8_t **p);
 static herr_t H5S__hyper_bounds(const H5S_t *space, hsize_t *start, hsize_t *end);
@@ -107,9 +102,10 @@ static herr_t H5S__hyper_iter_coords(const H5S_sel_iter_t *iter, hsize_t *coords
 static herr_t H5S__hyper_iter_block(const H5S_sel_iter_t *iter, hsize_t *start, hsize_t *end);
 static hsize_t H5S__hyper_iter_nelmts(const H5S_sel_iter_t *iter);
 static htri_t H5S__hyper_iter_has_next_block(const H5S_sel_iter_t *sel_iter);
-static herr_t H5S__hyper_iter_next(H5S_sel_iter_t *sel_iter, hsize_t nelem);
+static herr_t H5S__hyper_iter_next(H5S_sel_iter_t *sel_iter, size_t nelem);
 static herr_t H5S__hyper_iter_next_block(H5S_sel_iter_t *sel_iter);
 static herr_t H5S__hyper_iter_release(H5S_sel_iter_t *sel_iter);
+
 /* Static function for optimizing hyperslab */
 static hbool_t H5S__hyper_rebuild_helper(const H5S_hyper_span_t *span,
     H5S_hyper_dim_t span_slab_info[], unsigned rank);
@@ -688,7 +684,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5S__hyper_iter_next(H5S_sel_iter_t *iter, hsize_t nelem)
+H5S__hyper_iter_next(H5S_sel_iter_t *iter, size_t nelem)
 {
     unsigned ndims;     /* Number of dimensions of dataset */
     int fast_dim;       /* Rank of the fastest changing dimension for the dataspace */
@@ -735,17 +731,17 @@ H5S__hyper_iter_next(H5S_sel_iter_t *iter, hsize_t nelem)
         /* Loop through, advancing the offset & counts, until all the nelements are accounted for */
         while(nelem > 0) {
             /* Start with the fastest changing dimension */
-            temp_dim=fast_dim;
-            while(temp_dim>=0) {
-                if(temp_dim==fast_dim) {
-                    hsize_t actual_elem;    /* Actual # of elements advanced on each iteration through loop */
+            temp_dim = fast_dim;
+            while(temp_dim >= 0) {
+                if(temp_dim == fast_dim) {
+                    size_t actual_elem;     /* Actual # of elements advanced on each iteration through loop */
                     hsize_t block_elem;     /* Number of elements left in a block */
 
                     /* Compute the number of elements left in block */
                     block_elem = tdiminfo[temp_dim].block - iter_offset[temp_dim];
 
                     /* Compute the number of actual elements to advance */
-                    actual_elem=MIN(nelem,block_elem);
+                    actual_elem = (size_t)MIN(nelem, block_elem);
 
                     /* Move the iterator over as many elements as possible */
                     iter_offset[temp_dim] += actual_elem;
@@ -808,8 +804,8 @@ H5S__hyper_iter_next(H5S_sel_iter_t *iter, hsize_t nelem)
                 curr_span = ispan[curr_dim];
 
                 /* Increment absolute position */
-                if(curr_dim==fast_dim) {
-                    hsize_t actual_elem;    /* Actual # of elements advanced on each iteration through loop */
+                if(curr_dim == fast_dim) {
+                    size_t actual_elem;     /* Actual # of elements advanced on each iteration through loop */
                     hsize_t span_elem;      /* Number of elements left in a span */
 
                     /* Compute the number of elements left in block */
@@ -1951,140 +1947,13 @@ done:
 
 /*--------------------------------------------------------------------------
  NAME
-    H5S_hyper_set_offset_size
- PURPOSE
-    Determine the offset size (4 or 8 bytes) to use for encoding hyperslab selection info
- USAGE
-    hssize_t H5S_hyper_set_offset_size(space, block_count, bounds_end, version, offset_size)
-        const H5S_t *space:             IN: The maximum size of the hyperslab selection info
-        hsize_t block_count:            IN: The number of blocks in the selection
-        hsize_t bounds_end:             IN: The selection high bounds
-        uint32_t version:               IN: The version used for encoding
-        uint8_t *offset_size:           OUT: The offset size
-
- RETURNS
-    The offset size
- DESCRIPTION
-    Determine the offset size for encoding hyperslab selection info based on the
-    the input parameter "version".  This is for release 1.10.
- GLOBAL VARIABLES
- COMMENTS, BUGS, ASSUMPTIONS
- EXAMPLES
- REVISION LOG
---------------------------------------------------------------------------*/
-static herr_t
-H5S_hyper_set_offset_size(const H5S_t *space, hsize_t block_count, hsize_t bounds_end[], uint32_t version, uint8_t *offset_size)
-{
-    herr_t ret_value = SUCCEED;
-
-    FUNC_ENTER_NOAPI_NOINIT
-
-    switch(version) {
-        case H5S_HYPER_VERSION_1:
-            *offset_size = H5S_INFO_SIZE_4;
-            break;
-
-        case H5S_HYPER_VERSION_2:
-            *offset_size = H5S_INFO_SIZE_8;
-            break;
-
-        default:
-            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't determine hyper offset size")
-            break;
-    }
-
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* H5S_hyper_set_offset_size() */
-
-
-/*--------------------------------------------------------------------------
- NAME
-    H5S_hyper_set_version
- PURPOSE
-    Determine the version to use for encoding hyperslab selection info
-    See tables 2 & 3 in the RFC: H5Sencode/H5Sdecode Format Change
- USAGE
-    hssize_t H5S_hyper_set_version(space, block_count, bounds_end, f, version)
-        const H5S_t *space:             IN: The dataspace
-        hsize_t block_count:            IN: The number of blocks in the selection
-        hsize_t bounds_end:             IN: The selection high bounds
-        H5F_t *f:                       IN: The file pointer
-        uint32_t *version:              OUT: The version to use for encoding
-
- RETURNS
-    The version to use
- DESCRIPTION
-    Determine the version to use for encoding hyperslab selection info based
-    on whether the number of blocks or the selection high bounds exceeds (2^32 - 1).
- GLOBAL VARIABLES
- COMMENTS, BUGS, ASSUMPTIONS
- EXAMPLES
- REVISION LOG
---------------------------------------------------------------------------*/
-static herr_t
-H5S_hyper_set_version(const H5S_t *space, hsize_t block_count, hsize_t bounds_end[], H5F_t *f, uint32_t *version)
-{
-    hbool_t count_up_version = FALSE;   /* Whether number of blocks exceed (2^32 - 1) */
-    hbool_t bound_up_version = FALSE;   /* Whether high bounds exceed (2^32 - 1) */
-    unsigned u;                         /* Local index veriable */
-    uint32_t tmp_version;               /* Temporay version */
-    herr_t ret_value = SUCCEED;         /* return value */
-
-    FUNC_ENTER_NOAPI_NOINIT
-
-    /* Determine whether the number of blocks or the high bounds in the selection exceed (2^32 - 1) */
-    if(block_count > H5S_UINT32_MAX)
-        count_up_version = TRUE;
-    else {
-        for(u = 0; u < space->extent.rank; u++)
-            if(bounds_end[u] > H5S_UINT32_MAX)
-                bound_up_version = TRUE;
-    }
-
-    /* Use version 2 for unlimited selection */
-    if(space->select.sel_info.hslab->unlim_dim >= 0)
-       tmp_version = H5S_HYPER_VERSION_2;
-    else if(H5S__hyper_is_regular(space)) {
-
-        /* If exceed (2^32 -1) */
-        if(count_up_version || bound_up_version)
-            tmp_version = H5S_HYPER_VERSION_2;
-        else 
-            /* block_count < 4: version 1 */
-            /* block_count >= 4: determined by low bound */
-            tmp_version = (block_count < 4) ? H5S_HYPER_VERSION_1 : H5O_sds_hyper_ver_bounds[H5F_LOW_BOUND(f)];
-
-    } else { 
-        /* Fail for irregular hyperslab if exceeds 32 bits */
-        if(count_up_version)
-            HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "The number of blocks in hyperslab selection exceeds 2^32")
-        else if(bound_up_version)
-            HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "The end of bounding box in hyperslab selection exceeds 2^32")
-        tmp_version = H5S_HYPER_VERSION_1;
-    }
-
-    /* Version bounds check */
-    if(tmp_version > H5O_sds_hyper_ver_bounds[H5F_HIGH_BOUND(f)])
-        HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "Dataspace hyperslab selection version out of bounds")
-    
-    *version = tmp_version;
-
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* H5S_hyper_set_version() */
-
-
-/*--------------------------------------------------------------------------
- NAME
     H5S__hyper_serial_size
  PURPOSE
     Determine the number of bytes needed to store the serialized hyperslab
         selection information.
  USAGE
-    hssize_t H5S_hyper_serial_size(space, H5F_t *f)
+    hssize_t H5S__hyper_serial_size(space)
         H5S_t *space;             IN: Dataspace pointer to query
-        H5F_t *f;                 IN: File pointer
  RETURNS
     The number of bytes required on success, negative on an error.
  DESCRIPTION
@@ -2096,72 +1965,51 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static hssize_t
-H5S__hyper_serial_size(const H5S_t *space, H5F_t *f)
+H5S__hyper_serial_size(const H5S_t *space)
 {
-    hsize_t block_count = 0;    /* block counter for regular hyperslabs */
-    hsize_t bounds_start[H5S_MAX_RANK]; /* Selection bounds */
-    hsize_t bounds_end[H5S_MAX_RANK];   /* Selection bounds */
-    uint32_t version;           /* Version number */
-    uint8_t offset_size;        /* Offset size */
-    unsigned u;                 /* Local index variable */
-    hssize_t ret_value = -1;    /* return value */
+    hsize_t block_count;       /* block counter for regular hyperslabs */
+    unsigned u;                /* Counter */
+    hssize_t ret_value = -1;   /* return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC_NOERR
 
     HDassert(space);
 
-    /* Get bounding box for the selection */
-    HDmemset(bounds_end, 0, sizeof(bounds_end));
-    if(space->select.sel_info.hslab->unlim_dim < 0) { /* ! H5S_UNLIMITED */
-        /* Determine the number of blocks */
-        if(H5S__hyper_is_regular(space)) {
-            /* Check each dimension */
-            for(block_count = 1, u = 0; u < space->extent.rank; u++)
-                block_count *= space->select.sel_info.hslab->opt_diminfo[u].count;
-        } /* 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);
-
-        /* Get bounding box for the selection */
-        if(H5S__hyper_bounds(space, bounds_start, bounds_end) < 0)
-            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't get selection bounds")
-    }
-
-    /* Determine the version */
-    if(H5S_hyper_set_version(space, block_count, bounds_end, f, &version) < 0)
-        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't determine hyper version")
-
-    /* Determine the offset size */
-    if(H5S_hyper_set_offset_size(space, block_count, bounds_end, version, &offset_size) < 0)
-        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't determine hyper version")
-
-    if(version == H5S_HYPER_VERSION_2) {
+    /* Check for version (right now, an unlimited dimension is the only thing
+     * that would bump the version) */
+    if(space->select.sel_info.hslab->unlim_dim >= 0)
         /* Version 2 */
         /* Size required is always:
          * <type (4 bytes)> + <version (4 bytes)> + <flags (1 byte)> +
          * <length (4 bytes)> + <rank (4 bytes)> +
-         * (4 (start/stride/count/block) * <offset_size (8 bytes)> * <rank>) =
-         * 17 + (4 * 8 * rank) bytes
+         * (4 (start/stride/count/block) * <rank> * <value (8 bytes)>) =
+         * 17 + (4 * rank * 8) bytes
          */
-        HDassert(offset_size == 8);
-        ret_value = (hssize_t)17 + ((hssize_t)4 * (hssize_t)8 * (hssize_t)space->extent.rank);
-    } else {
-        HDassert(version == H5S_HYPER_VERSION_1);
-        HDassert(offset_size == 4);
+        ret_value = (hssize_t)17 + ((hssize_t)4 * (hssize_t)space->extent.rank
+                * (hssize_t)8);
+    else {
         /* Version 1 */
         /* Basic number of bytes required to serialize hyperslab selection:
          * <type (4 bytes)> + <version (4 bytes)> + <padding (4 bytes)> +
-         * <length (4 bytes)> + <rank (4 bytes)> + <# of blocks (4 bytes)> +
-         * (2 (starting/ending offset) * <offset_size (4 bytes)> * <rank> * <# of blocks) =
-         * = 24 bytes + (2 * 4 * rank * block_count)
+         * <length (4 bytes)> + <rank (4 bytes)> + <# of blocks (4 bytes)>
+         * = 24 bytes
          */
         ret_value = 24;
+
+        /* 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.rank; u++)
+                block_count *= space->select.sel_info.hslab->opt_diminfo[u].count;
+        } /* 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);
+
         H5_CHECK_OVERFLOW((8 * space->extent.rank * block_count), hsize_t, hssize_t);
-        ret_value += (hssize_t)(8 * space->extent.rank * block_count);
+        ret_value += (hssize_t)(8 * block_count * space->extent.rank);
     } /* end else */
 
-done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S__hyper_serial_size() */
 
@@ -2253,12 +2101,11 @@ H5S__hyper_serialize_helper(const H5S_hyper_span_info_t *spans,
  PURPOSE
     Serialize the current selection into a user-provided buffer.
  USAGE
-    herr_t H5S__hyper_serialize(space, p)
+    herr_t H5S_hyper_serialize(space, p)
         const H5S_t *space;     IN: Dataspace with selection to serialize
         uint8_t **p;            OUT: Pointer to buffer to put serialized
                                 selection.  Will be advanced to end of
                                 serialized selection.
-        H5F_t *f;               IN: File pointer
  RETURNS
     Non-negative on success/Negative on failure
  DESCRIPTION
@@ -2270,30 +2117,16 @@ H5S__hyper_serialize_helper(const H5S_hyper_span_info_t *spans,
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S__hyper_serialize(const H5S_t *space, uint8_t **p, H5F_t *f)
+H5S__hyper_serialize(const H5S_t *space, uint8_t **p)
 {
-    const H5S_hyper_dim_t *diminfo;         /* Alias for dataspace's diminfo information */
-    uint8_t *pp = (*p);                     /* Local pointer for decoding */
-    hsize_t tmp_count[H5O_LAYOUT_NDIMS];    /* Temporary hyperslab counts */
-    hsize_t offset[H5O_LAYOUT_NDIMS];       /* Offset of element in dataspace */
-    hsize_t start[H5O_LAYOUT_NDIMS];   /* Location of start of hyperslab */
-    hsize_t end[H5O_LAYOUT_NDIMS];     /* Location of end of hyperslab */
-    hsize_t temp_off; /* Offset in a given dimension */
-    uint8_t *lenp;          /* pointer to length location for later storage */
-    uint32_t len = 0;       /* number of bytes used */
+    uint8_t *pp;            /* Local pointer for decoding */
+    uint8_t *lenp;          /* Pointer to length location for later storage */
+    uint32_t len = 0;       /* Number of bytes used */
     uint32_t version;       /* Version number */
     uint8_t flags = 0;      /* Flags for message */
-    hsize_t block_count;    /* block counter for regular hyperslabs */
-    unsigned fast_dim;      /* Rank of the fastest changing dimension for the dataspace */
-    unsigned ndims;         /* Rank of the dataspace */
-    unsigned u;             /* Local counting variable */
-    int done;               /* Whether we are done with the iteration */
-    uint8_t offset_size;
-    hsize_t bounds_start[H5S_MAX_RANK];
-    hsize_t bounds_end[H5S_MAX_RANK];
-    herr_t ret_value = SUCCEED; /* return value */
+    hsize_t block_count;    /* Block counter for regular hyperslabs */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_STATIC_NOERR
 
     /* Sanity checks */
     HDassert(space);
@@ -2301,76 +2134,62 @@ H5S__hyper_serialize(const H5S_t *space, uint8_t **p, H5F_t *f)
     pp = (*p);
     HDassert(pp);
 
-    /* Set some convienence values */
-    ndims = space->extent.rank;
-    diminfo = space->select.sel_info.hslab->opt_diminfo;
-
-    if(space->select.sel_info.hslab->unlim_dim < 0) { /* ! H5S_UNLIMITED */
-        /* Calculate the # of blocks */
-        if(H5S__hyper_is_regular(space)) {
-            /* Check each dimension */
-            for(block_count = 1, u = 0; u < ndims; u++)
-                block_count *= diminfo[u].count;
-        } /* 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);
-
-        /* Get bounding box */
-        if(H5S__hyper_bounds(space, bounds_start, bounds_end) < 0)
-            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't get selection bounds")
-    }
-
-    /* Determine the version to use */
-    if(H5S_hyper_set_version(space, block_count, bounds_end, f, &version) < 0)
-        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't determine hyper version")
-
-    /* Determine the size of offset info */
-    if(H5S_hyper_set_offset_size(space, block_count, bounds_end, version, &offset_size) < 0)
-        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't determine hyper version")
-
-    if(H5S__hyper_is_regular(space) && version == H5S_HYPER_VERSION_2)
-        flags |= H5S_HYPER_REGULAR;
+    /* Calculate version */
+    if(space->select.sel_info.hslab->unlim_dim >= 0) {
+        version = 2;
+        flags |= H5S_SELECT_FLAG_UNLIM;
+    } /* end if */
+    else
+        version = 1;
 
     /* Store the preamble information */
     UINT32ENCODE(pp, (uint32_t)H5S_GET_SELECT_TYPE(space)); /* Store the type of selection */
     UINT32ENCODE(pp, version); /* Store the version number */
-
-    if(version == 2)
-        *(pp)++ = flags;    /* Store the flags */
+    if(version >= 2)
+        *(pp)++ = flags; /* Store the flags */
     else
         UINT32ENCODE(pp, (uint32_t)0); /* Store the un-used padding */
-    lenp = pp;              /* keep the pointer to the length location for later */
-    pp += 4;                /* skip over space for length */
-
-    len += 4;               /* ndims */
+    lenp = pp;           /* keep the pointer to the length location for later */
+    pp += 4;             /* skip over space for length */
 
     /* Encode number of dimensions */
-    UINT32ENCODE(pp, (uint32_t)ndims);
+    UINT32ENCODE(pp, (uint32_t)space->extent.rank);
+    len += 4;
 
-    /* If flags indicates a regular hyperslab or unlimited dimension, encode opt_diminfo */
-    if(flags & H5S_HYPER_REGULAR) {
+    /* If there is an unlimited dimension, only encode opt_unlim_diminfo */
+    if(flags & H5S_SELECT_FLAG_UNLIM) {
         unsigned i;
 
         HDassert(H5S_UNLIMITED == HSIZE_UNDEF);
-        HDassert(version == H5S_HYPER_VERSION_2);
 
         /* Iterate over dimensions */
-        /* Encode start/stride/block/count */
         for(i = 0; i < space->extent.rank; i++) {
-            UINT64ENCODE(pp, diminfo[i].start);
-            UINT64ENCODE(pp, diminfo[i].stride);
-            UINT64ENCODE(pp, diminfo[i].count);
-            UINT64ENCODE(pp, diminfo[i].block);
+            /* Encode start/stride/block/count */
+            UINT64ENCODE(pp, space->select.sel_info.hslab->opt_diminfo[i].start);
+            UINT64ENCODE(pp, space->select.sel_info.hslab->opt_diminfo[i].stride);
+            UINT64ENCODE(pp, space->select.sel_info.hslab->opt_diminfo[i].count);
+            UINT64ENCODE(pp, space->select.sel_info.hslab->opt_diminfo[i].block);
         } /* end for */
-        len += (4 * space->extent.rank * 8);
     } /* end if */
     /* Check for a "regular" hyperslab selection */
-    else if(H5S__hyper_is_regular(space)) {
-        HDassert(version == H5S_HYPER_VERSION_1);
+    else if(space->select.sel_info.hslab->diminfo_valid) {
+        const H5S_hyper_dim_t *diminfo;         /* Alias for dataspace's diminfo information */
+        hsize_t offset[H5O_LAYOUT_NDIMS];       /* Offset of element in dataspace */
+        hsize_t tmp_count[H5O_LAYOUT_NDIMS];    /* Temporary hyperslab counts */
+        unsigned fast_dim;      /* Rank of the fastest changing dimension for the dataspace */
+        unsigned ndims;         /* Rank of the dataspace */
+        unsigned u;             /* Local counting variable */
+        hbool_t done;           /* Whether we are done with the iteration */
 
-        /* Set some convienence values */
+        /* Set some convenience values */
+        ndims = space->extent.rank;
         fast_dim = ndims - 1;
+        diminfo = space->select.sel_info.hslab->opt_diminfo;
+
+        /* Check each dimension */
+        for(block_count = 1, u = 0; u < ndims; u++)
+            block_count *= diminfo[u].count;
+
         /* Encode number of hyperslabs */
         H5_CHECK_OVERFLOW(block_count, hsize_t, uint32_t);
         UINT32ENCODE(pp, (uint32_t)block_count);
@@ -2446,16 +2265,18 @@ H5S__hyper_serialize(const H5S_t *space, uint8_t **p, H5F_t *f)
         } /* end while */
     } /* end if */
     else {
-        HDassert(version == H5S_HYPER_VERSION_1);
+        hsize_t start[H5O_LAYOUT_NDIMS];   /* Location of start of hyperslab */
+        hsize_t end[H5O_LAYOUT_NDIMS];     /* Location of end of hyperslab */
+
         /* Encode number of hyperslabs */
+        block_count = H5S__hyper_span_nblocks(space->select.sel_info.hslab->span_lst);
         H5_CHECK_OVERFLOW(block_count, hsize_t, uint32_t);
         UINT32ENCODE(pp, (uint32_t)block_count);
-
-        len+=4; /* block_count */
+        len += 4;
 
         /* Add 8 bytes times the rank for each hyperslab selected */
-        H5_CHECK_OVERFLOW((8 * ndims * block_count), hsize_t, size_t);
-        len += (uint32_t)(8 * ndims * block_count);
+        H5_CHECK_OVERFLOW((8 * space->extent.rank * block_count), hsize_t, size_t);
+        len += (uint32_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, &pp);
@@ -2467,9 +2288,8 @@ H5S__hyper_serialize(const H5S_t *space, uint8_t **p, H5F_t *f)
     /* Update encoding pointer */
     *p = pp;
 
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-}   /* H5S_hyper_serialize() */
+    FUNC_LEAVE_NOAPI(SUCCEED)
+} /* end H5S__hyper_serialize() */
 
 
 /*--------------------------------------------------------------------------
@@ -2519,7 +2339,8 @@ H5S__hyper_deserialize(H5S_t *space, uint32_t H5_ATTR_UNUSED version, uint8_t fl
     /* (The header and rank have already beed decoded) */
     rank = space->extent.rank;  /* Retrieve rank from space */
 
-    if(flags & H5S_HYPER_REGULAR) {
+    /* If there is an unlimited dimension, only encode opt_unlim_diminfo */
+    if(flags & H5S_SELECT_FLAG_UNLIM) {
         hsize_t stride[H5O_LAYOUT_NDIMS];	/* Hyperslab stride information */
         hsize_t count[H5O_LAYOUT_NDIMS];	/* Hyperslab count information */
 
@@ -7652,7 +7473,7 @@ H5S_select_hyperslab (H5S_t *space, H5S_seloper_t op,
                 HGOTO_ERROR(H5E_DATASPACE, H5E_UNSUPPORTED, FAIL, "unsupported operation with unlimited selection")
 
             /* Get bounds of existing selection */
-            if(H5S__hyper_bounds(space, bounds_start, bounds_end) < 0)
+            if(H5S_hyper_bounds(space, bounds_start, bounds_end) < 0)
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't get selection bounds")
 
             /* Patch count and block to remove unlimited and include the