[svn-r25766] Description:

    Revert r25273, 25283 & 25439 (the hyperslab improvement changes).  They
are buggy and it's taking me a long time to correct the problem.  I'll check
in a revised form of the changes when I've got them straightened out.

Tested on:
    Mac OSX 10.10.0 (amazon) w/gcc 4.9.x, C++, FORTRAN
    Linux 2.6.x (jam) w/parallel

1 files changed, 1761 insertions, 2235 deletions

diff --git a/src/H5Shyper.c b/src/H5Shyper.c
index 889291f..c97c9b6 100644
--- a/src/H5Shyper.c
+++ b/src/H5Shyper.c
@@ -17,7 +17,7 @@
  * Programmer:  Quincey Koziol <koziol@ncsa.uiuc.edu>
  *              Thursday, June 18, 1998
  *
- * Purpose:	Hyperslab selection dataspace I/O functions.
+ * Purpose:	Hyperslab selection data space I/O functions.
  */
 
 #define H5S_PACKAGE		/*suppress error about including H5Spkg	  */
@@ -30,86 +30,21 @@
 #include "H5Spkg.h"		/* Dataspace functions			*/
 #include "H5VMprivate.h"         /* Vector functions			*/
 
-/* Local Macros */
-
-/* Flags for which hyperslab fragments to compute */
-#define H5S_HYPER_COMPUTE_B_NOT_A 0x01
-#define H5S_HYPER_COMPUTE_A_AND_B 0x02
-#define H5S_HYPER_COMPUTE_A_NOT_B 0x04
-
-/* Macro to advance a span, possibly recycling it first */
-#define H5S_HYPER_ADVANCE_SPAN(recover, curr_span, next_span)   \
-    do {                                                        \
-        /* Check if the span should be recovered */             \
-        if(recover) {                                           \
-            H5S_hyper_free_span(curr_span);                     \
-            recover = FALSE;                                    \
-        } /* end if */                                          \
-                                                                \
-        /* Set the current span to next span */                 \
-        curr_span = next_span;                                  \
-    } while(0)
-
-
 /* Local datatypes */
 
 /* Static function prototypes */
-static H5S_hyper_span_t *H5S_hyper_new_span(hsize_t low, hsize_t high,
-    H5S_hyper_span_info_t *down, H5S_hyper_span_t *next);
-static herr_t H5S_hyper_span_precompute(H5S_hyper_span_info_t *spans, size_t elmt_size);
-static void H5S_hyper_span_scratch(H5S_hyper_span_info_t *spans, void *scr_value);
-static H5S_hyper_span_info_t *H5S_hyper_copy_span(H5S_hyper_span_info_t *spans);
-static htri_t H5S_hyper_cmp_spans(const H5S_hyper_span_info_t *span_info1,
-    const H5S_hyper_span_info_t *span_info2);
 static herr_t H5S_hyper_free_span_info(H5S_hyper_span_info_t *span_info);
 static herr_t H5S_hyper_free_span(H5S_hyper_span_t *span);
-static herr_t H5S_hyper_span_blocklist(const H5S_hyper_span_info_t *spans,
-    hsize_t start[], hsize_t end[], hsize_t rank, hsize_t *startblock, hsize_t *numblocks,
-    hsize_t **buf);
-static herr_t H5S_get_select_hyper_blocklist(H5S_t *space, hbool_t internal,
-    hsize_t startblock, hsize_t numblocks, hsize_t *buf);
-static H5S_hyper_span_t *H5S_hyper_coord_to_span(unsigned rank, const hsize_t *coords);
-static herr_t H5S_hyper_append_span(H5S_hyper_span_t **prev_span,
-    H5S_hyper_span_info_t **span_tree, hsize_t low, hsize_t high,
-    H5S_hyper_span_info_t *down, H5S_hyper_span_t *next);
-static herr_t H5S_hyper_clip_spans(H5S_hyper_span_info_t *a_spans,
-    H5S_hyper_span_info_t *b_spans, unsigned int selector,
-    unsigned cur_dim, unsigned dim_size, const hsize_t *span_a_b_bounds[4],
-    hsize_t *all_clips_bounds, H5S_hyper_span_info_t **a_not_b,
-    H5S_hyper_span_info_t **a_and_b, H5S_hyper_span_info_t **b_not_a);
-static herr_t H5S_hyper_merge_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans);
-static hsize_t H5S_hyper_spans_nelem(const H5S_hyper_span_info_t *spans);
-static herr_t H5S_hyper_add_disjoint_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans);
-static H5S_hyper_span_info_t *H5S_hyper_make_spans(unsigned rank,
-    const hsize_t *start, const hsize_t *stride,
-    const hsize_t *count, const hsize_t *block);
-static herr_t H5S_hyper_update_diminfo(H5S_t *space, H5S_seloper_t op,
-    const H5S_hyper_dim_t *new_hyper_diminfo);
-static hbool_t H5S_hyper_rebuild_helper(const H5S_hyper_span_t *span,
-    H5S_hyper_dim_t span_slab_info[], unsigned rank);
-static herr_t H5S_hyper_generate_spans(H5S_t *space);
-static herr_t H5S_hyper_update_bound_box(H5S_t *space, H5S_seloper_t op,
-    const hsize_t low_bounds[], const hsize_t high_bounds[]);
-static herr_t H5S_fill_in_new_space(H5S_t *space1, H5S_seloper_t op, H5S_hyper_span_info_t *space2_span_lst, const hsize_t *space2_low_bound, const hsize_t *space2_high_bound, hbool_t can_own_span2, hbool_t *span2_owned, hbool_t *updated_spans, H5S_t **result);
+static H5S_hyper_span_info_t *H5S_hyper_copy_span(H5S_hyper_span_info_t *spans);
+static void H5S_hyper_span_scratch(H5S_hyper_span_info_t *spans, void *scr_value);
+static herr_t H5S_hyper_span_precompute(H5S_hyper_span_info_t *spans, size_t elmt_size);
 static herr_t H5S_generate_hyperslab(H5S_t *space, H5S_seloper_t op,
-    const hsize_t start[], const hsize_t stride[], const hsize_t count[],
-    const hsize_t block[]);
-static herr_t H5S_fill_in_hyperslab(H5S_t *old_space, H5S_seloper_t op,
-    const hsize_t start[], const hsize_t *stride, const hsize_t count[],
-    const hsize_t *block, H5S_t **new_space);
-static herr_t H5S_fill_in_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2,
-    H5S_t **result);
-static H5S_t *H5S_combine_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2);
-static herr_t H5S_modify_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2);
-static herr_t H5S_hyper_get_seq_list_gen(const H5S_t *space, H5S_sel_iter_t *iter,
-    size_t maxseq, size_t maxelem, size_t *nseq, size_t *nelem, hsize_t *off,
-    size_t *len);
-static herr_t H5S_hyper_get_seq_list_opt(const H5S_t *space, H5S_sel_iter_t *iter,
-    size_t maxseq, size_t maxelem, size_t *nseq, size_t *nelem, hsize_t *off,
-    size_t *len);
-static herr_t H5S_hyper_get_seq_list_single(const H5S_t *space, H5S_sel_iter_t *iter,
-    size_t maxseq, size_t maxelem, size_t *nseq, size_t *nelem, hsize_t *off,
-    size_t *len);
+    const hsize_t start[], const hsize_t stride[], const hsize_t count[], const hsize_t block[]);
+static herr_t H5S_hyper_generate_spans(H5S_t *space);
+/* Needed for use in hyperslab code (H5Shyper.c) */
+#ifdef NEW_HYPERSLAB_API
+static herr_t H5S_select_select (H5S_t *space1, H5S_seloper_t op, H5S_t *space2);
+#endif /*NEW_HYPERSLAB_API*/
 
 /* Selection callbacks */
 static herr_t H5S_hyper_copy(H5S_t *dst, const H5S_t *src, hbool_t share_selection);
@@ -140,6 +75,11 @@ 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);
+static htri_t H5S_hyper_rebuild(H5S_t *space);
+
 /* Selection properties for hyperslab selections */
 const H5S_select_class_t H5S_sel_hyper[1] = {{
     H5S_SEL_HYPERSLABS,
@@ -274,116 +214,6 @@ H5S_hyper_print_diminfo(FILE *f, const H5S_t *space)
 
     FUNC_LEAVE_NOAPI(SUCCEED)
 }
-
-
-/*--------------------------------------------------------------------------
- NAME
-    H5S_hyper_print_spans_dfs
- PURPOSE
-    Output the span elements for one span list in depth-first order
- USAGE
-    herr_t H5S_hyper_print_spans_dfs(f, span_lst, depth)
-        FILE *f;                                  IN: the file to output
-        const H5S_hyper_span_info_t *span_lst;    IN: the span list to output
-        unsigned depth;                           IN: the level of this span list
- RETURNS
-    non-negative on success, negative on failure
- GLOBAL VARIABLES
- COMMENTS, BUGS, ASSUMPTIONS
- EXAMPLES
- REVISION LOG
---------------------------------------------------------------------------*/
-static herr_t
-H5S_hyper_print_spans_dfs(FILE *f, const H5S_hyper_span_info_t *span_lst,
-    unsigned depth)
-{
-    H5S_hyper_span_t *actual_tail = NULL;
-    H5S_hyper_span_t *cur_elem;
-    unsigned num_elems = 0;
-    unsigned i, elem_idx;
-
-    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5S_hyper_print_spans_dfs)
-
-    /* get the actual tail from head */
-    cur_elem = span_lst->head;
-    HDassert(cur_elem); /* at least 1 element */
-    while(cur_elem) {
-        actual_tail = cur_elem;
-        cur_elem = cur_elem->next;
-        num_elems++;
-    } /* end while */
-
-    for(i = 0; i < depth; i++)
-        HDfprintf(f, "\t");
-    HDfprintf(f, "DIM[%u]: ref_count=%u, #elems=%u, scratch=%p, head=%p, tail=%p, actual_tail=%p, matched=%t\n", depth,
-              span_lst->count, num_elems, span_lst->scratch, span_lst->head,
-              span_lst->tail, actual_tail, (span_lst->tail == actual_tail));
-
-    cur_elem = span_lst->head;
-    elem_idx = 0;
-    while(cur_elem) {
-        for(i = 0; i < depth; i++)
-            HDfprintf(f, "\t");
-        HDfprintf(f, "ELEM[%u]: ptr=%p, low=%Hu, high=%Hu, nelem=%Hu, pstride=%Hu, down=%p\n",
-                  elem_idx++, cur_elem, cur_elem->low, cur_elem->high, cur_elem->nelem,
-                  cur_elem->pstride, cur_elem->down);
-        if(cur_elem->down)
-            H5S_hyper_print_spans_dfs(f, cur_elem->down, depth + 1);
-        cur_elem = cur_elem->next;
-    } /* end while */
-
-    FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5S_hyper_print_spans_dfs() */
-
-
-/*--------------------------------------------------------------------------
- NAME
-    H5S_hyper_print_space_dfs
- PURPOSE
-    Output the span elements for one hyperslab selection space in depth-first order
- USAGE
-    herr_t H5S_hyper_print_space_dfs(f, space)
-        FILE *f;               IN: the file to output
-        const H5S_t *space;    IN: the selection space to output
- RETURNS
-    non-negative on success, negative on failure
- GLOBAL VARIABLES
- COMMENTS, BUGS, ASSUMPTIONS
- EXAMPLES
- REVISION LOG
---------------------------------------------------------------------------*/
-static herr_t
-H5S_hyper_print_space_dfs(FILE *f, const H5S_t *space)
-{
-    const H5S_hyper_sel_t *hslab = space->select.sel_info.hslab;
-    const unsigned dims = space->extent.rank;
-    unsigned i;
-
-    FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5S_hyper_print_space_dfs)
-    HDassert(hslab);
-
-    HDfprintf(f, "=======================\n");
-    HDfprintf(f, "SPACE: span_lst=%p, #dims=%u, offset_changed=%d\n", hslab->span_lst, dims, space->select.offset_changed);
-    HDfprintf(f, "       offsets=[");
-    for(i = 0; i < dims - 1; i++)
-        HDfprintf(f, "%lld,", space->select.offset[i]);
-    HDfprintf(f, "%lld]\n", space->select.offset[dims-1]);
-    HDfprintf(f, "       low_bounds=[");
-    for(i = 0; i < dims-1; i++)
-        HDfprintf(f, "%llu,", space->select.low_bounds[i]);
-    HDfprintf(f, "%llu]\n", space->select.low_bounds[dims-1]);
-    HDfprintf(f, "       high_bounds=[");
-    for(i = 0; i < dims - 1; i++)
-        HDfprintf(f, "%llu,", space->select.high_bounds[i]);
-    HDfprintf(f, "%llu]\n", space->select.high_bounds[dims-1]);
-
-    /* Start print out the highest-order of dimension */
-    if(hslab->span_lst)
-        H5S_hyper_print_spans_dfs(f, hslab->span_lst, 0);
-    HDfprintf(f, "=======================\n\n");
-
-    FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5S_hyper_print_space_dfs() */
 #endif /* H5S_HYPER_DEBUG */
 
 
@@ -426,17 +256,11 @@ H5S_hyper_iter_init(H5S_sel_iter_t *iter, const H5S_t *space)
     /* Get the rank of the dataspace */
     rank = space->extent.rank;
 
-    /* Rebuild diminfo if it is invalid and has not been confirmed to be
-     * impossible */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO)
-        /* Casting away const OK -NAF */
-        (void)H5S_hyper_rebuild((H5S_t *)space);
-
     /* Set the temporary pointer to the dimension information */
     tdiminfo = space->select.sel_info.hslab->opt_diminfo;
 
     /* Check for the special case of just one H5Sselect_hyperslab call made */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+    if(space->select.sel_info.hslab->diminfo_valid) {
 /* Initialize the information needed for regular hyperslab I/O */
         const hsize_t *mem_size;    /* Temporary pointer to dataspace extent's dimension sizes */
         hsize_t acc;                /* Accumulator for "flattened" dimension's sizes */
@@ -583,7 +407,7 @@ H5S_hyper_iter_init(H5S_sel_iter_t *iter, const H5S_t *space)
     iter->type = H5S_sel_iter_hyper;
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5S_hyper_iter_init() */
+}   /* H5S_hyper_iter_init() */
 
 
 /*-------------------------------------------------------------------------
@@ -597,10 +421,12 @@ H5S_hyper_iter_init(H5S_sel_iter_t *iter, const H5S_t *space)
  * Programmer:	Quincey Koziol
  *              Tuesday, April 22, 2003
  *
+ * Modifications:
+ *
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5S_hyper_iter_coords(const H5S_sel_iter_t *iter, hsize_t *coords)
+H5S_hyper_iter_coords (const H5S_sel_iter_t *iter, hsize_t *coords)
 {
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
@@ -668,7 +494,7 @@ H5S_hyper_iter_coords(const H5S_sel_iter_t *iter, hsize_t *coords)
         HDmemcpy(coords, iter->u.hyp.off, sizeof(hsize_t) * iter->rank);
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5S_hyper_iter_coords() */
+}   /* H5S_hyper_iter_coords() */
 
 
 /*-------------------------------------------------------------------------
@@ -685,10 +511,12 @@ H5S_hyper_iter_coords(const H5S_sel_iter_t *iter, hsize_t *coords)
  * Notes:       This routine assumes that the iterator is always located at
  *              the beginning of a block.
  *
+ * Modifications:
+ *
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5S_hyper_iter_block(const H5S_sel_iter_t *iter, hsize_t *start, hsize_t *end)
+H5S_hyper_iter_block (const H5S_sel_iter_t *iter, hsize_t *start, hsize_t *end)
 {
     unsigned u;                 /* Local index variable */
 
@@ -720,7 +548,7 @@ H5S_hyper_iter_block(const H5S_sel_iter_t *iter, hsize_t *start, hsize_t *end)
     } /* end else */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5S_hyper_iter_block() */
+}   /* H5S_hyper_iter_block() */
 
 
 /*-------------------------------------------------------------------------
@@ -733,10 +561,12 @@ H5S_hyper_iter_block(const H5S_sel_iter_t *iter, hsize_t *start, hsize_t *end)
  * Programmer:	Quincey Koziol
  *              Tuesday, June 16, 1998
  *
+ * Modifications:
+ *
  *-------------------------------------------------------------------------
  */
 static hsize_t
-H5S_hyper_iter_nelmts(const H5S_sel_iter_t *iter)
+H5S_hyper_iter_nelmts (const H5S_sel_iter_t *iter)
 {
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
@@ -744,7 +574,7 @@ H5S_hyper_iter_nelmts(const H5S_sel_iter_t *iter)
     HDassert(iter);
 
     FUNC_LEAVE_NOAPI(iter->elmt_left)
-} /* end H5S_hyper_iter_nelmts() */
+}   /* H5S_hyper_iter_nelmts() */
 
 
 /*--------------------------------------------------------------------------
@@ -800,7 +630,7 @@ H5S_hyper_iter_has_next_block(const H5S_sel_iter_t *iter)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_iter_has_next_block() */
+}   /* H5S_hyper_iter_has_next_block() */
 
 
 /*-------------------------------------------------------------------------
@@ -815,6 +645,10 @@ done:
  * Programmer:	Quincey Koziol
  *              Friday, September 8, 2000
  *
+ * Modifications:
+ *      Modified for both general and optimized hyperslab I/O
+ *      Quincey Koziol, April 17, 2003
+ *
  *-------------------------------------------------------------------------
  */
 static herr_t
@@ -1013,7 +847,7 @@ H5S_hyper_iter_next(H5S_sel_iter_t *iter, size_t nelem)
     } /* end else */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5S_hyper_iter_next() */
+} /* H5S_hyper_iter_next() */
 
 
 /*-------------------------------------------------------------------------
@@ -1028,6 +862,8 @@ H5S_hyper_iter_next(H5S_sel_iter_t *iter, size_t nelem)
  * Programmer:	Quincey Koziol
  *              Tuesday, June 3, 2003
  *
+ * Modifications:
+ *
  *-------------------------------------------------------------------------
  */
 static herr_t
@@ -1196,7 +1032,7 @@ H5S_hyper_iter_next_block(H5S_sel_iter_t *iter)
     } /* end else */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5S_hyper_iter_next() */
+} /* H5S_hyper_iter_next() */
 
 
 /*--------------------------------------------------------------------------
@@ -1217,7 +1053,7 @@ H5S_hyper_iter_next_block(H5S_sel_iter_t *iter)
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S_hyper_iter_release(H5S_sel_iter_t *iter)
+H5S_hyper_iter_release (H5S_sel_iter_t *iter)
 {
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
@@ -1230,7 +1066,7 @@ H5S_hyper_iter_release(H5S_sel_iter_t *iter)
         H5S_hyper_free_span_info(iter->u.hyp.spans);
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5S_hyper_iter_release() */
+}   /* H5S_hyper_iter_release() */
 
 
 /*--------------------------------------------------------------------------
@@ -1279,7 +1115,7 @@ H5S_hyper_new_span(hsize_t low, hsize_t high, H5S_hyper_span_info_t *down, H5S_h
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_new_span() */
+}   /* H5S_hyper_new_span() */
 
 
 /*--------------------------------------------------------------------------
@@ -1302,17 +1138,17 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S_hyper_span_precompute_helper(H5S_hyper_span_info_t *spans, size_t elmt_size)
+H5S_hyper_span_precompute_helper (H5S_hyper_span_info_t *spans, size_t elmt_size)
 {
-    H5S_hyper_span_t *span;             /* Hyperslab span */
-    herr_t ret_value = SUCCEED;         /* Return value */
+    H5S_hyper_span_t *span;     /* Hyperslab span */
+    herr_t      ret_value = SUCCEED;       /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
     HDassert(spans);
 
     /* Check if we've already set this down span tree */
-    if(spans->scratch != (H5S_hyper_span_info_t *)~((size_t)NULL)) {
+    if(spans->scratch!=(H5S_hyper_span_info_t *)~((size_t)NULL)) {
         /* Set the tree's scratch pointer */
         spans->scratch=(H5S_hyper_span_info_t *)~((size_t)NULL);
 
@@ -1338,7 +1174,7 @@ H5S_hyper_span_precompute_helper(H5S_hyper_span_info_t *spans, size_t elmt_size)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_span_precompute_helper() */
+}   /* H5S_hyper_span_precompute_helper() */
 
 
 /*--------------------------------------------------------------------------
@@ -1378,7 +1214,7 @@ H5S_hyper_span_precompute(H5S_hyper_span_info_t *spans, size_t elmt_size)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_span_precompute() */
+}   /* H5S_hyper_span_precompute() */
 
 
 /*--------------------------------------------------------------------------
@@ -1425,7 +1261,7 @@ H5S_hyper_span_scratch(H5S_hyper_span_info_t *spans, void *scr_value)
     } /* end if */
 
     FUNC_LEAVE_NOAPI_VOID
-} /* end H5S_hyper_span_scratch() */
+}   /* H5S_hyper_span_scratch() */
 
 
 /*--------------------------------------------------------------------------
@@ -1446,7 +1282,7 @@ H5S_hyper_span_scratch(H5S_hyper_span_info_t *spans, void *scr_value)
  REVISION LOG
 --------------------------------------------------------------------------*/
 static H5S_hyper_span_info_t *
-H5S_hyper_copy_span_helper(H5S_hyper_span_info_t *spans)
+H5S_hyper_copy_span_helper (H5S_hyper_span_info_t *spans)
 {
     H5S_hyper_span_t *span;         /* Hyperslab span */
     H5S_hyper_span_t *new_span;     /* Temporary hyperslab span */
@@ -1468,11 +1304,13 @@ H5S_hyper_copy_span_helper(H5S_hyper_span_info_t *spans)
     } /* end if */
     else {
         /* Allocate a new span_info node */
-        if(NULL == (ret_value = H5FL_CALLOC(H5S_hyper_span_info_t)))
+        if(NULL == (ret_value = H5FL_MALLOC(H5S_hyper_span_info_t)))
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span info")
 
-        /* Set the non-zero span_info information */
+        /* Copy the span_info information */
         ret_value->count = 1;
+        ret_value->scratch = NULL;
+        ret_value->head = NULL;
 
         /* Set the scratch pointer in the node being copied to the newly allocated node */
         spans->scratch = ret_value;
@@ -1507,14 +1345,11 @@ H5S_hyper_copy_span_helper(H5S_hyper_span_info_t *spans)
             /* Advance to next span */
             span = span->next;
         } /* end while */
-
-        /* Retain a pointer to the last span */
-        ret_value->tail = prev_span;
     } /* end else */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_copy_span_helper() */
+}   /* H5S_hyper_copy_span_helper() */
 
 
 /*--------------------------------------------------------------------------
@@ -1554,7 +1389,7 @@ H5S_hyper_copy_span(H5S_hyper_span_info_t *spans)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_copy_span() */
+}   /* H5S_hyper_copy_span() */
 
 
 /*--------------------------------------------------------------------------
@@ -1577,20 +1412,19 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static htri_t
-H5S_hyper_cmp_spans(const H5S_hyper_span_info_t *span_info1, const H5S_hyper_span_info_t *span_info2)
+H5S_hyper_cmp_spans (H5S_hyper_span_info_t *span_info1, H5S_hyper_span_info_t *span_info2)
 {
-    htri_t ret_value = FAIL;    /* Return value */
+    H5S_hyper_span_t *span1;
+    H5S_hyper_span_t *span2;
+    htri_t nest=FAIL;
+    htri_t ret_value=FAIL;
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     /* Check for redundant comparison */
-    if(span_info1 == span_info2)
-        ret_value = TRUE;
+    if(span_info1==span_info2)
+        ret_value=TRUE;
     else {
-        const H5S_hyper_span_t *span1;
-        const H5S_hyper_span_t *span2;
-        htri_t nest = FAIL;
-
         /* Check for both spans being NULL */
         if(span_info1==NULL && span_info2==NULL)
             ret_value=TRUE;
@@ -1658,7 +1492,7 @@ H5S_hyper_cmp_spans(const H5S_hyper_span_info_t *span_info1, const H5S_hyper_spa
     } /* end else */
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_cmp_spans() */
+}   /* H5S_hyper_cmp_spans() */
 
 
 /*--------------------------------------------------------------------------
@@ -1681,7 +1515,7 @@ H5S_hyper_cmp_spans(const H5S_hyper_span_info_t *span_info1, const H5S_hyper_spa
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S_hyper_free_span_info(H5S_hyper_span_info_t *span_info)
+H5S_hyper_free_span_info (H5S_hyper_span_info_t *span_info)
 {
     H5S_hyper_span_t *span, *next_span;
     herr_t      ret_value=SUCCEED;       /* Return value */
@@ -1711,7 +1545,7 @@ H5S_hyper_free_span_info(H5S_hyper_span_info_t *span_info)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_free_span_info() */
+}   /* H5S_hyper_free_span_info() */
 
 
 /*--------------------------------------------------------------------------
@@ -1734,7 +1568,7 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S_hyper_free_span(H5S_hyper_span_t *span)
+H5S_hyper_free_span (H5S_hyper_span_t *span)
 {
     herr_t ret_value=SUCCEED;
 
@@ -1753,7 +1587,7 @@ H5S_hyper_free_span(H5S_hyper_span_t *span)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_free_span() */
+}   /* H5S_hyper_free_span() */
 
 
 /*--------------------------------------------------------------------------
@@ -1781,15 +1615,14 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S_hyper_copy(H5S_t *dst, const H5S_t *src, hbool_t share_selection)
+H5S_hyper_copy (H5S_t *dst, const H5S_t *src, hbool_t share_selection)
 {
     H5S_hyper_sel_t *dst_hslab;         /* Pointer to destination hyperslab info */
     const H5S_hyper_sel_t *src_hslab;   /* Pointer to source hyperslab info */
-    herr_t ret_value = SUCCEED;         /* Return value */
+    herr_t ret_value=SUCCEED;   /* return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
-    /* Sanity check */
     HDassert(src);
     HDassert(dst);
 
@@ -1798,21 +1631,24 @@ H5S_hyper_copy(H5S_t *dst, const H5S_t *src, hbool_t share_selection)
         HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab info")
 
     /* Set temporary pointers */
-    dst_hslab = dst->select.sel_info.hslab;
-    src_hslab = src->select.sel_info.hslab;
+    dst_hslab=dst->select.sel_info.hslab;
+    src_hslab=src->select.sel_info.hslab;
 
     /* Copy the hyperslab information */
-    dst_hslab->diminfo_valid = src_hslab->diminfo_valid;
-    if(src_hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
-        HDmemcpy(dst_hslab->opt_diminfo, src_hslab->opt_diminfo, sizeof(H5S_hyper_dim_t) * src->extent.rank);
-        HDmemcpy(dst_hslab->app_diminfo, src_hslab->app_diminfo, sizeof(H5S_hyper_dim_t) * src->extent.rank);
-    } /* end if */
+    dst_hslab->diminfo_valid=src_hslab->diminfo_valid;
+    if(src_hslab->diminfo_valid) {
+        size_t u;       /* Local index variable */
 
-    dst->select.sel_info.hslab->span_lst = src->select.sel_info.hslab->span_lst;
+        for(u=0; u<src->extent.rank; u++) {
+            dst_hslab->opt_diminfo[u]=src_hslab->opt_diminfo[u];
+            dst_hslab->app_diminfo[u]=src_hslab->app_diminfo[u];
+        } /* end for */
+    } /* end if */
+    dst->select.sel_info.hslab->span_lst=src->select.sel_info.hslab->span_lst;
 
     /* Check if there is hyperslab span information to copy */
     /* (Regular hyperslab information is copied with the selection structure) */
-    if(src->select.sel_info.hslab->span_lst != NULL) {
+    if(src->select.sel_info.hslab->span_lst!=NULL) {
         if(share_selection) {
             /* Share the source's span tree by incrementing the reference count on it */
             dst->select.sel_info.hslab->span_lst->count++;
@@ -1829,6 +1665,72 @@ done:
 
 /*--------------------------------------------------------------------------
  NAME
+    H5S_hyper_is_valid_helper
+ PURPOSE
+    Check whether the selection fits within the extent, with the current
+    offset defined.
+ USAGE
+    htri_t H5S_hyper_is_valid_helper(spans, offset, rank);
+        const H5S_hyper_span_info_t *spans; IN: Pointer to current hyperslab span tree
+        const hssize_t *offset;             IN: Pointer to offset array
+        const hsize_t *size;                IN: Pointer to size array
+        hsize_t rank;                       IN: Current rank looking at
+ RETURNS
+    TRUE if the selection fits within the extent, FALSE if it does not and
+        Negative on an error.
+ DESCRIPTION
+    Determines if the current selection at the current offet fits within the
+    extent for the dataspace.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+static htri_t
+H5S_hyper_is_valid_helper (const H5S_hyper_span_info_t *spans, const hssize_t *offset, const hsize_t *size, hsize_t rank)
+{
+    H5S_hyper_span_t *curr;     /* Hyperslab information nodes */
+    htri_t tmp;                 /* temporary return value */
+    htri_t ret_value=TRUE;      /* return value */
+
+    FUNC_ENTER_NOAPI_NOINIT_NOERR
+
+    HDassert(spans);
+    HDassert(offset);
+    HDassert(size);
+    HDassert(rank < H5O_LAYOUT_NDIMS);
+
+    /* Check each point to determine whether selection+offset is within extent */
+    curr=spans->head;
+    while(curr!=NULL && ret_value==TRUE) {
+        /* Check if an offset has been defined */
+        /* Bounds check the selected point + offset against the extent */
+        if((((hssize_t)curr->low+offset[rank])>=(hssize_t)size[rank])
+                || (((hssize_t)curr->low+offset[rank])<0)
+                || (((hssize_t)curr->high+offset[rank])>=(hssize_t)size[rank])
+                || (((hssize_t)curr->high+offset[rank])<0)) {
+            ret_value=FALSE;
+            break;
+        } /* end if */
+
+        /* Recurse if this node has down spans */
+        if(curr->down!=NULL) {
+            if((tmp=H5S_hyper_is_valid_helper(curr->down,offset,size,rank+1))!=TRUE) {
+                ret_value=tmp;
+                break;
+            } /* end if */
+        } /* end if */
+
+        /* Advance to next node */
+        curr=curr->next;
+    } /* end while */
+
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5S_hyper_is_valid_helper() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
     H5S_hyper_is_valid
  PURPOSE
     Check whether the selection fits within the extent, with the current
@@ -1848,23 +1750,43 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static htri_t
-H5S_hyper_is_valid(const H5S_t *space)
+H5S_hyper_is_valid (const H5S_t *space)
 {
-    unsigned u;                 /* Counter */
-    htri_t ret_value = TRUE;    /* Return value */
+    unsigned u;                    /* Counter */
+    htri_t ret_value=TRUE;      /* return value */
 
     FUNC_ENTER_NOAPI_NOERR
 
     HDassert(space);
 
-    /* Check each dimension */
-    for(u = 0; u < space->extent.rank; u++) {
-        /* Bounds check the selected point + offset against the extent */
-        if(((hssize_t)space->select.low_bounds[u] + space->select.offset[u]) < 0)
-            HGOTO_DONE(FALSE)
-        if((space->select.high_bounds[u] + (hsize_t)space->select.offset[u]) >= space->extent.size[u])
-            HGOTO_DONE(FALSE)
-    } /* end for */
+    /* Check for a "regular" hyperslab selection */
+    if(space->select.sel_info.hslab->diminfo_valid) {
+        const H5S_hyper_dim_t *diminfo=space->select.sel_info.hslab->opt_diminfo; /* local alias for diminfo */
+        hssize_t end;      /* The high bound of a region in a dimension */
+
+        /* Check each dimension */
+        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(((hssize_t)diminfo[u].start+space->select.offset[u])<0 ||
+                        ((hssize_t)diminfo[u].start+space->select.offset[u])>=(hssize_t)space->extent.size[u])
+                    HGOTO_DONE(FALSE)
+
+                /* Compute the largest location in this dimension */
+                end=(hssize_t)(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.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.size,(hsize_t)0);
+    } /* end else */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -1913,7 +1835,7 @@ H5S_hyper_span_nblocks(H5S_hyper_span_info_t *spans)
     } /* end else */
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_span_nblocks() */
+}   /* H5S_hyper_span_nblocks() */
 
 
 /*--------------------------------------------------------------------------
@@ -1936,15 +1858,14 @@ H5S_hyper_span_nblocks(H5S_hyper_span_info_t *spans)
 static hsize_t
 H5S_get_select_hyper_nblocks(H5S_t *space)
 {
-    hsize_t ret_value;         /* Return value */
+    hsize_t ret_value;         /* return value */
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     HDassert(space);
 
     /* Check for a "regular" hyperslab selection */
-    /* (No need to rebuild the dimension info yet -QAK) */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+    if(space->select.sel_info.hslab->diminfo_valid) {
         unsigned u;                 /* Local index variable */
 
         /* Check each dimension */
@@ -1955,7 +1876,7 @@ H5S_get_select_hyper_nblocks(H5S_t *space)
         ret_value = H5S_hyper_span_nblocks(space->select.sel_info.hslab->span_lst);
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_get_select_hyper_nblocks() */
+}   /* H5S_get_select_hyper_nblocks() */
 
 
 /*--------------------------------------------------------------------------
@@ -1986,7 +1907,7 @@ H5Sget_select_hyper_nblocks(hid_t spaceid)
 
     /* Check args */
     if(NULL == (space = (H5S_t *)H5I_object_verify(spaceid, H5I_DATASPACE)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space")
     if(H5S_GET_SELECT_TYPE(space) != H5S_SEL_HYPERSLABS)
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a hyperslab selection")
 
@@ -1994,7 +1915,7 @@ H5Sget_select_hyper_nblocks(hid_t spaceid)
 
 done:
     FUNC_LEAVE_API(ret_value)
-} /* end H5Sget_select_hyper_nblocks() */
+}   /* H5Sget_select_hyper_nblocks() */
 
 
 /*--------------------------------------------------------------------------
@@ -2034,10 +1955,7 @@ H5S_hyper_serial_size(const H5S_t *space)
     ret_value = 24;
 
     /* Check for a "regular" hyperslab selection */
-    /* (It would be useful to rebuild the regular hyperslab selection, if we
-     *  encoded it efficiently, which we aren't currently. *sigh* -QAK)
-     */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+    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;
@@ -2076,7 +1994,7 @@ H5S_hyper_serial_size(const H5S_t *space)
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S_hyper_serialize_helper(const H5S_hyper_span_info_t *spans, hsize_t *start, hsize_t *end, hsize_t rank, uint8_t **buf)
+H5S_hyper_serialize_helper (const H5S_hyper_span_info_t *spans, hsize_t *start, hsize_t *end, hsize_t rank, uint8_t **buf)
 {
     H5S_hyper_span_t *curr;     /* Pointer to current hyperslab span */
     hsize_t u;                  /* Index variable */
@@ -2128,7 +2046,7 @@ H5S_hyper_serialize_helper(const H5S_hyper_span_info_t *spans, hsize_t *start, h
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_serialize_helper() */
+}   /* H5S_hyper_serialize_helper() */
 
 
 /*--------------------------------------------------------------------------
@@ -2151,7 +2069,7 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S_hyper_serialize(const H5S_t *space, uint8_t *buf)
+H5S_hyper_serialize (const H5S_t *space, uint8_t *buf)
 {
     const H5S_hyper_dim_t *diminfo;         /* Alias for dataspace's diminfo information */
     hsize_t tmp_count[H5O_LAYOUT_NDIMS];    /* Temporary hyperslab counts */
@@ -2182,16 +2100,13 @@ H5S_hyper_serialize(const H5S_t *space, uint8_t *buf)
     len += 4;
 
     /* Check for a "regular" hyperslab selection */
-    /* (It would be useful to rebuild the regular hyperslab selection, if we
-     *  encoded it efficiently, which we aren't currently. *sigh* -QAK)
-     */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+    if(space->select.sel_info.hslab->diminfo_valid) {
         unsigned u;     /* Local counting variable */
 
-        /* Set some convenience values */
+        /* Set some convienence values */
         ndims = space->extent.rank;
         fast_dim = ndims - 1;
-        diminfo = space->select.sel_info.hslab->opt_diminfo;
+        diminfo=space->select.sel_info.hslab->opt_diminfo;
 
         /* Check each dimension */
         for(block_count = 1, u = 0; u < ndims; u++)
@@ -2282,7 +2197,7 @@ H5S_hyper_serialize(const H5S_t *space, uint8_t *buf)
 
         /* Add 8 bytes times the rank for each hyperslab selected */
         H5_CHECK_OVERFLOW((8 * space->extent.rank * block_count), hsize_t, size_t);
-        len += (uint32_t)(8 * space->extent.rank * block_count);
+        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);
@@ -2292,7 +2207,7 @@ H5S_hyper_serialize(const H5S_t *space, uint8_t *buf)
     UINT32ENCODE(lenp, (uint32_t)len);  /* Store the length of the extra information */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5S_hyper_serialize() */
+}   /* H5S_hyper_serialize() */
 
 
 /*--------------------------------------------------------------------------
@@ -2315,7 +2230,7 @@ H5S_hyper_serialize(const H5S_t *space, uint8_t *buf)
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S_hyper_deserialize(H5S_t *space, const uint8_t *buf)
+H5S_hyper_deserialize (H5S_t *space, const uint8_t *buf)
 {
     uint32_t rank;           	/* rank of points */
     size_t num_elem=0;      	/* number of elements in selection */
@@ -2372,7 +2287,7 @@ H5S_hyper_deserialize(H5S_t *space, const uint8_t *buf)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_deserialize() */
+}   /* H5S_hyper_deserialize() */
 
 
 /*--------------------------------------------------------------------------
@@ -2409,11 +2324,9 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S_hyper_span_blocklist(const H5S_hyper_span_info_t *spans, hsize_t start[],
-    hsize_t end[], hsize_t rank, hsize_t *startblock, hsize_t *numblocks,
-    hsize_t **buf)
+H5S_hyper_span_blocklist(H5S_hyper_span_info_t *spans, hsize_t start[], hsize_t end[], hsize_t rank, hsize_t *startblock, hsize_t *numblocks, hsize_t **buf)
 {
-    const H5S_hyper_span_t *curr;     /* Pointer to current hyperslab span */
+    H5S_hyper_span_t *curr;     /* Pointer to current hyperslab span */
     hsize_t u;                  /* Index variable */
     herr_t ret_value = SUCCEED; /* return value */
 
@@ -2478,7 +2391,7 @@ H5S_hyper_span_blocklist(const H5S_hyper_span_info_t *spans, hsize_t start[],
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_span_blocklist() */
+}   /* H5S_hyper_span_blocklist() */
 
 
 /*--------------------------------------------------------------------------
@@ -2521,13 +2434,8 @@ H5S_get_select_hyper_blocklist(H5S_t *space, hbool_t internal, hsize_t startbloc
     HDassert(space);
     HDassert(buf);
 
-    /* Rebuild diminfo if it is invalid and has not been confirmed to be
-     * impossible */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO)
-        (void)H5S_hyper_rebuild(space);
-
     /* Check for a "regular" hyperslab selection */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+    if(space->select.sel_info.hslab->diminfo_valid) {
         const H5S_hyper_dim_t *diminfo; /* Alias for dataspace's diminfo information */
         hsize_t tmp_count[H5O_LAYOUT_NDIMS];    /* Temporary hyperslab counts */
         hsize_t offset[H5O_LAYOUT_NDIMS];      /* Offset of element in dataspace */
@@ -2639,7 +2547,7 @@ H5S_get_select_hyper_blocklist(H5S_t *space, hbool_t internal, hsize_t startbloc
     } /* end else */
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_get_select_hyper_blocklist() */
+}   /* H5S_get_select_hyper_blocklist() */
 
 
 /*--------------------------------------------------------------------------
@@ -2686,7 +2594,7 @@ H5Sget_select_hyper_blocklist(hid_t spaceid, hsize_t startblock,
     if(buf == NULL)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "invalid pointer")
     if(NULL == (space = (H5S_t *)H5I_object_verify(spaceid, H5I_DATASPACE)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space")
     if(H5S_GET_SELECT_TYPE(space)!=H5S_SEL_HYPERSLABS)
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a hyperslab selection")
 
@@ -2698,7 +2606,77 @@ H5Sget_select_hyper_blocklist(hid_t spaceid, hsize_t startblock,
 
 done:
     FUNC_LEAVE_API(ret_value)
-} /* end H5Sget_select_hyper_blocklist() */
+}   /* H5Sget_select_hyper_blocklist() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_bounds_helper
+ PURPOSE
+    Gets the bounding box containing the selection.
+ USAGE
+    htri_t H5S_hyper_bounds_helper(spans, offset, rank);
+        const H5S_hyper_span_info_t *spans; IN: Pointer to current hyperslab span tree
+        const hssize_t *offset;         IN: Pointer to offset array
+        hsize_t rank;                   IN: Current rank looking at
+        hsize_t *start;                 OUT: Start array bounds
+        hsize_t *end;                   OUT: End array bounds
+ RETURNS
+    Non-negative on success, negative on failure
+ DESCRIPTION
+    Retrieves the bounding box containing the current selection and places
+    it into the user's buffers.  The start and end buffers must be large
+    enough to hold the dataspace rank number of coordinates.  The bounding box
+    exactly contains the selection, ie. if a 2-D element selection is currently
+    defined with the following points: (4,5), (6,8) (10,7), the bounding box
+    with be (4, 5), (10, 8).
+        The bounding box calculations _does_ include the current offset of the
+    selection within the dataspace extent.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+static herr_t
+H5S_hyper_bounds_helper(const H5S_hyper_span_info_t *spans, const hssize_t *offset, hsize_t rank, hsize_t *start, hsize_t *end)
+{
+    H5S_hyper_span_t *curr;             /* Hyperslab information nodes */
+    herr_t      ret_value = SUCCEED;    /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT
+
+    HDassert(spans);
+    HDassert(offset);
+    HDassert(rank < H5O_LAYOUT_NDIMS);
+    HDassert(start);
+    HDassert(end);
+
+    /* Check each point to determine whether selection+offset is within extent */
+    curr=spans->head;
+    while(curr!=NULL) {
+        /* Check for offset moving selection negative */
+        if(((hssize_t)curr->low + offset[rank]) < 0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "offset moves selection out of bounds")
+
+        /* Check if the current span extends the bounding box */
+        if((curr->low + (hsize_t)offset[rank]) < start[rank])
+            start[rank] = curr->low + (hsize_t)offset[rank];
+        if((curr->high + (hsize_t)offset[rank]) > end[rank])
+            end[rank] = curr->high + (hsize_t)offset[rank];
+
+        /* Recurse if this node has down spans */
+        if(curr->down != NULL) {
+            if(H5S_hyper_bounds_helper(curr->down, offset, (rank + 1), start, end) < 0)
+                HGOTO_ERROR(H5E_DATASPACE, H5E_BADSELECT, FAIL, "failure in lower dimension")
+        } /* end if */
+
+        /* Advance to next node */
+        curr = curr->next;
+    } /* end while */
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5S_hyper_bounds_helper() */
 
 
 /*--------------------------------------------------------------------------
@@ -2730,33 +2708,48 @@ done:
 static herr_t
 H5S_hyper_bounds(const H5S_t *space, hsize_t *start, hsize_t *end)
 {
-    unsigned u;                 /* Local index variable */
+    unsigned rank;              /* Dataspace rank */
+    unsigned i;                 /* index variable */
     herr_t ret_value = SUCCEED; /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_NOAPI(FAIL)
 
-    /* Sanity check */
     HDassert(space);
     HDassert(start);
     HDassert(end);
 
-    /* Loop over dimensions */
-    for(u = 0; u < space->extent.rank; u++) {
-        /* Sanity check */
-        HDassert(space->select.low_bounds[u] <= space->select.high_bounds[u]);
+    /* Set the start and end arrays up */
+    rank = space->extent.rank;
+    for(i = 0; i < rank; i++) {
+        start[i] = HSIZET_MAX;
+        end[i] = 0;
+    } /* end for */
 
-        /* Check for offset moving selection negative */
-        if(((hssize_t)space->select.low_bounds[u] + space->select.offset[u]) < 0)
-            HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "offset moves selection out of bounds")
+    /* Check for a "regular" hyperslab selection */
+    if(space->select.sel_info.hslab->diminfo_valid) {
+        const H5S_hyper_dim_t *diminfo = space->select.sel_info.hslab->opt_diminfo; /* local alias for diminfo */
 
-        /* Set the low & high bounds in this dimension */
-        start[u] = (hsize_t)((hssize_t)space->select.low_bounds[u] + space->select.offset[u]);
-        end[u] = (hsize_t)((hssize_t)space->select.high_bounds[u] + space->select.offset[u]);
-    } /* end for */
+        /* Check each dimension */
+        for(i = 0; i < rank; i++) {
+            /* Check for offset moving selection negative */
+            if((space->select.offset[i] + (hssize_t)diminfo[i].start) < 0)
+                HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "offset moves selection out of bounds")
+
+            /* Compute the smallest location in this dimension */
+            start[i] = diminfo[i].start + (hsize_t)space->select.offset[i];
+
+            /* Compute the largest location in this dimension */
+            end[i] = diminfo[i].start + diminfo[i].stride * (diminfo[i].count - 1) + (diminfo[i].block - 1) + (hsize_t)space->select.offset[i];
+        } /* end for */
+    } /* end if */
+    else {
+        /* Call the recursive routine to get the bounds for the span tree */
+        ret_value = H5S_hyper_bounds_helper(space->select.sel_info.hslab->span_lst, space->select.offset, (hsize_t)0, start, end);
+    } /* end if */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_bounds() */
+}   /* H5S_hyper_bounds() */
 
 
 /*--------------------------------------------------------------------------
@@ -2803,8 +2796,7 @@ H5S_hyper_offset(const H5S_t *space, hsize_t *offset)
     dim_size = space->extent.size;
 
     /* Check for a "regular" hyperslab selection */
-    /* (No need to rebuild the dimension info yet -QAK) */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+    if(space->select.sel_info.hslab->diminfo_valid) {
         const H5S_hyper_dim_t *diminfo = space->select.sel_info.hslab->opt_diminfo; /* Local alias for diminfo */
 
         /* Loop through starting coordinates, calculating the linear offset */
@@ -2865,7 +2857,7 @@ H5S_hyper_offset(const H5S_t *space, hsize_t *offset)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_offset() */
+}   /* H5S_hyper_offset() */
 
 
 /*--------------------------------------------------------------------------
@@ -2899,8 +2891,7 @@ H5S_hyper_is_contiguous(const H5S_t *space)
     HDassert(space);
 
     /* Check for a "regular" hyperslab selection */
-    /* (No need to rebuild the dimension info yet -QAK) */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+    if(space->select.sel_info.hslab->diminfo_valid) {
         const H5S_hyper_dim_t *diminfo=space->select.sel_info.hslab->opt_diminfo; /* local alias for diminfo */
 
         /*
@@ -3051,7 +3042,7 @@ H5S_hyper_is_contiguous(const H5S_t *space)
     } /* end else */
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_is_contiguous() */
+}   /* H5S_hyper_is_contiguous() */
 
 
 /*--------------------------------------------------------------------------
@@ -3085,8 +3076,7 @@ H5S_hyper_is_single(const H5S_t *space)
     HDassert(space);
 
     /* Check for a "single" hyperslab selection */
-    /* (No need to rebuild the dimension info yet -QAK) */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+    if(space->select.sel_info.hslab->diminfo_valid) {
         /*
          * For a regular hyperslab to be single, it must have only one
          * block (i.e. count==1 in all dimensions)
@@ -3120,7 +3110,7 @@ H5S_hyper_is_single(const H5S_t *space)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_is_single() */
+}   /* H5S_hyper_is_single() */
 
 
 /*--------------------------------------------------------------------------
@@ -3153,20 +3143,14 @@ H5S_hyper_is_regular(const H5S_t *space)
     /* Check args */
     HDassert(space);
 
-    /* Rebuild diminfo if it is invalid and has not been confirmed to be
-     * impossible */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO)
-        /* Casting away const OK -NAF */
-        (void)H5S_hyper_rebuild((H5S_t *)space);
-
     /* Only simple check for regular hyperslabs for now... */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES)
-        ret_value = TRUE;
+    if(space->select.sel_info.hslab->diminfo_valid)
+        ret_value=TRUE;
     else
-        ret_value = FALSE;
+        ret_value=FALSE;
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_is_regular() */
+}   /* H5S_hyper_is_regular() */
 
 
 /*--------------------------------------------------------------------------
@@ -3188,8 +3172,8 @@ H5S_hyper_is_regular(const H5S_t *space)
  * 	Robb Matzke, 1998-08-25
  *	The fields which are freed are set to NULL to prevent them from being
  *	freed again later.  This fixes some allocation problems where
- *	changing the hyperslab selection of one dataspace causes a core dump
- *	when closing some other dataspace.
+ *	changing the hyperslab selection of one data space causes a core dump
+ *	when closing some other data space.
 --------------------------------------------------------------------------*/
 static herr_t
 H5S_hyper_release(H5S_t *space)
@@ -3215,7 +3199,48 @@ H5S_hyper_release(H5S_t *space)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_release() */
+}   /* H5S_hyper_release() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_recover_span
+ PURPOSE
+    Recover a generated span, if appropriate
+ USAGE
+    herr_t H5S_hyper_recover_span(recover, curr_span, next_span)
+        unsigned *recover;                 IN/OUT: Pointer recover flag
+        H5S_hyper_span_t **curr_span;   IN/OUT: Pointer to current span in list
+        H5S_hyper_span_t *next_span;    IN: Pointer to next span
+ RETURNS
+    Non-negative on success, negative on failure
+ DESCRIPTION
+    Check if the current span needs to be recovered and free it if so.
+    Set the current span to the next span in any case.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+static herr_t
+H5S_hyper_recover_span (unsigned *recover, H5S_hyper_span_t **curr_span, H5S_hyper_span_t *next_span)
+{
+    FUNC_ENTER_NOAPI_NOINIT_NOERR
+
+    HDassert(recover);
+    HDassert(curr_span);
+
+    /* Check if the span should be recovered */
+    if(*recover) {
+        H5S_hyper_free_span(*curr_span);
+        *recover=0;
+    } /* end if */
+
+    /* Set the current span to next span */
+    *curr_span=next_span;
+
+    FUNC_LEAVE_NOAPI(SUCCEED)
+}   /* H5S_hyper_recover_span() */
 
 
 /*--------------------------------------------------------------------------
@@ -3237,11 +3262,11 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static H5S_hyper_span_t *
-H5S_hyper_coord_to_span(unsigned rank, const hsize_t *coords)
+H5S_hyper_coord_to_span(unsigned rank, hsize_t *coords)
 {
     H5S_hyper_span_t *new_span;         /* Pointer to new span tree for coordinate */
-    H5S_hyper_span_info_t *down = NULL; /* Pointer to new span tree for next level down */
-    H5S_hyper_span_t *ret_value = NULL; /* Return value */
+    H5S_hyper_span_info_t *down=NULL;   /* Pointer to new span tree for next level down */
+    H5S_hyper_span_t *ret_value=NULL;   /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -3249,32 +3274,37 @@ H5S_hyper_coord_to_span(unsigned rank, const hsize_t *coords)
     HDassert(coords);
 
     /* Search for location to insert new element in tree */
-    if(rank > 1) {
+    if(rank>1) {
         /* Allocate a span info node */
-        if(NULL == (down = H5FL_CALLOC(H5S_hyper_span_info_t)))
+        if((down = H5FL_MALLOC(H5S_hyper_span_info_t))==NULL)
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span")
 
+        /* Set the reference count */
+        down->count=0;
+
+        /* Reset the scratch pad space */
+        down->scratch=0;
+
         /* Build span tree for coordinates below this one */
-        if(NULL == (down->head = H5S_hyper_coord_to_span(rank - 1, &coords[1])))
+        if((down->head=H5S_hyper_coord_to_span(rank-1,&coords[1]))==NULL)
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span")
-
-       /* Update the tail pointer of the down dimension, and it's a single span element */
-       down->tail = down->head;
     } /* end if */
 
     /* Build span for this coordinate */
-    if(NULL == (new_span = H5S_hyper_new_span(coords[0], coords[0], down, NULL)))
+    if((new_span = H5S_hyper_new_span(coords[0],coords[0],down,NULL))==NULL)
         HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span")
 
     /* Set return value */
-    ret_value = new_span;
+    ret_value=new_span;
 
 done:
-    if(ret_value == NULL && down!=NULL)
-        H5S_hyper_free_span_info(down);
+    if(ret_value==NULL) {
+        if(down!=NULL)
+            H5S_hyper_free_span_info(down);
+    } /* end if */
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_coord_to_span() */
+}   /* H5S_hyper_coord_to_span() */
 
 
 /*--------------------------------------------------------------------------
@@ -3294,29 +3324,18 @@ done:
  GLOBAL VARIABLES
  COMMENTS, BUGS, ASSUMPTIONS
     Assumes that the element is not already covered by the span tree
-
-    NOTE: There's an assumption about the context of this function call.
-    This function is only called  is only being called from
-    H5D_chunk_mem_cb in src/H5Dchunk, when the library is
-    iterating over a memory selection, so the coordinates passed
-    to H5S_hyper_add_span_element will always be in increasing
-    order (according to a row-major (i.e. C, not FORTRAN) scan
-    over the dataset. Therefore, for every input of coordinates,
-    only the last span element (i.e., the tail pointer) in one
-    dimension is checked against the input.
  EXAMPLES
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S_hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree,
-    unsigned rank, const hsize_t *coords)
+H5S_hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree, unsigned rank, hsize_t *coords)
 {
     H5S_hyper_span_info_t *tspan_info;  /* Temporary pointer to span info */
     H5S_hyper_span_info_t *prev_span_info;  /* Pointer to span info for level above current position */
-    H5S_hyper_span_t *tail_span;        /* Pointer to the tail span of one dimension */
+    H5S_hyper_span_t *tmp_span;         /* Temporary pointer to a span */
     H5S_hyper_span_t *tmp2_span;        /* Another temporary pointer to a span */
     H5S_hyper_span_t *new_span;         /* New span created for element */
-    herr_t ret_value = SUCCEED;         /* Return value */
+    herr_t ret_value=SUCCEED;           /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -3325,26 +3344,38 @@ H5S_hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree,
     HDassert(coords);
 
     /* Get pointer to last span in span tree */
-    tail_span = span_tree->tail;
+    tspan_info=span_tree;
+    if(span_tree->scratch)
+        tmp_span=(H5S_hyper_span_t *)span_tree->scratch;
+    else {
+        tmp_span=span_tree->head;
+        HDassert(tmp_span);
+        span_tree->scratch=(H5S_hyper_span_info_t *)tmp_span;
+    } /* end else */
 
     /* Find last span tree which includes a portion of the coordinate */
-    tspan_info = span_tree;
-    prev_span_info = NULL;
-    while(coords[0] >= tail_span->low && coords[0] <= tail_span->high) {
+    prev_span_info=NULL;
+    while(coords[0]>=tmp_span->low && coords[0]<=tmp_span->high) {
         /* Move rank & coordinate offset down a dimension */
         rank--;
         coords++;
 
         /* Remember the span tree we are descending into */
-        prev_span_info = tspan_info;
-        tspan_info = tail_span->down;
-        HDassert(tspan_info);
-        tail_span = tspan_info->tail;
+        prev_span_info=tspan_info;
+        tspan_info=tmp_span->down;
+
+        /* Get the last span in this span's 'down' tree */
+        if(tspan_info->scratch)
+            tmp_span=(H5S_hyper_span_t *)tspan_info->scratch;
+        else {
+            tmp_span=tspan_info->head;
+            HDassert(tmp_span);
+            tspan_info->scratch=(H5S_hyper_span_info_t *)tmp_span;
+        } /* end else */
     } /* end while */
-    HDassert(rank > 0);
 
     /* Check if we made it all the way to the bottom span in the tree */
-    if(rank > 1) {
+    if(rank>1) {
         /* Before we create another span at this level in the tree, check if
          * the last span's "down tree" was equal to any other spans in this
          * list of spans in the span tree.
@@ -3353,31 +3384,31 @@ H5S_hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree,
          * previous span (if possible), or at least share their "down tree"
          * information.
          */
-        tmp2_span = tspan_info->head;
-        while(tmp2_span != tail_span) {
-            if(TRUE == H5S_hyper_cmp_spans(tmp2_span->down, tail_span->down)) {
+        tmp2_span=tspan_info->head;
+        while(tmp2_span!=tmp_span) {
+            if(H5S_hyper_cmp_spans(tmp2_span->down,tmp_span->down)==TRUE) {
                 /* Check for merging into previous span */
-                if(tmp2_span->high + 1 == tail_span->low) {
+                if(tmp2_span->high+1==tmp_span->low) {
                     /* Release last span created */
-                    H5S_hyper_free_span(tail_span);
+                    H5S_hyper_free_span(tmp_span);
 
                     /* Increase size of previous span */
                     tmp2_span->high++;
                     tmp2_span->nelem++;
 
                     /* Reset the 'tmp_span' for the rest of this block's algorithm */
-                    tail_span = tmp2_span;
+                    tmp_span=tmp2_span;
                 } /* end if */
                 /* Span is disjoint, but has the same "down tree" selection */
                 else {
                     /* Release "down tree" information */
-                    H5S_hyper_free_span_info(tail_span->down);
+                    H5S_hyper_free_span_info(tmp_span->down);
 
                     /* Point at earlier span's "down tree" */
-                    tail_span->down = tmp2_span->down;
+                    tmp_span->down=tmp2_span->down;
 
                     /* Increment reference count on shared "down tree" */
-                    tail_span->down->count++;
+                    tmp_span->down->count++;
                 } /* end else */
 
                 /* Found span to merge into, break out now */
@@ -3385,30 +3416,32 @@ H5S_hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree,
             } /* end if */
 
             /* Advance to next span to check */
-            tmp2_span = tmp2_span->next;
+            tmp2_span=tmp2_span->next;
         } /* end while */
 
         /* Make span tree for current coordinates */
-        if(NULL == (new_span = H5S_hyper_coord_to_span(rank, coords)))
+        if((new_span=H5S_hyper_coord_to_span(rank,coords))==NULL)
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
         /* Add new span tree as span */
-        HDassert(tail_span);
-        tail_span->next = new_span;
+        HDassert(tmp_span);
+        tmp_span->next=new_span;
+
+        /* Make scratch pointer point to last span in list */
         HDassert(tspan_info);
-        tspan_info->tail = new_span;
+        tspan_info->scratch=(H5S_hyper_span_info_t *)new_span;
 
         /* Set the proper 'pstride' for new span */
-        new_span->pstride = new_span->low - tail_span->low;
+        new_span->pstride=new_span->low-tmp_span->low;
     } /* end if */
     else {
         /* Does new node adjoin existing node? */
-        if(tail_span->high + 1 == coords[0]) {
-            tail_span->high++;
-            tail_span->nelem++;
+        if(tmp_span->high+1==coords[0]) {
+            tmp_span->high++;
+            tmp_span->nelem++;
 
             /* Check if this span tree should now be merged with a level higher in the tree */
-            if(prev_span_info != NULL) {
+            if(prev_span_info!=NULL) {
                 /* Before we create another span at this level in the tree, check if
                  * the last span's "down tree" was equal to any other spans in this
                  * list of spans in the span tree.
@@ -3417,33 +3450,33 @@ H5S_hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree,
                  * previous span (if possible), or at least share their "down tree"
                  * information.
                  */
-                tmp2_span = prev_span_info->head;
-                tail_span = prev_span_info->tail;
-                while(tmp2_span != tail_span) {
-                    if(TRUE == H5S_hyper_cmp_spans(tmp2_span->down, tail_span->down)) {
+                tmp2_span=prev_span_info->head;
+                tmp_span=(H5S_hyper_span_t *)prev_span_info->scratch;
+                while(tmp2_span!=tmp_span) {
+                    if(H5S_hyper_cmp_spans(tmp2_span->down,tmp_span->down)==TRUE) {
                         /* Check for merging into previous span */
-                        if(tmp2_span->high + 1 == tail_span->low) {
+                        if(tmp2_span->high+1==tmp_span->low) {
                             /* Release last span created */
-                            H5S_hyper_free_span(tail_span);
+                            H5S_hyper_free_span(tmp_span);
 
                             /* Increase size of previous span */
                             tmp2_span->high++;
                             tmp2_span->nelem++;
 
                             /* Update pointers */
-                            tmp2_span->next = NULL;
-                            prev_span_info->tail = tmp2_span;
+                            tmp2_span->next=NULL;
+                            prev_span_info->scratch=(H5S_hyper_span_info_t *)tmp2_span;
                         } /* end if */
                         /* Span is disjoint, but has the same "down tree" selection */
                         else {
                             /* Release "down tree" information */
-                            H5S_hyper_free_span_info(tail_span->down);
+                            H5S_hyper_free_span_info(tmp_span->down);
 
                             /* Point at earlier span's "down tree" */
-                            tail_span->down = tmp2_span->down;
+                            tmp_span->down=tmp2_span->down;
 
                             /* Increment reference count on shared "down tree" */
-                            tail_span->down->count++;
+                            tmp_span->down->count++;
                         } /* end else */
 
                         /* Found span to merge into, break out now */
@@ -3451,27 +3484,29 @@ H5S_hyper_add_span_element_helper(H5S_hyper_span_info_t *span_tree,
                     } /* end if */
 
                     /* Advance to next span to check */
-                    tmp2_span = tmp2_span->next;
+                    tmp2_span=tmp2_span->next;
                 } /* end while */
             } /* end if */
         } /* end if */
         else {
-            if(NULL == (new_span = H5S_hyper_new_span(coords[0], coords[0], NULL, NULL)))
+            if((new_span = H5S_hyper_new_span(coords[0],coords[0],NULL,NULL))==NULL)
                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
             /* Add new span tree as span */
-            HDassert(tail_span);
-            tail_span->next = new_span;
-            tspan_info->tail = new_span;
+            HDassert(tmp_span);
+            tmp_span->next=new_span;
+
+            /* Make scratch pointer point to last span in list */
+            tspan_info->scratch=(H5S_hyper_span_info_t *)new_span;
 
             /* Set the proper 'pstride' for new span */
-            new_span->pstride = new_span->low - tail_span->low;
+            new_span->pstride=new_span->low-tmp_span->low;
         } /* end else */
     } /* end else */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_add_span_element_helper() */
+}   /* H5S_hyper_add_span_element_helper() */
 
 
 /*--------------------------------------------------------------------------
@@ -3495,7 +3530,7 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 herr_t
-H5S_hyper_add_span_element(H5S_t *space, unsigned rank, const hsize_t *coords)
+H5S_hyper_add_span_element(H5S_t *space, unsigned rank, hsize_t *coords)
 {
     H5S_hyper_span_info_t *head = NULL;    /* Pointer to new head of span tree */
     herr_t      ret_value = SUCCEED;       /* Return value */
@@ -3505,24 +3540,23 @@ H5S_hyper_add_span_element(H5S_t *space, unsigned rank, const hsize_t *coords)
     HDassert(space);
     HDassert(rank > 0);
     HDassert(coords);
-    HDassert(space->extent.rank == rank);
 
     /* Check if this is the first element in the selection */
     if(NULL == space->select.sel_info.hslab) {
         /* Allocate a span info node */
-        if(NULL == (head = H5FL_CALLOC(H5S_hyper_span_info_t)))
+        if(NULL == (head = H5FL_MALLOC(H5S_hyper_span_info_t)))
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
         /* Set the reference count */
         head->count = 1;
 
+        /* Reset the scratch pad space */
+        head->scratch = 0;
+
         /* Build span tree for this coordinate */
         if(NULL == (head->head = H5S_hyper_coord_to_span(rank, coords)))
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
-        /* Update the tail pointer of this newly created span in dimension "rank" */
-        head->tail = head->head;
-
         /* Allocate selection info */
         if(NULL == (space->select.sel_info.hslab = H5FL_MALLOC(H5S_hyper_sel_t)))
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab info")
@@ -3534,7 +3568,7 @@ H5S_hyper_add_span_element(H5S_t *space, unsigned rank, const hsize_t *coords)
         space->select.type = H5S_sel_hyper;
 
         /* Reset "regular" hyperslab flag */
-        space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO;
+        space->select.sel_info.hslab->diminfo_valid = FALSE;
 
         /* Set # of elements in selection */
         space->select.num_elem = 1;
@@ -3553,7 +3587,7 @@ done:
             H5S_hyper_free_span_info(head);
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_add_span_element() */
+}   /* H5S_hyper_add_span_element() */
 
 
 /*--------------------------------------------------------------------------
@@ -3587,7 +3621,7 @@ H5S_hyper_reset_scratch(H5S_t *space)
         H5S_hyper_span_scratch(space->select.sel_info.hslab->span_lst, NULL);
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5S_hyper_reset_scratch() */
+}   /* H5S_hyper_reset_scratch() */
 
 
 /*--------------------------------------------------------------------------
@@ -3657,7 +3691,126 @@ H5S_hyper_convert(H5S_t *space)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_convert() */
+}   /* H5S_hyper_convert() */
+
+#ifdef LATER
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_intersect_helper
+ PURPOSE
+    Helper routine to detect intersections in span trees
+ USAGE
+    htri_t H5S_hyper_intersect_helper(spans1, spans2)
+        H5S_hyper_span_info_t *spans1;     IN: First span tree to operate with
+        H5S_hyper_span_info_t *spans2;     IN: Second span tree to operate with
+ RETURNS
+    Non-negative on success, negative on failure
+ DESCRIPTION
+    Quickly detect intersections between two span trees
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+static htri_t
+H5S_hyper_intersect_helper (H5S_hyper_span_info_t *spans1, H5S_hyper_span_info_t *spans2)
+{
+    H5S_hyper_span_t *curr1;    /* Pointer to current span in 1st span tree */
+    H5S_hyper_span_t *curr2;    /* Pointer to current span in 2nd span tree */
+    htri_t status;              /* Status from recursive call */
+    htri_t ret_value=FALSE;     /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT
+
+    /* Sanity check */
+    HDassert((spans1 && spans2) || (spans1 == NULL && spans2 == NULL));
+
+    /* "NULL" span trees compare as overlapping */
+    if(spans1==NULL && spans2==NULL)
+        HGOTO_DONE(TRUE);
+
+    /* Get the span lists for each span in this tree */
+    curr1=spans1->head;
+    curr2=spans2->head;
+
+    /* Iterate over the spans in each tree */
+    while(curr1!=NULL && curr2!=NULL) {
+        /* Check for 1st span entirely before 2nd span */
+        if(curr1->high<curr2->low)
+            curr1=curr1->next;
+        /* Check for 2nd span entirely before 1st span */
+        else if(curr2->high<curr1->low)
+            curr2=curr2->next;
+        /* Spans must overlap */
+        else {
+            /* Recursively check spans in next dimension down */
+            if((status=H5S_hyper_intersect_helper(curr1->down,curr2->down))<0)
+                HGOTO_ERROR(H5E_DATASPACE, H5E_BADSELECT, FAIL, "can't perform hyperslab intersection check")
+
+            /* If there is a span intersection in the down dimensions, the span trees overlap */
+            if(status==TRUE)
+                HGOTO_DONE(TRUE);
+
+            /* No intersection in down dimensions, advance to next span */
+            if(curr1->high<curr2->high)
+                curr1=curr1->next;
+            else
+                curr2=curr2->next;
+        } /* end else */
+    } /* end while */
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+}   /* H5S_hyper_intersect_helper() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_intersect
+ PURPOSE
+    Detect intersections in span trees
+ USAGE
+    htri_t H5S_hyper_intersect(space1, space2)
+        H5S_t *space1;     IN: First dataspace to operate on span tree
+        H5S_t *space2;     IN: Second dataspace to operate on span tree
+ RETURNS
+    Non-negative on success, negative on failure
+ DESCRIPTION
+    Quickly detect intersections between two span trees
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+htri_t
+H5S_hyper_intersect (H5S_t *space1, H5S_t *space2)
+{
+    htri_t ret_value=FAIL;      /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT
+
+    /* Sanity check */
+    HDassert(space1);
+    HDassert(space2);
+
+    /* Check that the space selections both have span trees */
+    if(space1->select.sel_info.hslab->span_lst==NULL ||
+            space2->select.sel_info.hslab->span_lst==NULL)
+        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.rank!=space2->extent.rank)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "dataspace ranks don't match")
+
+    /* Perform the span-by-span intersection check */
+    if((ret_value=H5S_hyper_intersect_helper(space1->select.sel_info.hslab->span_lst,space2->select.sel_info.hslab->span_lst))<0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_BADSELECT, FAIL, "can't perform hyperslab intersection check")
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+}   /* H5S_hyper_intersect() */
+#endif /* LATER */
 
 
 /*--------------------------------------------------------------------------
@@ -3681,8 +3834,7 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static htri_t
-H5S_hyper_intersect_block_helper(const H5S_hyper_span_info_t *spans,
-    const hsize_t *start, const hsize_t *end)
+H5S_hyper_intersect_block_helper (const H5S_hyper_span_info_t *spans, hsize_t *start, hsize_t *end)
 {
     H5S_hyper_span_t *curr;     /* Pointer to current span in 1st span tree */
     htri_t status;              /* Status from recursive call */
@@ -3728,7 +3880,7 @@ H5S_hyper_intersect_block_helper(const H5S_hyper_span_info_t *spans,
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_intersect_block_helper() */
+}   /* H5S_hyper_intersect_block_helper() */
 
 
 /*--------------------------------------------------------------------------
@@ -3751,9 +3903,9 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 htri_t
-H5S_hyper_intersect_block(H5S_t *space, const hsize_t *start, const hsize_t *end)
+H5S_hyper_intersect_block (H5S_t *space, hsize_t *start, hsize_t *end)
 {
-    htri_t ret_value = FAIL;      /* Return value */
+    htri_t ret_value=FAIL;      /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -3764,30 +3916,30 @@ H5S_hyper_intersect_block(H5S_t *space, const hsize_t *start, const hsize_t *end
 
     /* Check for 'all' selection, instead of a hyperslab selection */
     /* (Technically, this shouldn't be in the "hyperslab" routines...) */
-    if(H5S_GET_SELECT_TYPE(space) == H5S_SEL_ALL)
+    if(H5S_GET_SELECT_TYPE(space)==H5S_SEL_ALL)
         HGOTO_DONE(TRUE);
 
     /* Check that the space selection has a span tree */
-    if(space->select.sel_info.hslab->span_lst == NULL)
-        if(H5S_hyper_generate_spans(space) < 0)
+    if(space->select.sel_info.hslab->span_lst==NULL)
+        if(H5S_hyper_generate_spans(space)<0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "dataspace does not have span tree")
 
     /* Perform the span-by-span intersection check */
-    if((ret_value = H5S_hyper_intersect_block_helper(space->select.sel_info.hslab->span_lst, start, end)) < 0)
+    if((ret_value=H5S_hyper_intersect_block_helper(space->select.sel_info.hslab->span_lst,start,end))<0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_BADSELECT, FAIL, "can't perform hyperslab intersection check")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_intersect_block() */
+}   /* H5S_hyper_intersect_block() */
 
 
 /*--------------------------------------------------------------------------
  NAME
-    H5S_hyper_adjust_u_helper
+    H5S_hyper_adjust_helper_u
  PURPOSE
     Helper routine to adjust offsets in span trees
  USAGE
-    herr_t H5S_hyper_adjust_u_helper(spans, offset)
+    herr_t H5S_hyper_adjust_helper_u(spans, offset)
         H5S_hyper_span_info_t *spans;   IN: Span tree to operate with
         const hsize_t *offset;         IN: Offset to subtract
  RETURNS
@@ -3800,7 +3952,7 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S_hyper_adjust_u_helper(H5S_hyper_span_info_t *spans, const hsize_t *offset)
+H5S_hyper_adjust_helper_u (H5S_hyper_span_info_t *spans, const hsize_t *offset)
 {
     H5S_hyper_span_t *span;     /* Pointer to current span in span tree */
 
@@ -3827,7 +3979,7 @@ H5S_hyper_adjust_u_helper(H5S_hyper_span_info_t *spans, const hsize_t *offset)
 
             /* Recursively adjust spans in next dimension down */
             if(span->down!=NULL)
-                H5S_hyper_adjust_u_helper(span->down,offset+1);
+                H5S_hyper_adjust_helper_u(span->down,offset+1);
 
             /* Advance to next span in this dimension */
             span=span->next;
@@ -3835,7 +3987,7 @@ H5S_hyper_adjust_u_helper(H5S_hyper_span_info_t *spans, const hsize_t *offset)
     } /* end if */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5S_hyper_adjust_u_helper() */
+}   /* H5S_hyper_adjust_helper_u() */
 
 
 /*--------------------------------------------------------------------------
@@ -3859,9 +4011,8 @@ H5S_hyper_adjust_u_helper(H5S_hyper_span_info_t *spans, const hsize_t *offset)
 static herr_t
 H5S_hyper_adjust_u(H5S_t *space, const hsize_t *offset)
 {
-    hbool_t update_bound = FALSE;       /* Indicate whether to update bound */
     unsigned u;                         /* Local index variable */
-    herr_t ret_value = SUCCEED;         /* Return value */
+    herr_t      ret_value=SUCCEED;       /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -3869,39 +4020,25 @@ H5S_hyper_adjust_u(H5S_t *space, const hsize_t *offset)
     HDassert(offset);
 
     /* Subtract the offset from the "regular" coordinates, if they exist */
-    /* (No need to rebuild the dimension info yet -QAK) */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
-        for(u = 0; u < space->extent.rank; u++) {
-            HDassert(space->select.sel_info.hslab->opt_diminfo[u].start >= offset[u]);
-            space->select.sel_info.hslab->opt_diminfo[u].start -= offset[u];
+    if(space->select.sel_info.hslab->diminfo_valid) {
+        for(u=0; u<space->extent.rank; u++) {
+            HDassert(space->select.sel_info.hslab->opt_diminfo[u].start>=offset[u]);
+            space->select.sel_info.hslab->opt_diminfo[u].start-=offset[u];
         } /* end for */
-
-        update_bound = TRUE;
     } /* end if */
 
     /* Subtract the offset from the span tree coordinates, if they exist */
     if(space->select.sel_info.hslab->span_lst) {
-        if(H5S_hyper_adjust_u_helper(space->select.sel_info.hslab->span_lst, offset) < 0)
+        if(H5S_hyper_adjust_helper_u(space->select.sel_info.hslab->span_lst,offset)<0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_BADSELECT, FAIL, "can't perform hyperslab offset adjustment")
 
         /* Reset the scratch pointers for the next routine which needs them */
         H5S_hyper_span_scratch(space->select.sel_info.hslab->span_lst, NULL);
-
-        update_bound = TRUE;
-    } /* end if */
-
-    if(update_bound) {
-        /* Update the bound box of this hyperslab */
-        for(u = 0; u < space->extent.rank; u++) {
-            HDassert(space->select.low_bounds[u] >= offset[u]);
-            space->select.low_bounds[u] -= offset[u];
-            space->select.high_bounds[u] -= offset[u];
-        } /* end for */
     } /* end if */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_adjust_u() */
+}   /* H5S_hyper_adjust_u() */
 
 
 /*-------------------------------------------------------------------------
@@ -3930,8 +4067,7 @@ H5S_hyper_project_scalar(const H5S_t *space, hsize_t *offset)
     HDassert(offset);
 
     /* Check for a "regular" hyperslab selection */
-    /* (No need to rebuild the dimension info yet -QAK) */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+    if(space->select.sel_info.hslab->diminfo_valid) {
         const H5S_hyper_dim_t *diminfo = space->select.sel_info.hslab->opt_diminfo; /* Alias for dataspace's diminfo information */
         unsigned u;                 /* Counter */
 
@@ -3966,11 +4102,11 @@ H5S_hyper_project_scalar(const H5S_t *space, hsize_t *offset)
     } /* end else */
 
     /* Calculate offset of selection in projected buffer */
-    *offset = H5VM_array_offset(space->extent.rank, space->extent.size, block);
+    *offset = H5VM_array_offset(space->extent.rank, space->extent.size, block); 
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_project_scalar() */
+}   /* H5S_hyper_project_scalar() */
 
 
 /*-------------------------------------------------------------------------
@@ -3991,7 +4127,6 @@ H5S_hyper_project_simple_lower(const H5S_t *base_space, H5S_t *new_space)
 {
     H5S_hyper_span_info_t *down;        /* Pointer to list of spans */
     unsigned curr_dim;                  /* Current dimension being operated on */
-    unsigned u;                         /* Local index variable */
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
@@ -4013,18 +4148,12 @@ H5S_hyper_project_simple_lower(const H5S_t *base_space, H5S_t *new_space)
     } /* end while */
     HDassert(down);
 
-    /* Update the bounding box */
-    for(u = 0; u < new_space->extent.rank; u++) {
-        new_space->select.low_bounds[u] = base_space->select.low_bounds[u + curr_dim];
-        new_space->select.high_bounds[u] = base_space->select.high_bounds[u + curr_dim];
-    } /* end for */
-
     /* Share the underlying hyperslab span information */
     new_space->select.sel_info.hslab->span_lst = down;
     new_space->select.sel_info.hslab->span_lst->count++;
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5S_hyper_project_simple_lower() */
+}   /* H5S_hyper_project_simple_lower() */
 
 
 /*-------------------------------------------------------------------------
@@ -4045,7 +4174,6 @@ H5S_hyper_project_simple_higher(const H5S_t *base_space, H5S_t *new_space)
 {
     H5S_hyper_span_t *prev_span = NULL; /* Pointer to previous list of spans */
     unsigned curr_dim;                  /* Current dimension being operated on */
-    unsigned u;                         /* Local index variable */
     herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
@@ -4063,7 +4191,7 @@ H5S_hyper_project_simple_higher(const H5S_t *base_space, H5S_t *new_space)
         H5S_hyper_span_t *new_span;     /* Temporary hyperslab span */
 
         /* Allocate a new span_info node */
-        if(NULL == (new_span_info = H5FL_CALLOC(H5S_hyper_span_info_t))) {
+        if(NULL == (new_span_info = H5FL_MALLOC(H5S_hyper_span_info_t))) {
             if(prev_span)
                 if(H5S_hyper_free_span(prev_span) < 0)
                     HERROR(H5E_DATASPACE, H5E_CANTFREE, "can't free hyperslab span");
@@ -4075,7 +4203,7 @@ H5S_hyper_project_simple_higher(const H5S_t *base_space, H5S_t *new_space)
             prev_span->down = new_span_info;
 
         /* Allocate a new node */
-        if(NULL == (new_span = H5S_hyper_new_span((hsize_t)0, (hsize_t)0, NULL, NULL))) {
+        if(NULL == (new_span = H5S_hyper_new_span(0, 0, NULL, NULL))) {
             HDassert(new_span_info);
             if(!prev_span)
                 (void)H5FL_FREE(H5S_hyper_span_info_t, new_span_info);
@@ -4084,8 +4212,8 @@ H5S_hyper_project_simple_higher(const H5S_t *base_space, H5S_t *new_space)
 
         /* Set the span_info information */
         new_span_info->count = 1;
+        new_span_info->scratch = NULL;
         new_span_info->head = new_span;
-        new_span_info->tail = new_span;
 
         /* Attach to new space, if top span info */
         if(NULL == new_space->select.sel_info.hslab->span_lst)
@@ -4100,16 +4228,6 @@ H5S_hyper_project_simple_higher(const H5S_t *base_space, H5S_t *new_space)
     HDassert(new_space->select.sel_info.hslab->span_lst);
     HDassert(prev_span);
 
-    /* Update the bounding box */
-    for(u = 0; u < curr_dim; u++) {
-        new_space->select.low_bounds[u] = 0;
-        new_space->select.high_bounds[u] = 0;
-    } /* end for */
-    for(; u < new_space->extent.rank; u++) {
-        new_space->select.low_bounds[u] = base_space->select.low_bounds[u - curr_dim];
-        new_space->select.high_bounds[u] = base_space->select.high_bounds[u - curr_dim];
-    } /* end for */
-
     /* Share the underlying hyperslab span information */
     prev_span->down = base_space->select.sel_info.hslab->span_lst;
     prev_span->down->count++;
@@ -4125,7 +4243,7 @@ done:
     } /* end if */
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_project_simple_higher() */
+}   /* H5S_hyper_project_simple_higher() */
 
 
 /*-------------------------------------------------------------------------
@@ -4162,22 +4280,21 @@ H5S_hyper_project_simple(const H5S_t *base_space, H5S_t *new_space, hsize_t *off
         HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab info")
 
     /* Check for a "regular" hyperslab selection */
-    /* (No need to rebuild the dimension info yet -QAK) */
-    if(base_space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+    if(base_space->select.sel_info.hslab->diminfo_valid) {
         unsigned base_space_dim;    /* Current dimension in the base dataspace */
         unsigned new_space_dim;     /* Current dimension in the new dataspace */
-        unsigned u;                 /* Local index variable */
 
         /* Check if the new space's rank is < or > base space's rank */
         if(new_space->extent.rank < base_space->extent.rank) {
             const H5S_hyper_dim_t *opt_diminfo = base_space->select.sel_info.hslab->opt_diminfo; /* Alias for dataspace's diminfo information */
             hsize_t block[H5S_MAX_RANK];     /* Block selected in base dataspace */
+            unsigned u;         /* Local index variable */
 
             /* Compute the offset for the down-projection */
             HDmemset(block, 0, sizeof(block));
             for(u = 0; u < (base_space->extent.rank - new_space->extent.rank); u++)
                 block[u] = opt_diminfo[u].start;
-            *offset = H5VM_array_offset(base_space->extent.rank, base_space->extent.size, block);
+            *offset = H5VM_array_offset(base_space->extent.rank, base_space->extent.size, block); 
 
             /* Set the correct dimensions for the base & new spaces */
             base_space_dim = base_space->extent.rank - new_space->extent.rank;
@@ -4208,22 +4325,22 @@ H5S_hyper_project_simple(const H5S_t *base_space, H5S_t *new_space, hsize_t *off
 
         /* Copy the diminfo */
         while(base_space_dim < base_space->extent.rank) {
-            new_space->select.sel_info.hslab->app_diminfo[new_space_dim].start =
+            new_space->select.sel_info.hslab->app_diminfo[new_space_dim].start = 
                     base_space->select.sel_info.hslab->app_diminfo[base_space_dim].start;
-            new_space->select.sel_info.hslab->app_diminfo[new_space_dim].stride =
+            new_space->select.sel_info.hslab->app_diminfo[new_space_dim].stride = 
                     base_space->select.sel_info.hslab->app_diminfo[base_space_dim].stride;
-            new_space->select.sel_info.hslab->app_diminfo[new_space_dim].count =
+            new_space->select.sel_info.hslab->app_diminfo[new_space_dim].count = 
                     base_space->select.sel_info.hslab->app_diminfo[base_space_dim].count;
-            new_space->select.sel_info.hslab->app_diminfo[new_space_dim].block =
+            new_space->select.sel_info.hslab->app_diminfo[new_space_dim].block = 
                     base_space->select.sel_info.hslab->app_diminfo[base_space_dim].block;
 
-            new_space->select.sel_info.hslab->opt_diminfo[new_space_dim].start =
+            new_space->select.sel_info.hslab->opt_diminfo[new_space_dim].start = 
                     base_space->select.sel_info.hslab->opt_diminfo[base_space_dim].start;
             new_space->select.sel_info.hslab->opt_diminfo[new_space_dim].stride =
                     base_space->select.sel_info.hslab->opt_diminfo[base_space_dim].stride;
-            new_space->select.sel_info.hslab->opt_diminfo[new_space_dim].count =
+            new_space->select.sel_info.hslab->opt_diminfo[new_space_dim].count = 
                     base_space->select.sel_info.hslab->opt_diminfo[base_space_dim].count;
-            new_space->select.sel_info.hslab->opt_diminfo[new_space_dim].block =
+            new_space->select.sel_info.hslab->opt_diminfo[new_space_dim].block = 
                     base_space->select.sel_info.hslab->opt_diminfo[base_space_dim].block;
 
             /* Advance to next dimensions */
@@ -4231,14 +4348,8 @@ H5S_hyper_project_simple(const H5S_t *base_space, H5S_t *new_space, hsize_t *off
             new_space_dim++;
         } /* end for */
 
-        /* Update the bounding box */
-        for(u = 0; u < new_space->extent.rank; u++) {
-            new_space->select.low_bounds[u] = new_space->select.sel_info.hslab->opt_diminfo[u].start;
-            new_space->select.high_bounds[u] = new_space->select.low_bounds[u] + new_space->select.sel_info.hslab->opt_diminfo[u].stride * (new_space->select.sel_info.hslab->opt_diminfo[u].count - 1) + (new_space->select.sel_info.hslab->opt_diminfo[u].block - 1);
-        } /* end for */
-
         /* Indicate that the dimension information is valid */
-        new_space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_YES;
+        new_space->select.sel_info.hslab->diminfo_valid = TRUE;
 
         /* Indicate that there's no slab information */
         new_space->select.sel_info.hslab->span_lst = NULL;
@@ -4266,7 +4377,7 @@ H5S_hyper_project_simple(const H5S_t *base_space, H5S_t *new_space, hsize_t *off
             } /* end while */
 
             /* Compute the offset for the down-projection */
-            *offset = H5VM_array_offset(base_space->extent.rank, base_space->extent.size, block);
+            *offset = H5VM_array_offset(base_space->extent.rank, base_space->extent.size, block); 
 
             /* Project the base space's selection down in less dimensions */
             if(H5S_hyper_project_simple_lower(base_space, new_space) < 0)
@@ -4278,13 +4389,13 @@ H5S_hyper_project_simple(const H5S_t *base_space, H5S_t *new_space, hsize_t *off
             /* The offset is zero when projected into higher dimensions */
             *offset = 0;
 
-            /* Project the base space's selection down in more dimensions */
+            /* Project the base space's selection down in less dimensions */
             if(H5S_hyper_project_simple_higher(base_space, new_space) < 0)
                 HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't project hyperslab selection into less dimensions")
         } /* end else */
 
-        /* Copy the status of the dimension information */
-        new_space->select.sel_info.hslab->diminfo_valid = base_space->select.sel_info.hslab->diminfo_valid;
+        /* Indicate that the dimension information is not valid */
+        new_space->select.sel_info.hslab->diminfo_valid = FALSE;
     } /* end else */
 
     /* Number of elements selected will be the same */
@@ -4295,16 +4406,16 @@ H5S_hyper_project_simple(const H5S_t *base_space, H5S_t *new_space, hsize_t *off
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_project_simple() */
+}   /* H5S_hyper_project_simple() */
 
 
 /*--------------------------------------------------------------------------
  NAME
-    H5S_hyper_adjust_s_helper
+    H5S_hyper_adjust_helper_s
  PURPOSE
     Helper routine to adjust offsets in span trees
  USAGE
-    herr_t H5S_hyper_adjust_s_helper(spans, offset)
+    herr_t H5S_hyper_adjust_helper_s(spans, offset)
         H5S_hyper_span_info_t *spans;   IN: Span tree to operate with
         const hssize_t *offset;         IN: Offset to subtract
  RETURNS
@@ -4317,7 +4428,7 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S_hyper_adjust_s_helper(H5S_hyper_span_info_t *spans, const hssize_t *offset)
+H5S_hyper_adjust_helper_s(H5S_hyper_span_info_t *spans, const hssize_t *offset)
 {
     H5S_hyper_span_t *span;     /* Pointer to current span in span tree */
 
@@ -4344,7 +4455,7 @@ H5S_hyper_adjust_s_helper(H5S_hyper_span_info_t *spans, const hssize_t *offset)
 
             /* Recursively adjust spans in next dimension down */
             if(span->down != NULL)
-                H5S_hyper_adjust_s_helper(span->down, offset + 1);
+                H5S_hyper_adjust_helper_s(span->down, offset + 1);
 
             /* Advance to next span in this dimension */
             span = span->next;
@@ -4352,7 +4463,7 @@ H5S_hyper_adjust_s_helper(H5S_hyper_span_info_t *spans, const hssize_t *offset)
     } /* end if */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5S_hyper_adjust_s_helper() */
+}   /* H5S_hyper_adjust_helper_s() */
 
 
 /*--------------------------------------------------------------------------
@@ -4376,7 +4487,6 @@ H5S_hyper_adjust_s_helper(H5S_hyper_span_info_t *spans, const hssize_t *offset)
 herr_t
 H5S_hyper_adjust_s(H5S_t *space, const hssize_t *offset)
 {
-    hbool_t update_bound = FALSE;       /* Indicate whether to update bound */
     unsigned u;                         /* Local index variable */
     herr_t      ret_value = SUCCEED;    /* Return value */
 
@@ -4386,42 +4496,25 @@ H5S_hyper_adjust_s(H5S_t *space, const hssize_t *offset)
     HDassert(offset);
 
     /* Subtract the offset from the "regular" coordinates, if they exist */
-    /* (No need to rebuild the dimension info yet -QAK) */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+    if(space->select.sel_info.hslab->diminfo_valid) {
         for(u = 0; u < space->extent.rank; u++) {
             HDassert((hssize_t)space->select.sel_info.hslab->opt_diminfo[u].start >= offset[u]);
             space->select.sel_info.hslab->opt_diminfo[u].start = (hsize_t)((hssize_t)space->select.sel_info.hslab->opt_diminfo[u].start - offset[u]);
         } /* end for */
-
-        update_bound = TRUE;
     } /* end if */
 
     /* Subtract the offset from the span tree coordinates, if they exist */
     if(space->select.sel_info.hslab->span_lst) {
-        if(H5S_hyper_adjust_s_helper(space->select.sel_info.hslab->span_lst, offset) < 0)
+        if(H5S_hyper_adjust_helper_s(space->select.sel_info.hslab->span_lst, offset) < 0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_BADSELECT, FAIL, "can't perform hyperslab offset adjustment")
 
         /* Reset the scratch pointers for the next routine which needs them */
         H5S_hyper_span_scratch(space->select.sel_info.hslab->span_lst, NULL);
-
-        update_bound = TRUE;
-    } /* end if */
-
-    if(update_bound) {
-        /* Update the bound box of this hyperslab */
-        for(u = 0; u < space->extent.rank; u++) {
-            hssize_t tmp = (hssize_t)space->select.low_bounds[u];
-
-            HDassert(tmp >= offset[u]);
-            space->select.low_bounds[u] = (hsize_t)(tmp - offset[u]);
-            tmp = (hssize_t)space->select.high_bounds[u];
-            space->select.high_bounds[u] = (hsize_t)(tmp - offset[u]);
-        } /* end for */
     } /* end if */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_adjust_s() */
+}   /* H5S_hyper_adjust_s() */
 
 
 /*--------------------------------------------------------------------------
@@ -4476,7 +4569,7 @@ H5S_hyper_normalize_offset(H5S_t *space, hssize_t *old_offset)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_normalize_offset() */
+}   /* H5S_hyper_normalize_offset() */
 
 
 /*--------------------------------------------------------------------------
@@ -4519,7 +4612,7 @@ H5S_hyper_denormalize_offset(H5S_t *space, const hssize_t *old_offset)
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_denormalize_offset() */
+}   /* H5S_hyper_denormalize_offset() */
 
 
 /*--------------------------------------------------------------------------
@@ -4545,8 +4638,7 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S_hyper_append_span(H5S_hyper_span_t **prev_span, H5S_hyper_span_info_t **span_tree,
-    hsize_t low, hsize_t high, H5S_hyper_span_info_t *down, H5S_hyper_span_t *next)
+H5S_hyper_append_span (H5S_hyper_span_t **prev_span, H5S_hyper_span_info_t ** span_tree, hsize_t low, hsize_t high, H5S_hyper_span_info_t *down, H5S_hyper_span_t *next)
 {
     H5S_hyper_span_t *new_span = NULL;
     herr_t      ret_value = SUCCEED;       /* Return value */
@@ -4557,51 +4649,51 @@ H5S_hyper_append_span(H5S_hyper_span_t **prev_span, H5S_hyper_span_info_t **span
     HDassert(span_tree);
 
     /* Check for adding first node to merged spans */
-    if(*prev_span == NULL) {
+    if(*prev_span==NULL) {
         /* Allocate new span node to append to list */
-        if(NULL == (new_span = H5S_hyper_new_span(low, high, down, next)))
+        if((new_span = H5S_hyper_new_span(low,high,down,next))==NULL)
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
         /* Make first node in span list */
 
         /* Check that we haven't already allocated a span tree */
-        HDassert(*span_tree == NULL);
+        HDassert(*span_tree==NULL);
 
         /* Allocate a new span_info node */
-        if(NULL == (*span_tree = H5FL_CALLOC(H5S_hyper_span_info_t)))
+        if((*span_tree = H5FL_MALLOC(H5S_hyper_span_info_t))==NULL)
             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
         /* Set the span tree's basic information */
-        (*span_tree)->count = 1;
-        (*span_tree)->head = new_span;
-        (*span_tree)->tail = new_span;
+        (*span_tree)->count=1;
+        (*span_tree)->scratch=NULL;
+        (*span_tree)->head=new_span;
 
         /* Update previous merged span */
-        *prev_span = new_span;
+        *prev_span=new_span;
     } /* end if */
     /* Merge or append to existing merged spans list */
     else {
         /* Check if span can just extend the previous merged span */
-        if((((*prev_span)->high + 1) == low) &&
-                TRUE == H5S_hyper_cmp_spans(down, (*prev_span)->down)) {
+        if((((*prev_span)->high+1)==low) &&
+                H5S_hyper_cmp_spans(down,(*prev_span)->down)==TRUE) {
             /* Extend previous merged span to include new high bound */
-            (*prev_span)->high = high;
-            (*prev_span)->nelem += (high - low) + 1;
+            (*prev_span)->high=high;
+            (*prev_span)->nelem+=(high-low)+1;
         } /* end if */
         else {
             /* Allocate new span node to append to list */
-            if(NULL == (new_span = H5S_hyper_new_span(low, high, down, next)))
+            if((new_span = H5S_hyper_new_span(low,high,down,next))==NULL)
                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
             /* Check if there is actually a down span */
             if(new_span->down) {
                 /* Check if the down spans for the new span node are the same as the previous span node */
-                if(TRUE == H5S_hyper_cmp_spans(new_span->down, (*prev_span)->down)) {
+                if(H5S_hyper_cmp_spans(new_span->down,(*prev_span)->down)==TRUE) {
                     /* Release the down span for the new node */
                     H5S_hyper_free_span_info(new_span->down);
 
                     /* Point the new node's down span at the previous node's down span */
-                    new_span->down = (*prev_span)->down;
+                    new_span->down=(*prev_span)->down;
 
                     /* Increment the reference count to the shared down span */
                     new_span->down->count++;
@@ -4609,23 +4701,23 @@ H5S_hyper_append_span(H5S_hyper_span_t **prev_span, H5S_hyper_span_info_t **span
             } /* end if */
 
             /* Indicate elements from previous span */
-            new_span->pstride = low - (*prev_span)->low;
+            new_span->pstride=low-(*prev_span)->low;
 
             /* Append to end of merged spans list */
-            (*prev_span)->next = new_span;
-            *prev_span = new_span;
-
-            (*span_tree)->tail = new_span;
+            (*prev_span)->next=new_span;
+            *prev_span=new_span;
         } /* end else */
     } /* end else */
 
 done:
-    if(ret_value < 0)
-        if(new_span && H5S_hyper_free_span(new_span) < 0)
-            HDONE_ERROR(H5E_DATASPACE, H5E_CANTFREE, FAIL, "failed to release new hyperslab span")
+    if(ret_value < 0) {
+        if(new_span)
+            if(H5S_hyper_free_span(new_span) < 0)
+                HDONE_ERROR(H5E_DATASPACE, H5E_CANTFREE, FAIL, "failed to release new hyperslab span")
+    } /* end if */
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_append_span() */
+}   /* H5S_hyper_append_span() */
 
 
 /*--------------------------------------------------------------------------
@@ -4634,24 +4726,9 @@ done:
  PURPOSE
     Clip a new span tree against the current spans in the hyperslab selection
  USAGE
-    herr_t H5S_hyper_clip_spans(span_a, span_b, selector, cur_dim, dim_size,
-                                span_a_b_bounds[4], all_clips_bound,
-                                a_not_b, a_and_b, b_not_a)
+    herr_t H5S_hyper_clip_spans(span_a, span_b, a_not_b, a_and_b, b_not_a)
         H5S_hyper_span_t *a_spans;    IN: Span tree 'a' to clip with.
         H5S_hyper_span_t *b_spans;    IN: Span tree 'b' to clip with.
-        unsigned int selector;        IN: The parameter deciding which output is needed
-                                          (only considering the last three bits ABC:
-                                           If A is set, then a_not_b is needed;
-                                           If B is set, then a_and_b is needed;
-                                           If C is set, then b_not_a is needed;
-                                           )
-        unsigned int cur_dim;         IN: The dimension in which this clip operation
-                                          is performed.
-        unsigned int dim_size;        IN: The dimension size.
-        const hsize_t *span_a_b_bounds[4];  IN: The bound box of span a and span b.
-        hsize_t *all_clips_bounds;    OUT: The array containing the bounds box
-                                              of all three clipped span tree in the order
-                                              a_not_b, a_and_b and b_not_a.
         H5S_hyper_span_t **a_not_b;  OUT: Span tree of 'a' hyperslab spans which
                                             doesn't overlap with 'b' hyperslab
                                             spans.
@@ -4674,29 +4751,21 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S_hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_spans,
-    unsigned int selector, unsigned cur_dim, unsigned dim_size,
-    const hsize_t *span_a_b_bounds[4], hsize_t *all_clips_bounds,
+H5S_hyper_clip_spans (H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_spans,
     H5S_hyper_span_info_t **a_not_b, H5S_hyper_span_info_t **a_and_b,
     H5S_hyper_span_info_t **b_not_a)
 {
-    H5S_hyper_span_t *span_a;       /* Pointer to a node in span tree 'a' */
-    H5S_hyper_span_t *span_b;       /* Pointer to a node in span tree 'b' */
-    const hsize_t *span_a_low_bounds;   /* The low bound array for span a */
-    const hsize_t *span_a_high_bounds;  /* The high bound array for span a */
-    const hsize_t *span_b_low_bounds;   /* The low bound array for span b */
-    const hsize_t *span_b_high_bounds;  /* The high bound array for span b */
-    hsize_t *a_not_b_low_bounds;    /* The low bound array for a_not_b */
-    hsize_t *a_not_b_high_bounds;   /* The high bound array for a_not_b */
-    hsize_t *a_and_b_low_bounds;    /* The low bound array for a_and_b */
-    hsize_t *a_and_b_high_bounds;   /* The high bound array for a_and_b */
-    hsize_t *b_not_a_low_bounds;    /* The low bound array for b_not_a */
-    hsize_t *b_not_a_high_bounds;   /* The high bound array for b_not_a */
-    hbool_t need_a_not_b = FALSE;   /* Whether to generate a_not_b list */
-    hbool_t need_a_and_b = FALSE;   /* Whether to generate a_and_b list */
-    hbool_t need_b_not_a = FALSE;   /* Whether to generate b_not_a list */
-    unsigned u;                     /* Local index variable */
-    herr_t ret_value = SUCCEED;     /* Return value */
+    H5S_hyper_span_t *span_a;   /* Pointer to a node in span tree 'a' */
+    H5S_hyper_span_t *span_b;   /* Pointer to a node in span tree 'b' */
+    H5S_hyper_span_t *tmp_span; /* Temporary pointer to new span */
+    H5S_hyper_span_t *last_a_not_b;   /* Pointer to previous node in span tree 'a_not_b' */
+    H5S_hyper_span_t *last_a_and_b;   /* Pointer to previous node in span tree 'a_and_b' */
+    H5S_hyper_span_t *last_b_not_a;   /* Pointer to previous node in span tree 'b_not_a' */
+    H5S_hyper_span_info_t *down_a_not_b; /* Temporary pointer to a_not_b span tree of down spans for overlapping nodes */
+    H5S_hyper_span_info_t *down_a_and_b; /* Temporary pointer to a_and_b span tree of down spans for overlapping nodes */
+    H5S_hyper_span_info_t *down_b_not_a; /* Temporary pointer to b_and_a span tree of down spans for overlapping nodes */
+    unsigned recover_a, recover_b;         /* Flags to indicate when to recover temporary spans */
+    herr_t      ret_value=SUCCEED;       /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -4706,151 +4775,76 @@ H5S_hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_sp
     HDassert(a_not_b);
     HDassert(a_and_b);
     HDassert(b_not_a);
-    HDassert(cur_dim < dim_size);
-    HDassert(all_clips_bounds);
-    HDassert(span_a_b_bounds);
-
-    /* Set the values of bound box pointers */
-    span_a_low_bounds = span_a_b_bounds[0];
-    span_a_high_bounds = span_a_b_bounds[1];
-    span_b_low_bounds = span_a_b_bounds[2];
-    span_b_high_bounds = span_a_b_bounds[3];
-    a_not_b_low_bounds = all_clips_bounds;
-    a_not_b_high_bounds = all_clips_bounds + dim_size;
-    a_and_b_low_bounds = all_clips_bounds + 2 * dim_size;
-    a_and_b_high_bounds = all_clips_bounds + 3 * dim_size;
-    b_not_a_low_bounds = all_clips_bounds + 4 * dim_size;
-    b_not_a_high_bounds = all_clips_bounds + 5 * dim_size;
-
-    /* Set which list(s) to be generated, based on selector */
-    if(H5S_HYPER_COMPUTE_B_NOT_A == (selector & H5S_HYPER_COMPUTE_B_NOT_A))
-        need_b_not_a = TRUE;
-    if(H5S_HYPER_COMPUTE_A_AND_B == (selector & H5S_HYPER_COMPUTE_A_AND_B))
-        need_a_and_b = TRUE;
-    if(H5S_HYPER_COMPUTE_A_NOT_B == (selector & H5S_HYPER_COMPUTE_A_NOT_B))
-        need_a_not_b = TRUE;
 
     /* Check if both span trees are not defined */
-    if(a_spans == NULL && b_spans == NULL) {
-        *a_not_b = NULL;
-        *a_and_b = NULL;
-        *b_not_a = NULL;
+    if(a_spans==NULL && b_spans==NULL) {
+        *a_not_b=NULL;
+        *a_and_b=NULL;
+        *b_not_a=NULL;
     } /* end if */
     /* If span 'a' is not defined, but 'b' is, copy 'b' and set the other return span trees to empty */
-    else if(a_spans == NULL) {
-        *a_not_b = NULL;
-        *a_and_b = NULL;
-        if(need_b_not_a) {
-            if(NULL == (*b_not_a = H5S_hyper_copy_span(b_spans)))
-                HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOPY, FAIL, "can't copy hyperslab span tree")
-
-            /* update b_not_a's bound box based on the values from span_b's bound box */
-            for(u = cur_dim; u < dim_size; u++) {
-                b_not_a_low_bounds[u] = MIN(b_not_a_low_bounds[u], span_b_low_bounds[u]);
-                b_not_a_high_bounds[u] = MAX(b_not_a_high_bounds[u], span_b_high_bounds[u]);
-            } /* end for */
-        } /* end if */
-        else
-            *b_not_a = NULL;
+    else if(a_spans==NULL) {
+        *a_not_b=NULL;
+        *a_and_b=NULL;
+        if((*b_not_a=H5S_hyper_copy_span(b_spans))==NULL)
+            HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOPY, FAIL, "can't copy hyperslab span tree")
     } /* end if */
     /* If span 'b' is not defined, but 'a' is, copy 'a' and set the other return span trees to empty */
-    else if(b_spans == NULL) {
-        *a_and_b = NULL;
-        *b_not_a = NULL;
-        if(need_a_not_b) {
-            if(NULL == (*a_not_b = H5S_hyper_copy_span(a_spans)))
-                HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOPY, FAIL, "can't copy hyperslab span tree")
-
-            /* update b_not_a's bound box based on the values from span_a's bound box */
-            for(u = cur_dim; u < dim_size; u++) {
-                a_not_b_low_bounds[u] = MIN(a_not_b_low_bounds[u], span_a_low_bounds[u]);
-                a_not_b_high_bounds[u] = MAX(a_not_b_high_bounds[u], span_a_high_bounds[u]);
-            } /* end for */
-        } /* end if */
-        else
-            *a_not_b = NULL;
+    else if(b_spans==NULL) {
+        if((*a_not_b=H5S_hyper_copy_span(a_spans))==NULL)
+            HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOPY, FAIL, "can't copy hyperslab span tree")
+        *a_and_b=NULL;
+        *b_not_a=NULL;
     } /* end if */
     /* If span 'a' and 'b' are both defined, calculate the proper span trees */
     else {
         /* Check if both span trees completely overlap */
-        if(H5S_hyper_cmp_spans(a_spans, b_spans) == TRUE) {
-            *a_not_b = NULL;
-            *b_not_a = NULL;
-            if(need_a_and_b) {
-                if(NULL == (*a_and_b = H5S_hyper_copy_span(a_spans)))
-                    HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOPY, FAIL, "can't copy hyperslab span tree")
-
-                /* update a_and_b's bound box based on the values from span_a's bound box */
-                for(u = cur_dim; u < dim_size; u++) {
-                    a_and_b_low_bounds[u] = MIN(a_and_b_low_bounds[u], span_a_low_bounds[u]);
-                    a_and_b_high_bounds[u] = MAX(a_and_b_high_bounds[u], span_a_high_bounds[u]);
-                } /* end for */
-            } /* end if */
-            else
-                *a_and_b = NULL;
+        if(H5S_hyper_cmp_spans(a_spans,b_spans)==TRUE) {
+            *a_not_b=NULL;
+            if((*a_and_b=H5S_hyper_copy_span(a_spans))==NULL)
+                HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOPY, FAIL, "can't copy hyperslab span tree")
+            *b_not_a=NULL;
         } /* end if */
         else {
-            H5S_hyper_span_t *last_a_not_b;   /* Pointer to previous node in span tree 'a_not_b' */
-            H5S_hyper_span_t *last_a_and_b;   /* Pointer to previous node in span tree 'a_and_b' */
-            H5S_hyper_span_t *last_b_not_a;   /* Pointer to previous node in span tree 'b_not_a' */
-            hbool_t update_a_not_b_bounds, update_b_not_a_bounds;        /* Flags to indicate that bounds should be updated */
-            hbool_t recover_a, recover_b;     /* Flags to indicate when to recover temporary spans */
-
             /* Get the pointers to the new and old span lists */
-            span_a = a_spans->head;
-            span_b = b_spans->head;
+            span_a=a_spans->head;
+            span_b=b_spans->head;
 
-            /* Reset the pointers to the previous spans */
-            last_a_not_b = last_a_and_b = last_b_not_a = NULL;
+            /* Set the pointer to the previous spans */
+            last_a_not_b=NULL;
+            last_a_and_b=NULL;
+            last_b_not_a=NULL;
 
             /* No spans to recover yet */
-            recover_a = recover_b = FALSE;
-
-            /* No bounds to update yet */
-            update_a_not_b_bounds = update_b_not_a_bounds = FALSE;
+            recover_a=recover_b=0;
 
             /* Work through the list of spans in the new list */
-            while(span_a != NULL && span_b != NULL) {
-                H5S_hyper_span_info_t *down_a_not_b; /* Temporary pointer to a_not_b span tree of down spans for overlapping nodes */
-                H5S_hyper_span_info_t *down_a_and_b; /* Temporary pointer to a_and_b span tree of down spans for overlapping nodes */
-                H5S_hyper_span_info_t *down_b_not_a; /* Temporary pointer to b_and_a span tree of down spans for overlapping nodes */
-                H5S_hyper_span_t *tmp_span; /* Temporary pointer to new span */
-
+            while(span_a!=NULL && span_b!=NULL) {
                 /* Check if span 'a' is completely before span 'b' */
                 /*    AAAAAAA                            */
                 /* <-----------------------------------> */
                 /*             BBBBBBBBBB                */
-                if(span_a->high < span_b->low) {
+                if(span_a->high<span_b->low) {
                     /* Copy span 'a' and add to a_not_b list */
 
                     /* Merge/add span 'a' with/to a_not_b list */
-                    if(need_a_not_b) {
-                        if(H5S_hyper_append_span(&last_a_not_b, a_not_b, span_a->low, span_a->high, span_a->down, NULL) < 0)
-                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
-
-                        /* Indicate that the a_not_b bounds should be updated */
-                        update_a_not_b_bounds = TRUE;
-                    } /* end if */
+                    if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_a->low,span_a->high,span_a->down,NULL)==FAIL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
                     /* Advance span 'a', leave span 'b' */
-                    H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next);
+                    H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
                 } /* end if */
                 /* Check if span 'a' overlaps only the lower bound */
                 /*  of span 'b' , up to the upper bound of span 'b' */
                 /*    AAAAAAAAAAAA                       */
                 /* <-----------------------------------> */
                 /*             BBBBBBBBBB                */
-                else if(span_a->low < span_b->low && (span_a->high >= span_b->low && span_a->high <= span_b->high)) {
+                else if(span_a->low<span_b->low && (span_a->high>=span_b->low && span_a->high<=span_b->high)) {
                     /* Split span 'a' into two parts at the low bound of span 'b' */
 
                     /* Merge/add lower part of span 'a' with/to a_not_b list */
-                    if(need_a_not_b) {
-                        if(H5S_hyper_append_span(&last_a_not_b, a_not_b, span_a->low, span_b->low - 1, span_a->down, NULL) < 0)
-                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
-
-                        /* Indicate that the a_not_b bounds should be updated */
-                        update_a_not_b_bounds = TRUE;
-                    } /* end if */
+                    if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_a->low,span_b->low-1,span_a->down,NULL)==FAIL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
                     /* Check for overlaps between upper part of span 'a' and lower part of span 'b' */
 
@@ -4858,33 +4852,26 @@ H5S_hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_sp
                     HDassert((span_a->down != NULL && span_b->down != NULL) || (span_a->down == NULL && span_b->down == NULL));
 
                     /* If there are no down spans, just add the overlapping area to the a_and_b list */
-                    if(span_a->down == NULL) {
+                    if(span_a->down==NULL) {
                         /* Merge/add overlapped part with/to a_and_b list */
-                        if(need_a_and_b)
-                            if(H5S_hyper_append_span(&last_a_and_b, a_and_b, span_b->low, span_a->high, NULL, NULL) < 0)
-                                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
+                        if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_b->low,span_a->high,NULL,NULL)==FAIL)
+                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
                     } /* end if */
                     /* If there are down spans, check for the overlap in them and add to each appropriate list */
                     else {
                         /* NULL out the temporary pointers to clipped areas in down spans */
-                        down_a_not_b = NULL;
-                        down_a_and_b = NULL;
-                        down_b_not_a = NULL;
+                        down_a_not_b=NULL;
+                        down_a_and_b=NULL;
+                        down_b_not_a=NULL;
 
                         /* Check for overlaps in the 'down spans' of span 'a' & 'b' */
-                        /** Note: since the bound box of remaining dimensions
-                         *  has been updated in the following clip function (via
-                         *  all_clips_bounds), there's no need updating the bound box
-                         *  after each append call in the following codes */
-                        if(H5S_hyper_clip_spans(span_a->down, span_b->down, selector, cur_dim + 1, dim_size, span_a_b_bounds, all_clips_bounds, &down_a_not_b, &down_a_and_b, &down_b_not_a) < 0)
+                        if(H5S_hyper_clip_spans(span_a->down,span_b->down,&down_a_not_b,&down_a_and_b,&down_b_not_a)<0)
                             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information")
 
                         /* Check for additions to the a_not_b list */
-                        if(down_a_not_b) {
-                            HDassert(need_a_not_b == TRUE);
-
+                        if(down_a_not_b!=NULL) {
                             /* Merge/add overlapped part with/to a_not_b list */
-                            if(H5S_hyper_append_span(&last_a_not_b, a_not_b, span_b->low, span_a->high, down_a_not_b, NULL) < 0)
+                            if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_b->low,span_a->high,down_a_not_b,NULL)==FAIL)
                                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
@@ -4892,11 +4879,9 @@ H5S_hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_sp
                         } /* end if */
 
                         /* Check for additions to the a_and_b list */
-                        if(down_a_and_b) {
-                            HDassert(need_a_and_b == TRUE);
-
+                        if(down_a_and_b!=NULL) {
                             /* Merge/add overlapped part with/to a_and_b list */
-                            if(H5S_hyper_append_span(&last_a_and_b, a_and_b, span_b->low, span_a->high, down_a_and_b, NULL) < 0)
+                            if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_b->low,span_a->high,down_a_and_b,NULL)==FAIL)
                                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
@@ -4904,11 +4889,9 @@ H5S_hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_sp
                         } /* end if */
 
                         /* Check for additions to the b_not_a list */
-                        if(down_b_not_a) {
-                            HDassert(need_b_not_a == TRUE);
-
+                        if(down_b_not_a!=NULL) {
                             /* Merge/add overlapped part with/to b_not_a list */
-                            if(H5S_hyper_append_span(&last_b_not_a, b_not_a, span_b->low, span_a->high, down_b_not_a, NULL) < 0)
+                            if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_b->low,span_a->high,down_b_not_a,NULL)==FAIL)
                                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
@@ -4919,23 +4902,23 @@ H5S_hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_sp
                     /* Split off upper part of span 'b' at upper span of span 'a' */
 
                     /* Check if there is actually an upper part of span 'b' to split off */
-                    if(span_a->high < span_b->high) {
+                    if(span_a->high<span_b->high) {
                         /* Allocate new span node for upper part of span 'b' */
-                        if(NULL == (tmp_span = H5S_hyper_new_span(span_a->high + 1, span_b->high, span_b->down, span_b->next)))
+                        if((tmp_span = H5S_hyper_new_span(span_a->high+1,span_b->high,span_b->down,span_b->next))==NULL)
                             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
                         /* Advance span 'a' */
-                        H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next);
+                        H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
 
                         /* Make upper part of span 'b' into new span 'b' */
-                        H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, tmp_span);
-                        recover_b = TRUE;
+                        H5S_hyper_recover_span(&recover_b,&span_b,tmp_span);
+                        recover_b=1;
                     } /* end if */
                     /* No upper part of span 'b' to split */
                     else {
                         /* Advance both 'a' and 'b' */
-                        H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next);
-                        H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next);
+                        H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
+                        H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
                     } /* end else */
                 } /* end if */
                 /* Check if span 'a' overlaps the lower & upper bound */
@@ -4943,17 +4926,12 @@ H5S_hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_sp
                 /*    AAAAAAAAAAAAAAAAAAAAA              */
                 /* <-----------------------------------> */
                 /*             BBBBBBBBBB                */
-                else if(span_a->low < span_b->low && span_a->high > span_b->high) {
+                else if(span_a->low<span_b->low && span_a->high>span_b->high) {
                     /* Split off lower part of span 'a' at lower span of span 'b' */
 
                     /* Merge/add lower part of span 'a' with/to a_not_b list */
-                    if(need_a_not_b) {
-                        if(H5S_hyper_append_span(&last_a_not_b, a_not_b, span_a->low, span_b->low - 1, span_a->down, NULL) < 0)
-                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
-
-                        /* Indicate that the a_not_b bounds should be updated */
-                        update_a_not_b_bounds = TRUE;
-                    } /* end if */
+                    if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_a->low,span_b->low-1,span_a->down,NULL)==FAIL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
                     /* Check for overlaps between middle part of span 'a' and span 'b' */
 
@@ -4961,29 +4939,26 @@ H5S_hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_sp
                     HDassert((span_a->down != NULL && span_b->down != NULL) || (span_a->down == NULL && span_b->down == NULL));
 
                     /* If there are no down spans, just add the overlapping area to the a_and_b list */
-                    if(span_a->down == NULL) {
+                    if(span_a->down==NULL) {
                         /* Merge/add overlapped part with/to a_and_b list */
-                        if(need_a_and_b)
-                            if(H5S_hyper_append_span(&last_a_and_b, a_and_b, span_b->low, span_b->high, NULL, NULL) < 0)
-                                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
+                        if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_b->low,span_b->high,NULL,NULL)==FAIL)
+                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
                     } /* end if */
                     /* If there are down spans, check for the overlap in them and add to each appropriate list */
                     else {
                         /* NULL out the temporary pointers to clipped areas in down spans */
-                        down_a_not_b = NULL;
-                        down_a_and_b = NULL;
-                        down_b_not_a = NULL;
+                        down_a_not_b=NULL;
+                        down_a_and_b=NULL;
+                        down_b_not_a=NULL;
 
                         /* Check for overlaps in the 'down spans' of span 'a' & 'b' */
-                        if(H5S_hyper_clip_spans(span_a->down, span_b->down, selector, cur_dim + 1, dim_size, span_a_b_bounds, all_clips_bounds, &down_a_not_b, &down_a_and_b, &down_b_not_a) < 0)
+                        if(H5S_hyper_clip_spans(span_a->down,span_b->down,&down_a_not_b,&down_a_and_b,&down_b_not_a)<0)
                             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information")
 
                         /* Check for additions to the a_not_b list */
-                        if(down_a_not_b) {
-                            HDassert(need_a_not_b == TRUE);
-
+                        if(down_a_not_b!=NULL) {
                             /* Merge/add overlapped part with/to a_not_b list */
-                            if(H5S_hyper_append_span(&last_a_not_b, a_not_b,span_b->low, span_b->high, down_a_not_b, NULL) < 0)
+                            if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_b->low,span_b->high,down_a_not_b,NULL)==FAIL)
                                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
@@ -4991,11 +4966,9 @@ H5S_hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_sp
                         } /* end if */
 
                         /* Check for additions to the a_and_b list */
-                        if(down_a_and_b) {
-                            HDassert(need_a_and_b == TRUE);
-
+                        if(down_a_and_b!=NULL) {
                             /* Merge/add overlapped part with/to a_and_b list */
-                            if(H5S_hyper_append_span(&last_a_and_b, a_and_b, span_b->low, span_b->high, down_a_and_b, NULL) < 0)
+                            if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_b->low,span_b->high,down_a_and_b,NULL)==FAIL)
                                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
@@ -5003,11 +4976,9 @@ H5S_hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_sp
                         } /* end if */
 
                         /* Check for additions to the b_not_a list */
-                        if(down_b_not_a) {
-                            HDassert(need_b_not_a == TRUE);
-
+                        if(down_b_not_a!=NULL) {
                             /* Merge/add overlapped part with/to b_not_a list */
-                            if(H5S_hyper_append_span(&last_b_not_a, b_not_a, span_b->low, span_b->high, down_b_not_a, NULL) < 0)
+                            if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_b->low,span_b->high,down_b_not_a,NULL)==FAIL)
                                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
@@ -5018,33 +4989,28 @@ H5S_hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_sp
                     /* Split off upper part of span 'a' at upper span of span 'b' */
 
                     /* Allocate new span node for upper part of span 'a' */
-                    if(NULL == (tmp_span = H5S_hyper_new_span(span_b->high + 1, span_a->high, span_a->down, span_a->next)))
+                    if((tmp_span = H5S_hyper_new_span(span_b->high+1,span_a->high,span_a->down,span_a->next))==NULL)
                         HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
                     /* Make upper part of span 'a' the new span 'a' */
-                    H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, tmp_span);
-                    recover_a = TRUE;
+                    H5S_hyper_recover_span(&recover_a,&span_a,tmp_span);
+                    recover_a=1;
 
                     /* Advance span 'b' */
-                    H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next);
+                    H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
                 } /* end if */
                 /* Check if span 'a' is entirely within span 'b' */
                 /*                AAAAA                  */
                 /* <-----------------------------------> */
                 /*             BBBBBBBBBB                */
-                else if(span_a->low >= span_b->low && span_a->high <= span_b->high) {
+                else if(span_a->low>=span_b->low && span_a->high<=span_b->high) {
                     /* Split off lower part of span 'b' at lower span of span 'a' */
 
                     /* Check if there is actually a lower part of span 'b' to split off */
-                    if(span_a->low > span_b->low) {
+                    if(span_a->low>span_b->low) {
                         /* Merge/add lower part of span 'b' with/to b_not_a list */
-                        if(need_b_not_a) {
-                            if(H5S_hyper_append_span(&last_b_not_a, b_not_a, span_b->low, span_a->low - 1, span_b->down, NULL) < 0)
-                                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
-
-                            /* Indicate that the b_not_a bounds should be updated */
-                            update_b_not_a_bounds = TRUE;
-                        } /* end if */
+                        if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_b->low,span_a->low-1,span_b->down,NULL)==FAIL)
+                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
                     } /* end if */
                     else {
                         /* Keep going, nothing to split off */
@@ -5056,29 +5022,26 @@ H5S_hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_sp
                     HDassert((span_a->down != NULL && span_b->down != NULL) || (span_a->down == NULL && span_b->down == NULL));
 
                     /* If there are no down spans, just add the overlapping area to the a_and_b list */
-                    if(span_a->down == NULL) {
+                    if(span_a->down==NULL) {
                         /* Merge/add overlapped part with/to a_and_b list */
-                        if(need_a_and_b)
-                            if(H5S_hyper_append_span(&last_a_and_b, a_and_b, span_a->low, span_a->high, NULL, NULL) < 0)
-                                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
+                        if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_a->low,span_a->high,NULL,NULL)==FAIL)
+                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
                     } /* end if */
                     /* If there are down spans, check for the overlap in them and add to each appropriate list */
                     else {
                         /* NULL out the temporary pointers to clipped areas in down spans */
-                        down_a_not_b = NULL;
-                        down_a_and_b = NULL;
-                        down_b_not_a = NULL;
+                        down_a_not_b=NULL;
+                        down_a_and_b=NULL;
+                        down_b_not_a=NULL;
 
                         /* Check for overlaps in the 'down spans' of span 'a' & 'b' */
-                        if(H5S_hyper_clip_spans(span_a->down, span_b->down, selector, cur_dim + 1, dim_size, span_a_b_bounds, all_clips_bounds, &down_a_not_b, &down_a_and_b, &down_b_not_a) < 0)
+                        if(H5S_hyper_clip_spans(span_a->down,span_b->down,&down_a_not_b,&down_a_and_b,&down_b_not_a)<0)
                             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information")
 
                         /* Check for additions to the a_not_b list */
-                        if(down_a_not_b) {
-                            HDassert(need_a_not_b == TRUE);
-
+                        if(down_a_not_b!=NULL) {
                             /* Merge/add overlapped part with/to a_not_b list */
-                            if(H5S_hyper_append_span(&last_a_not_b, a_not_b, span_a->low, span_a->high, down_a_not_b, NULL) < 0)
+                            if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_a->low,span_a->high,down_a_not_b,NULL)==FAIL)
                                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
@@ -5086,11 +5049,9 @@ H5S_hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_sp
                         } /* end if */
 
                         /* Check for additions to the a_and_b list */
-                        if(down_a_and_b) {
-                            HDassert(need_a_and_b == TRUE);
-
+                        if(down_a_and_b!=NULL) {
                             /* Merge/add overlapped part with/to a_and_b list */
-                            if(H5S_hyper_append_span(&last_a_and_b, a_and_b, span_a->low, span_a->high, down_a_and_b, NULL) < 0)
+                            if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_a->low,span_a->high,down_a_and_b,NULL)==FAIL)
                                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
@@ -5098,11 +5059,9 @@ H5S_hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_sp
                         } /* end if */
 
                         /* Check for additions to the b_not_a list */
-                        if(down_b_not_a) {
-                            HDassert(need_b_not_a == TRUE);
-
+                        if(down_b_not_a!=NULL) {
                             /* Merge/add overlapped part with/to b_not_a list */
-                            if(H5S_hyper_append_span(&last_b_not_a, b_not_a, span_a->low, span_a->high, down_b_not_a, NULL) < 0)
+                            if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_a->low,span_a->high,down_b_not_a,NULL)==FAIL)
                                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
@@ -5111,24 +5070,24 @@ H5S_hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_sp
                     } /* end else */
 
                     /* Check if there is actually an upper part of span 'b' to split off */
-                    if(span_a->high < span_b->high) {
+                    if(span_a->high<span_b->high) {
                         /* Split off upper part of span 'b' at upper span of span 'a' */
 
                         /* Allocate new span node for upper part of spans 'a' */
-                        if(NULL == (tmp_span = H5S_hyper_new_span(span_a->high + 1, span_b->high, span_b->down, span_b->next)))
+                        if((tmp_span = H5S_hyper_new_span(span_a->high+1,span_b->high,span_b->down,span_b->next))==NULL)
                             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
                         /* And advance span 'a' */
-                        H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next);
+                        H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
 
                         /* Make upper part of span 'b' the new span 'b' */
-                        H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, tmp_span);
-                        recover_b = TRUE;
+                        H5S_hyper_recover_span(&recover_b,&span_b,tmp_span);
+                        recover_b=1;
                     } /* end if */
                     else {
                         /* Advance both span 'a' & span 'b' */
-                        H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next);
-                        H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next);
+                        H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
+                        H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
                     } /* end else */
                 } /* end if */
                 /* Check if span 'a' overlaps only the upper bound */
@@ -5136,19 +5095,14 @@ H5S_hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_sp
                 /*                AAAAAAAAAA             */
                 /* <-----------------------------------> */
                 /*             BBBBBBBBBB                */
-                else if((span_a->low >= span_b->low && span_a->low <= span_b->high) && span_a->high > span_b->high) {
+                else if((span_a->low>=span_b->low && span_a->low<=span_b->high) && span_a->high>span_b->high) {
                     /* Check if there is actually a lower part of span 'b' to split off */
-                    if(span_a->low > span_b->low) {
+                    if(span_a->low>span_b->low) {
                         /* Split off lower part of span 'b' at lower span of span 'a' */
 
                         /* Merge/add lower part of span 'b' with/to b_not_a list */
-                        if(need_b_not_a) {
-                            if(H5S_hyper_append_span(&last_b_not_a, b_not_a, span_b->low, span_a->low - 1, span_b->down, NULL) < 0)
-                                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
-
-                            /* Indicate that the b_not_a bounds should be updated */
-                            update_b_not_a_bounds = TRUE;
-                        } /* end if */
+                        if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_b->low,span_a->low-1,span_b->down,NULL)==FAIL)
+                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
                     } /* end if */
                     else {
                         /* Keep going, nothing to split off */
@@ -5160,29 +5114,26 @@ H5S_hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_sp
                     HDassert((span_a->down != NULL && span_b->down != NULL) || (span_a->down == NULL && span_b->down == NULL));
 
                     /* If there are no down spans, just add the overlapping area to the a_and_b list */
-                    if(span_a->down == NULL) {
+                    if(span_a->down==NULL) {
                         /* Merge/add overlapped part with/to a_and_b list */
-                        if(need_a_and_b)
-                            if(H5S_hyper_append_span(&last_a_and_b, a_and_b, span_a->low, span_b->high, NULL, NULL) < 0)
-                                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
+                        if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_a->low,span_b->high,NULL,NULL)==FAIL)
+                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
                     } /* end if */
                     /* If there are down spans, check for the overlap in them and add to each appropriate list */
                     else {
                         /* NULL out the temporary pointers to clipped areas in down spans */
-                        down_a_not_b = NULL;
-                        down_a_and_b = NULL;
-                        down_b_not_a = NULL;
+                        down_a_not_b=NULL;
+                        down_a_and_b=NULL;
+                        down_b_not_a=NULL;
 
                         /* Check for overlaps in the 'down spans' of span 'a' & 'b' */
-                        if(H5S_hyper_clip_spans(span_a->down, span_b->down, selector, cur_dim + 1, dim_size, span_a_b_bounds, all_clips_bounds, &down_a_not_b, &down_a_and_b, &down_b_not_a) < 0)
+                        if(H5S_hyper_clip_spans(span_a->down,span_b->down,&down_a_not_b,&down_a_and_b,&down_b_not_a)<0)
                             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information")
 
                         /* Check for additions to the a_not_b list */
-                        if(down_a_not_b) {
-                            HDassert(need_a_not_b == TRUE);
-
+                        if(down_a_not_b!=NULL) {
                             /* Merge/add overlapped part with/to a_not_b list */
-                            if(H5S_hyper_append_span(&last_a_not_b, a_not_b, span_a->low, span_b->high, down_a_not_b, NULL) < 0)
+                            if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_a->low,span_b->high,down_a_not_b,NULL)==FAIL)
                                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
@@ -5190,11 +5141,9 @@ H5S_hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_sp
                         } /* end if */
 
                         /* Check for additions to the a_and_b list */
-                        if(down_a_and_b) {
-                            HDassert(need_a_and_b == TRUE);
-
+                        if(down_a_and_b!=NULL) {
                             /* Merge/add overlapped part with/to a_and_b list */
-                            if(H5S_hyper_append_span(&last_a_and_b, a_and_b, span_a->low, span_b->high, down_a_and_b, NULL) < 0)
+                            if(H5S_hyper_append_span(&last_a_and_b,a_and_b,span_a->low,span_b->high,down_a_and_b,NULL)==FAIL)
                                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
@@ -5202,11 +5151,9 @@ H5S_hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_sp
                         } /* end if */
 
                         /* Check for additions to the b_not_a list */
-                        if(down_b_not_a) {
-                            HDassert(need_b_not_a == TRUE);
-
+                        if(down_b_not_a!=NULL) {
                             /* Merge/add overlapped part with/to b_not_a list */
-                            if(H5S_hyper_append_span(&last_b_not_a, b_not_a, span_a->low, span_b->high, down_b_not_a, NULL) < 0)
+                            if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_a->low,span_b->high,down_b_not_a,NULL)==FAIL)
                                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
                             /* Release the down span tree generated */
@@ -5217,15 +5164,15 @@ H5S_hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_sp
                     /* Split off upper part of span 'a' at upper span of span 'b' */
 
                     /* Allocate new span node for upper part of span 'a' */
-                    if(NULL == (tmp_span = H5S_hyper_new_span(span_b->high + 1, span_a->high, span_a->down, span_a->next)))
+                    if((tmp_span = H5S_hyper_new_span(span_b->high+1,span_a->high,span_a->down,span_a->next))==NULL)
                         HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
                     /* Make upper part of span 'a' into new span 'a' */
-                    H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, tmp_span);
-                    recover_a = TRUE;
+                    H5S_hyper_recover_span(&recover_a,&span_a,tmp_span);
+                    recover_a=1;
 
                     /* Advance span 'b' */
-                    H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next);
+                    H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
                 } /* end if */
                 /* span 'a' must be entirely above span 'b' */
                 /*                         AAAAA         */
@@ -5235,103 +5182,46 @@ H5S_hyper_clip_spans(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_sp
                     /* Copy span 'b' and add to b_not_a list */
 
                     /* Merge/add span 'b' with/to b_not_a list */
-                    if(need_b_not_a) {
-                        if(H5S_hyper_append_span(&last_b_not_a, b_not_a, span_b->low, span_b->high, span_b->down, NULL) < 0)
-                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
-
-                        /* Indicate that the b_not_a bounds should be updated */
-                        update_b_not_a_bounds = TRUE;
-                    } /* end if */
+                    if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_b->low,span_b->high,span_b->down,NULL)==FAIL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
                     /* Advance span 'b', leave span 'a' */
-                    H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next);
+                    H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
                 } /* end else */
             } /* end while */
 
             /* Clean up 'a' spans which haven't been covered yet */
-            if(span_a != NULL && span_b == NULL) {
-                /* Check if need to merge/add 'a' spans with/to a_not_b list */
-                if(need_a_not_b) {
-                    while(span_a != NULL) {
-                        /* Copy span 'a' and add to a_not_b list */
-                        if(H5S_hyper_append_span(&last_a_not_b, a_not_b, span_a->low, span_a->high, span_a->down, NULL) < 0)
-                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
+            if(span_a!=NULL && span_b==NULL) {
+                while(span_a!=NULL) {
+                    /* Copy span 'a' and add to a_not_b list */
 
-                        /* Advance to the next 'a' span */
-                        H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next);
-                    } /* end while */
+                    /* Merge/add span 'a' with/to a_not_b list */
+                    if(H5S_hyper_append_span(&last_a_not_b,a_not_b,span_a->low,span_a->high,span_a->down,NULL)==FAIL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
-                    /* Indicate that the a_not_b bounds should be updated */
-                    update_a_not_b_bounds = TRUE;
-                } /* end if */
-                else {
-                    /* Free the span, if it's generated */
-                    if(recover_a)
-                        H5S_hyper_free_span(span_a);
-                } /* end else */
+                    /* Advance to the next 'a' span */
+                    H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
+                } /* end while */
             } /* end if */
             /* Clean up 'b' spans which haven't been covered yet */
-            else if(span_a == NULL && span_b != NULL) {
-                /* Check if need to merge/add 'b' spans with/to b_not_a list */
-                if(need_b_not_a) {
-                    while(span_b != NULL) {
-                        /* Copy span 'b' and add to b_not_a list */
-                        if(H5S_hyper_append_span(&last_b_not_a, b_not_a, span_b->low, span_b->high, span_b->down, NULL) < 0)
-                            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
-
-                        /* Advance to the next 'b' span */
-                        H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next);
-                    } /* end while */
-
-                    /* Indicate that the b_not_a bounds should be updated */
-                    update_b_not_a_bounds = TRUE;
-                } /* end if */
-                else {
-                    /* Free the span, if it's generated */
-                    if(recover_b)
-                        H5S_hyper_free_span(span_b);
-                } /* end else */
-            } /* end if */
+            else if(span_a==NULL && span_b!=NULL) {
+                while(span_b!=NULL) {
+                    /* Copy span 'b' and add to b_not_a list */
 
-            /* Check for needing to update each set of bounds */
-            if(update_a_not_b_bounds) {
-                /* Update bounding box of a_not_b for remaining dimensions as a span was appended */
-                for(u = cur_dim + 1; u < dim_size; u++) {
-                    a_not_b_low_bounds[u] = MIN(a_not_b_low_bounds[u], span_a_low_bounds[u]);
-                    a_not_b_high_bounds[u] = MAX(a_not_b_high_bounds[u], span_a_high_bounds[u]);
-                } /* end for */
-            } /* end if */
-            if(update_b_not_a_bounds) {
-                /* Update bounding box of b_not_a for remaining dimensions as a span was appended */
-                for(u = cur_dim + 1; u < dim_size; u++) {
-                    b_not_a_low_bounds[u] = MIN(b_not_a_low_bounds[u], span_b_low_bounds[u]);
-                    b_not_a_high_bounds[u] = MAX(b_not_a_high_bounds[u], span_b_high_bounds[u]);
-                } /* end for */
-            } /* end if */
+                    /* Merge/add span 'b' with/to b_not_a list */
+                    if(H5S_hyper_append_span(&last_b_not_a,b_not_a,span_b->low,span_b->high,span_b->down,NULL)==FAIL)
+                        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
-            /**
-             *  Up to this point, the clip operation has been applied to one
-             *  span list in one dimension. So it's time to update the bound
-             *  box of the clipped span trees.
-             */
-            if(need_a_not_b && *a_not_b != NULL) {
-                a_not_b_low_bounds[cur_dim] = MIN(a_not_b_low_bounds[cur_dim], (*a_not_b)->head->low);
-                a_not_b_high_bounds[cur_dim] = MAX(a_not_b_high_bounds[cur_dim], (*a_not_b)->tail->high);
-            } /* end if */
-            if(need_a_and_b && *a_and_b != NULL) {
-                a_and_b_low_bounds[cur_dim] = MIN(a_and_b_low_bounds[cur_dim], (*a_and_b)->head->low);
-                a_and_b_high_bounds[cur_dim] = MAX(a_and_b_high_bounds[cur_dim], (*a_and_b)->tail->high);
-            } /* end if */
-            if(need_b_not_a && *b_not_a != NULL) {
-                b_not_a_low_bounds[cur_dim] = MIN(b_not_a_low_bounds[cur_dim], (*b_not_a)->head->low);
-                b_not_a_high_bounds[cur_dim] = MAX(b_not_a_high_bounds[cur_dim], (*b_not_a)->tail->high);
+                    /* Advance to the next 'b' span */
+                    H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
+                } /* end while */
             } /* end if */
         } /* end else */
     } /* end else */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_clip_spans() */
+}   /* H5S_hyper_clip_spans() */
 
 
 /*--------------------------------------------------------------------------
@@ -5356,10 +5246,16 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static H5S_hyper_span_info_t *
-H5S_hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_spans)
+H5S_hyper_merge_spans_helper (H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info_t *b_spans)
 {
-    H5S_hyper_span_info_t *merged_spans = NULL; /* Pointer to the merged span tree */
-    H5S_hyper_span_info_t *ret_value;   /* Return value */
+    H5S_hyper_span_info_t *merged_spans=NULL; /* Pointer to the merged span tree */
+    H5S_hyper_span_info_t *tmp_spans;   /* Pointer to temporary new span tree */
+    H5S_hyper_span_t *tmp_span;         /* Pointer to temporary new span */
+    H5S_hyper_span_t *span_a;           /* Pointer to current span 'a' working on */
+    H5S_hyper_span_t *span_b;           /* Pointer to current span 'b' working on */
+    H5S_hyper_span_t *prev_span_merge;  /* Pointer to previous merged span */
+    unsigned recover_a, recover_b;         /* Flags to indicate when to recover temporary spans */
+    H5S_hyper_span_info_t *ret_value;
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -5367,54 +5263,46 @@ H5S_hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info
     HDassert((a_spans != NULL && b_spans != NULL) || (a_spans == NULL && b_spans == NULL));
 
     /* Check if the span trees for the 'a' span and the 'b' span are the same */
-    if(H5S_hyper_cmp_spans(a_spans, b_spans) == TRUE) {
-        if(a_spans == NULL)
-            merged_spans = NULL;
+    if(H5S_hyper_cmp_spans(a_spans,b_spans)==TRUE) {
+        if(a_spans==NULL)
+            merged_spans=NULL;
         else {
             /* Copy one of the span trees to return */
-            if(NULL == (merged_spans = H5S_hyper_copy_span(a_spans)))
+            if((merged_spans=H5S_hyper_copy_span(a_spans))==NULL)
                 HGOTO_ERROR(H5E_INTERNAL, H5E_CANTCOPY, NULL, "can't copy hyperslab span tree")
         } /* end else */
     } /* end if */
     else {
-        H5S_hyper_span_t *span_a;           /* Pointer to current span 'a' working on */
-        H5S_hyper_span_t *span_b;           /* Pointer to current span 'b' working on */
-        H5S_hyper_span_t *prev_span_merge;  /* Pointer to previous merged span */
-        hbool_t recover_a, recover_b;       /* Flags to indicate when to recover temporary spans */
-
         /* Get the pointers to the 'a' and 'b' span lists */
-        span_a = a_spans->head;
-        span_b = b_spans->head;
+        span_a=a_spans->head;
+        span_b=b_spans->head;
 
         /* Set the pointer to the previous spans */
-        prev_span_merge = NULL;
+        prev_span_merge=NULL;
 
         /* No spans to recover yet */
-        recover_a = recover_b = FALSE;
+        recover_a=recover_b=0;
 
         /* Work through the list of spans in the new list */
         while(span_a!=NULL && span_b!=NULL) {
-            H5S_hyper_span_info_t *tmp_spans;   /* Pointer to temporary new span tree */
-            H5S_hyper_span_t *tmp_span;         /* Pointer to temporary new span */
-
             /* Check if the 'a' span is completely before 'b' span */
             /*    AAAAAAA                            */
             /* <-----------------------------------> */
             /*             BBBBBBBBBB                */
-            if(span_a->high < span_b->low) {
+            if(span_a->high<span_b->low) {
                 /* Merge/add span 'a' with/to the merged spans */
                 if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_a->low,span_a->high,span_a->down,NULL)==FAIL)
                     HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span")
 
                 /* Advance span 'a' */
-                H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next);
+                H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
             } /* end if */
             /* Check if span 'a' overlaps only the lower bound */
             /*  of span 'b', up to the upper bound of span 'b' */
             /*    AAAAAAAAAAAA                       */
             /* <-----------------------------------> */
             /*             BBBBBBBBBB                */
-            else if(span_a->low < span_b->low && (span_a->high >= span_b->low && span_a->high <= span_b->high)) {
+            else if(span_a->low<span_b->low && (span_a->high>=span_b->low && span_a->high<=span_b->high)) {
                 /* Check if span 'a' and span 'b' down spans are equal */
                 if(H5S_hyper_cmp_spans(span_a->down,span_b->down)==TRUE) {
                     /* Merge/add copy of span 'a' with/to merged spans */
@@ -5438,7 +5326,7 @@ H5S_hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info
                 } /* end else */
 
                 /* Check if there is an upper part of span 'b' */
-                if(span_a->high < span_b->high) {
+                if(span_a->high<span_b->high) {
                     /* Copy upper part of span 'b' as new span 'b' */
 
                     /* Allocate new span node to append to list */
@@ -5446,16 +5334,16 @@ H5S_hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info
                         HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span")
 
                     /* Advance span 'a' */
-                    H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next);
+                    H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
 
                     /* Set new span 'b' to tmp_span */
-                    H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, tmp_span);
-                    recover_b = TRUE;
+                    H5S_hyper_recover_span(&recover_b,&span_b,tmp_span);
+                    recover_b=1;
                 } /* end if */
                 else {
                     /* Advance both span 'a' & 'b' */
-                    H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next);
-                    H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next);
+                    H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
+                    H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
                 } /* end else */
             } /* end if */
             /* Check if span 'a' overlaps the lower & upper bound */
@@ -5463,7 +5351,7 @@ H5S_hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info
             /*    AAAAAAAAAAAAAAAAAAAAA              */
             /* <-----------------------------------> */
             /*             BBBBBBBBBB                */
-            else if(span_a->low < span_b->low && span_a->high > span_b->high) {
+            else if(span_a->low<span_b->low && span_a->high>span_b->high) {
                 /* Check if span 'a' and span 'b' down spans are equal */
                 if(H5S_hyper_cmp_spans(span_a->down,span_b->down)==TRUE) {
                     /* Merge/add copy of lower & middle parts of span 'a' to merged spans */
@@ -5493,17 +5381,17 @@ H5S_hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info
                     HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span")
 
                 /* Set new span 'a' to tmp_span */
-                H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, tmp_span);
-                recover_a = TRUE;
+                H5S_hyper_recover_span(&recover_a,&span_a,tmp_span);
+                recover_a=1;
 
                 /* Advance span 'b' */
-                H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next);
+                H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
             } /* end if */
             /* Check if span 'a' is entirely within span 'b' */
             /*                AAAAA                  */
             /* <-----------------------------------> */
             /*             BBBBBBBBBB                */
-            else if(span_a->low >= span_b->low && span_a->high <= span_b->high) {
+            else if(span_a->low>=span_b->low && span_a->high<=span_b->high) {
                 /* Check if span 'a' and span 'b' down spans are equal */
                 if(H5S_hyper_cmp_spans(span_a->down,span_b->down)==TRUE) {
                     /* Merge/add copy of lower & middle parts of span 'b' to merged spans */
@@ -5512,7 +5400,7 @@ H5S_hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info
                 } /* end if */
                 else {
                     /* Check if there is a lower part of span 'b' */
-                    if(span_a->low > span_b->low) {
+                    if(span_a->low>span_b->low) {
                         /* Merge/add lower part of span 'b' to merged spans */
                         if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_b->low,span_a->low-1,span_b->down,NULL)==FAIL)
                             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span")
@@ -5533,7 +5421,7 @@ H5S_hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info
                 } /* end else */
 
                 /* Check if there is an upper part of span 'b' */
-                if(span_a->high < span_b->high) {
+                if(span_a->high<span_b->high) {
                     /* Copy upper part of span 'b' as new span 'b' (remember to free) */
 
                     /* Allocate new span node to append to list */
@@ -5541,16 +5429,16 @@ H5S_hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info
                         HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span")
 
                     /* Advance span 'a' */
-                    H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next);
+                    H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
 
                     /* Set new span 'b' to tmp_span */
-                    H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, tmp_span);
-                    recover_b = TRUE;
+                    H5S_hyper_recover_span(&recover_b,&span_b,tmp_span);
+                    recover_b=1;
                 } /* end if */
                 else {
                     /* Advance both spans */
-                    H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next);
-                    H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next);
+                    H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
+                    H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
                 } /* end else */
             } /* end if */
             /* Check if span 'a' overlaps only the upper bound */
@@ -5558,7 +5446,7 @@ H5S_hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info
             /*                AAAAAAAAAA             */
             /* <-----------------------------------> */
             /*             BBBBBBBBBB                */
-            else if((span_a->low >= span_b->low && span_a->low <= span_b->high) && span_a->high > span_b->high) {
+            else if((span_a->low>=span_b->low && span_a->low<=span_b->high) && span_a->high>span_b->high) {
                 /* Check if span 'a' and span 'b' down spans are equal */
                 if(H5S_hyper_cmp_spans(span_a->down,span_b->down)==TRUE) {
                     /* Merge/add copy of span 'b' to merged spans if so */
@@ -5567,7 +5455,7 @@ H5S_hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info
                 } /* end if */
                 else {
                     /* Check if there is a lower part of span 'b' */
-                    if(span_a->low > span_b->low) {
+                    if(span_a->low>span_b->low) {
                         /* Merge/add lower part of span 'b' to merged spans */
                         if(H5S_hyper_append_span(&prev_span_merge,&merged_spans,span_b->low,span_a->low-1,span_b->down,NULL)==FAIL)
                             HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span")
@@ -5594,11 +5482,11 @@ H5S_hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info
                     HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span")
 
                 /* Set new span 'a' to tmp_span */
-                H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, tmp_span);
-                recover_a = TRUE;
+                H5S_hyper_recover_span(&recover_a,&span_a,tmp_span);
+                recover_a=1;
 
                 /* Advance span 'b' */
-                H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next);
+                H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
             } /* end if */
             /* Span 'a' must be entirely above span 'b' */
             /*                         AAAAA         */
@@ -5610,7 +5498,7 @@ H5S_hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info
                     HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span")
 
                 /* Advance span 'b' */
-                H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next);
+                H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
             } /* end else */
         } /* end while */
 
@@ -5622,7 +5510,7 @@ H5S_hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info
                     HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span")
 
                 /* Advance to next 'a' span, until all processed */
-                H5S_HYPER_ADVANCE_SPAN(recover_a, span_a, span_a->next);
+                H5S_hyper_recover_span(&recover_a,&span_a,span_a->next);
             } /* end while */
         } /* end if */
 
@@ -5634,7 +5522,7 @@ H5S_hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info
                     HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span")
 
                 /* Advance to next 'b' span, until all processed */
-                H5S_HYPER_ADVANCE_SPAN(recover_b, span_b, span_b->next);
+                H5S_hyper_recover_span(&recover_b,&span_b,span_b->next);
             } /* end while */
         } /* end if */
     } /* end else */
@@ -5643,12 +5531,14 @@ H5S_hyper_merge_spans_helper(H5S_hyper_span_info_t *a_spans, H5S_hyper_span_info
     ret_value = merged_spans;
 
 done:
-    if(ret_value == NULL)
-        if(merged_spans && H5S_hyper_free_span_info(merged_spans) < 0)
-            HDONE_ERROR(H5E_INTERNAL, H5E_CANTFREE, NULL, "failed to release merged hyperslab spans")
+    if(ret_value == NULL) {
+        if(merged_spans)
+            if(H5S_hyper_free_span_info(merged_spans) < 0)
+                HDONE_ERROR(H5E_INTERNAL, H5E_CANTFREE, NULL, "failed to release merged hyperslab spans")
+    } /* end if */
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_merge_spans_helper() */
+}   /* H5S_hyper_merge_spans_helper() */
 
 
 /*--------------------------------------------------------------------------
@@ -5662,6 +5552,9 @@ done:
                                         selection.
         H5S_hyper_span_t *new_spans;    IN: Span tree of new spans to add to
                                             hyperslab selection
+        hbool_t can_own;        IN: Flag to indicate that it is OK to point
+                                    directly to the new spans, instead of
+                                    copying them.
  RETURNS
     non-negative on success, negative on failure
  DESCRIPTION
@@ -5674,38 +5567,41 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S_hyper_merge_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans)
+H5S_hyper_merge_spans (H5S_t *space, H5S_hyper_span_info_t *new_spans, hbool_t can_own)
 {
-    herr_t ret_value = SUCCEED;     /* Return value */
-
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     /* Check args */
     HDassert(space);
     HDassert(new_spans);
 
     /* If this is the first span tree in the hyperslab selection, just use it */
-    if(space->select.sel_info.hslab->span_lst == NULL)
-        space->select.sel_info.hslab->span_lst = new_spans;
+    if(space->select.sel_info.hslab->span_lst==NULL) {
+        if(can_own)
+            space->select.sel_info.hslab->span_lst=new_spans;
+        else
+            space->select.sel_info.hslab->span_lst=H5S_hyper_copy_span(new_spans);
+    } /* end if */
     else {
         H5S_hyper_span_info_t *merged_spans;
 
         /* Get the merged spans */
-        if(NULL == (merged_spans = H5S_hyper_merge_spans_helper(space->select.sel_info.hslab->span_lst, new_spans)))
-            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTMERGE, FAIL, "can't merge hyperslab spans")
+        merged_spans=H5S_hyper_merge_spans_helper(space->select.sel_info.hslab->span_lst, new_spans);
+
+        /* Sanity checking since we started with some spans, we should still have some after the merge */
+        HDassert(merged_spans);
 
         /* Free the previous spans */
-        if(H5S_hyper_free_span_info(space->select.sel_info.hslab->span_lst) < 0)
-            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTFREE, FAIL, "failed to release hyperslab spans")
+        H5S_hyper_free_span_info(space->select.sel_info.hslab->span_lst);
 
         /* Point to the new merged spans */
-        space->select.sel_info.hslab->span_lst = merged_spans;
+        space->select.sel_info.hslab->span_lst=merged_spans;
     } /* end else */
 
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_merge_spans() */
+    FUNC_LEAVE_NOAPI(SUCCEED)
+}   /* H5S_hyper_merge_spans() */
 
+
 /*--------------------------------------------------------------------------
  NAME
     H5S_hyper_spans_nelem
@@ -5724,150 +5620,34 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static hsize_t
-H5S_hyper_spans_nelem(const H5S_hyper_span_info_t *spans)
+H5S_hyper_spans_nelem (H5S_hyper_span_info_t *spans)
 {
-    hsize_t ret_value = 0;          /* Return value */
+    H5S_hyper_span_t *span;     /* Hyperslab span */
+    hsize_t ret_value;
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     /* Count the number of elements in the span tree */
-    if(spans != NULL) {
-        const H5S_hyper_span_t *span;     /* Hyperslab span */
-
-        span = spans->head;
-        while(span != NULL) {
+    if(spans==NULL)
+        ret_value=0;
+    else {
+        span=spans->head;
+        ret_value=0;
+        while(span!=NULL) {
             /* If there are down spans, multiply the size of this span by the total down span elements */
-            if(span->down != NULL)
-                ret_value += span->nelem * H5S_hyper_spans_nelem(span->down);
+            if(span->down!=NULL)
+                ret_value+=span->nelem*H5S_hyper_spans_nelem(span->down);
             /* If there are no down spans, just count the elements in this span */
             else
-                ret_value += span->nelem;
+                ret_value+=span->nelem;
 
             /* Advance to next span */
-            span = span->next;
+            span=span->next;
         } /* end while */
     } /* end else */
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_spans_nelem() */
-
-/*--------------------------------------------------------------------------
- NAME
-    H5S_hyper_add_disjoint_spans
- PURPOSE
-    Add new hyperslab spans to existing hyperslab selection in the case the
-    new hyperslab spans don't overlap or border with the existing hyperslab
-    selection
- USAGE
-    herr_t H5S_hyper_add_disjoint_spans(space, new_spans)
-        H5S_t *space;             IN: Dataspace to add new spans to hyperslab
-                                        selection.
-        H5S_hyper_span_t *new_spans;    IN: Span tree of new spans to add to
-                                            hyperslab selection
- RETURNS
-    non-negative on success, negative on failure
- DESCRIPTION
-    Add a set of hyperslab spans to an existing hyperslab selection.  The
-    new spans are required not to overlap or borderwith the existing spans
-    in the dataspace's current hyperslab selection in terms of bound box.
- GLOBAL VARIABLES
- COMMENTS, BUGS, ASSUMPTIONS
- EXAMPLES
- REVISION LOG
---------------------------------------------------------------------------*/
-static herr_t
-H5S_hyper_add_disjoint_spans(H5S_t *space, H5S_hyper_span_info_t *new_spans)
-{
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
-
-    /* Check args */
-    HDassert(space);
-    HDassert(new_spans);
-
-    /* update the number of elements in the selection */
-    space->select.num_elem += H5S_hyper_spans_nelem(new_spans);
-
-    /* If this is the first span tree in the hyperslab selection, just use it */
-    if(space->select.sel_info.hslab->span_lst == NULL)
-        space->select.sel_info.hslab->span_lst = new_spans;
-    else {
-       H5S_hyper_span_info_t *old_spans = space->select.sel_info.hslab->span_lst;
-       H5S_hyper_span_info_t *high_order_spans = NULL;
-       H5S_hyper_span_info_t *low_order_spans = NULL;
-
-       /* Combine the new_spans with the old_spans only in the highest-order of dimension */
-       /* Example:
-        * old_spans:           ------------------> X
-        *            | (1,2)--->(1,3)--->(6,4)--->||
-        *            |   |        ^
-        *            |   |        |
-        *      Y     |   V        |
-        *            | (5,2)------.
-        *            |   |
-        *            |   |
-        *            |   V
-        *            |   =
-        *            V
-        * new_spans:           --------------------> X
-        *            | (8,2)--->(12,3)--->(17,4)--->||
-        *            |   |
-        *      Y     |   |
-        *            |   V
-        *            |   =
-        *            V
-        *
-        * After merging, the old_spans becomes
-        *
-        * old_spans:           ------------------> X
-        *            | (1,2)--->(1,3)--->(6,4)--->||
-        *            |   |        ^
-        *            |   |        |
-        *            |   V        |
-        *            | (5,2)------.
-        *            |   |
-        *      Y     |   |
-        *            | (8,2)--->(12,3)--->(17,4)--->||
-        *            |   |
-        *            |   |
-        *            |   V
-        *            |   =
-        *            V
-        */
-
-       /* Make sure the tail pointers are updated correctly */
-       HDassert(old_spans->tail);
-       HDassert(NULL == old_spans->tail->next);
-       HDassert(new_spans->tail);
-       HDassert(NULL == new_spans->tail->next);
-
-       /* Check old_spans and new_spans to see which one is of higher order,
-        * and append the higher order spans to the lower order ones.
-        */
-       if(new_spans->head->low > old_spans->tail->high) {
-           high_order_spans = new_spans;
-           low_order_spans = old_spans;
-       } /* end if */
-       else{
-           high_order_spans = old_spans;
-           low_order_spans = new_spans;
-       } /* end else */
-
-       /* The high_order_spans should be appended to low_order_spans */
-       low_order_spans->tail->next = high_order_spans->head;
-
-       /* "pstride" is only updated in IO operations, so it needs no update here */
-       /*high_order_spans->head->pstride = high_order_spans->head->low - low_order_spans->tail->low;*/
-       low_order_spans->tail = high_order_spans->tail;
-
-       /* Fix the selection's 1st span info node */
-       space->select.sel_info.hslab->span_lst = low_order_spans;
-
-       /* free the memory space for "new_spans" node */
-       high_order_spans = H5FL_FREE(H5S_hyper_span_info_t, high_order_spans);
-    } /* end else */
-
-    FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5S_hyper_add_disjoint_spans */
+}   /* H5S_hyper_spans_nelem() */
 
 
 /*--------------------------------------------------------------------------
@@ -5956,19 +5736,23 @@ H5S_hyper_make_spans(unsigned rank, const hsize_t *start, const hsize_t *stride,
                 span->down = down;
                 down->count++;  /* Increment reference count for shared span */
             } /* end if */
-            else
+            else {
                 span->down = NULL;
+            } /* end else */
         } /* end for */
 
         /* Allocate a span info node */
-        if(NULL == (down = H5FL_CALLOC(H5S_hyper_span_info_t)))
+        if(NULL == (down = H5FL_MALLOC(H5S_hyper_span_info_t)))
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTALLOC, NULL, "can't allocate hyperslab span")
 
+        /* Set the reference count */
+        down->count = 0;
+
+        /* Reset the scratch pad space */
+        down->scratch = 0;
+
         /* Keep the pointer to the next dimension down's completed list */
         down->head = head;
-
-        /* Keep the tail pointer to the next dimension down's completed list */
-        down->tail = last_span;
     } /* end for */
 
     /* Indicate that there is a pointer to this tree */
@@ -6002,217 +5786,7 @@ done:
     } /* end if */
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_make_spans() */
-
-
-/*--------------------------------------------------------------------------
- NAME
-    H5S_hyper_update_diminfo
- PURPOSE
-    Attempt to update optimized hyperslab information quickly.  (It can be
-    recovered with regular selection).  If this algorithm cannot determine
-    the optimized dimension info quickly, this function will simply mark it
-    as invalid and unknown if it can be built (H5S_DIMINFO_VALID_NO), so
-    H5S_hyper_rebuild can be run later to determine for sure.
- USAGE
-    herr_t H5S_hyper_update_diminfo(space, op, new_hyper_diminfo)
-        H5S_t *space;       IN: Dataspace to check
-        H5S_seloper_t op;   IN: The operation being performed on the
-                                selection
-        const H5S_hyper_dim_t new_hyper_diminfo; IN: The new selection that
-                                                     is being combined with
-                                                     the current
- RETURNS
-    >=0 on success, <0 on failure
- DESCRIPTION
-    Examine the span tree for a hyperslab selection and rebuild
-    the start/stride/count/block information for the selection, if possible.
-
- GLOBAL VARIABLES
- COMMENTS, BUGS, ASSUMPTIONS
- EXAMPLES
- REVISION LOG
-    NF, 2014/6/6
---------------------------------------------------------------------------*/
-static herr_t
-H5S_hyper_update_diminfo(H5S_t *space, H5S_seloper_t op,
-    const H5S_hyper_dim_t *new_hyper_diminfo)
-{
-    H5S_hyper_dim_t tmp_diminfo[H5S_MAX_RANK];  /* Temporary dimension info */
-    hbool_t found_nonidentical_dim = FALSE;
-    unsigned curr_dim;
-    herr_t ret_value = SUCCEED;      /* Return value */
-
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
-
-    /* Check args */
-    HDassert(space);
-    HDassert(new_hyper_diminfo);
-
-    /* Check for conditions that prevent us from using the fast algorithm here
-     * (and instead require H5S_hyper_rebuild) */
-    if(!((op == H5S_SELECT_OR) || (op == H5S_SELECT_XOR))
-            || space->select.sel_info.hslab->diminfo_valid != H5S_DIMINFO_VALID_YES
-            || !space->select.sel_info.hslab->span_lst->head) {
-        space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO;
-        HGOTO_DONE(SUCCEED)
-    } /* end if */
-
-    /* Copy current opt_diminfo values */
-    for(curr_dim = 0; curr_dim < space->extent.rank; curr_dim++) {
-        tmp_diminfo[curr_dim].start  = space->select.sel_info.hslab->opt_diminfo[curr_dim].start;
-        tmp_diminfo[curr_dim].stride = space->select.sel_info.hslab->opt_diminfo[curr_dim].stride;
-        tmp_diminfo[curr_dim].count  = space->select.sel_info.hslab->opt_diminfo[curr_dim].count;
-        tmp_diminfo[curr_dim].block  = space->select.sel_info.hslab->opt_diminfo[curr_dim].block;
-    } /* end for */
-
-    /* Loop over dimensions */
-    for(curr_dim = 0; curr_dim < space->extent.rank; curr_dim++) {
-        /* Check for this being identical */
-        if((tmp_diminfo[curr_dim].start != new_hyper_diminfo[curr_dim].start)
-                || (tmp_diminfo[curr_dim].stride != new_hyper_diminfo[curr_dim].stride)
-                || (tmp_diminfo[curr_dim].count != new_hyper_diminfo[curr_dim].count)
-                || (tmp_diminfo[curr_dim].block != new_hyper_diminfo[curr_dim].block)) {
-            hsize_t high_start, high_count, high_block;         /* The start, count & block values for the higher block */
-
-            /* Dimension is not identical */
-            /* Check if we already found a nonidentical dim - only one is
-             * allowed */
-            if(found_nonidentical_dim) {
-                space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO;
-                break;
-            } /* end if */
-
-            /* Check that strides are the same, or count is 1 for one of the
-             * slabs */
-            if((tmp_diminfo[curr_dim].stride != new_hyper_diminfo[curr_dim].stride)
-                    && (tmp_diminfo[curr_dim].count > 1)
-                    && (new_hyper_diminfo[curr_dim].count > 1)) {
-                space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO;
-                break;
-            } /* end if */
-
-            /* Patch tmp_diminfo.stride if its count is 1 */
-            if((tmp_diminfo[curr_dim].count == 1)
-                    && (new_hyper_diminfo[curr_dim].count > 1))
-                tmp_diminfo[curr_dim].stride = new_hyper_diminfo[curr_dim].stride;
-
-            /* Determine lowest start, and set tmp_diminfo.start, count and
-             *  block to use the lowest, and high_start, high_count and
-             *  high_block to use the highest
-             */
-            if(tmp_diminfo[curr_dim].start < new_hyper_diminfo[curr_dim].start) {
-                high_start = new_hyper_diminfo[curr_dim].start;
-                high_count = new_hyper_diminfo[curr_dim].count;
-                high_block = new_hyper_diminfo[curr_dim].block;
-            } /* end if */
-            else {
-                high_start = tmp_diminfo[curr_dim].start;
-                tmp_diminfo[curr_dim].start = new_hyper_diminfo[curr_dim].start;
-                high_count = tmp_diminfo[curr_dim].count;
-                tmp_diminfo[curr_dim].count = new_hyper_diminfo[curr_dim].count;
-                high_block = tmp_diminfo[curr_dim].block;
-                tmp_diminfo[curr_dim].block = new_hyper_diminfo[curr_dim].block;
-            } /* end else */
-
-            /* If count is 1 for both slabs, take different actions */
-            if((tmp_diminfo[curr_dim].count == 1) && (high_count == 1)) {
-                /* Check for overlap */
-                if((tmp_diminfo[curr_dim].start + tmp_diminfo[curr_dim].block)
-                        > high_start) {
-                    /* Check operation type */
-                    if(op == H5S_SELECT_OR)
-                        /* Merge blocks */
-                        tmp_diminfo[curr_dim].block = ((high_start + high_block)
-                                >= (tmp_diminfo[curr_dim].start + tmp_diminfo[curr_dim].block))
-                                ? (high_start + high_block - tmp_diminfo[curr_dim].start)
-                                : tmp_diminfo[curr_dim].block;
-                    else {
-                        /* Block values must be the same */
-                        if(tmp_diminfo[curr_dim].block != high_block) {
-                            space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO;
-                            break;
-                        } /* end if */
-
-                        /* XOR - overlap creates 2 blocks */
-                        tmp_diminfo[curr_dim].stride = high_block;
-                        tmp_diminfo[curr_dim].count = 2;
-                        tmp_diminfo[curr_dim].block = high_start - tmp_diminfo[curr_dim].start;
-                    } /* end else */
-                } /* end if */
-                else if((tmp_diminfo[curr_dim].start + tmp_diminfo[curr_dim].block)
-                        == high_start)
-                    /* Blocks border, merge them */
-                    tmp_diminfo[curr_dim].block += high_block;
-                else {
-                    /* Distinct blocks */
-                    /* Block values must be the same */
-                    if(tmp_diminfo[curr_dim].block != high_block) {
-                        space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO;
-                        break;
-                    } /* end if */
-
-                    /* Create strided selection */
-                    tmp_diminfo[curr_dim].stride = high_start - tmp_diminfo[curr_dim].start;
-                    tmp_diminfo[curr_dim].count = 2;
-                } /* end else */
-            } /* end if */
-            else {
-                /* Check if block values are the same */
-                if(tmp_diminfo[curr_dim].block != new_hyper_diminfo[curr_dim].block) {
-                    space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO;
-                    break;
-                } /* end if */
-
-                /* Check phase of strides */
-                if((tmp_diminfo[curr_dim].start % tmp_diminfo[curr_dim].stride)
-                        != (new_hyper_diminfo[curr_dim].start % tmp_diminfo[curr_dim].stride)) {
-                    space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO;
-                    break;
-                } /* end if */
-
-                /* Check operation type */
-                if(op == H5S_SELECT_OR) {
-                    /* Make sure the slabs border or overlap */
-                    if(high_start > (tmp_diminfo[curr_dim].start
-                            + (tmp_diminfo[curr_dim].count
-                            * tmp_diminfo[curr_dim].stride))) {
-                        space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO;
-                        break;
-                    } /* end if */
-                } /* end if */
-                else
-                    /* XOR: Make sure the slabs border */
-                    if(high_start != (tmp_diminfo[curr_dim].start
-                            + (tmp_diminfo[curr_dim].count
-                            * tmp_diminfo[curr_dim].stride))) {
-                        space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO;
-                        break;
-                    } /* end if */
-
-                /* Set count for combined selection */
-                tmp_diminfo[curr_dim].count = ((high_start
-                        - tmp_diminfo[curr_dim].start)
-                        / tmp_diminfo[curr_dim].stride) + high_count;
-            } /* end else */
-
-            /* Indicate that we found a nonidentical dim */
-            found_nonidentical_dim = TRUE;
-        } /* end if */
-    } /* end for */
-
-    /* Check if we succeeded, if so, set the new diminfo values */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES)
-        for(curr_dim = 0; curr_dim < space->extent.rank; curr_dim++) {
-            space->select.sel_info.hslab->app_diminfo[curr_dim].start  = space->select.sel_info.hslab->opt_diminfo[curr_dim].start = tmp_diminfo[curr_dim].start;
-            space->select.sel_info.hslab->app_diminfo[curr_dim].stride = space->select.sel_info.hslab->opt_diminfo[curr_dim].stride = tmp_diminfo[curr_dim].stride;
-            space->select.sel_info.hslab->app_diminfo[curr_dim].count  = space->select.sel_info.hslab->opt_diminfo[curr_dim].count = tmp_diminfo[curr_dim].count;
-            space->select.sel_info.hslab->app_diminfo[curr_dim].block  = space->select.sel_info.hslab->opt_diminfo[curr_dim].block = tmp_diminfo[curr_dim].block;
-        } /* end for */
-
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_update_diminfo() */
+}   /* H5S_hyper_make_spans() */
 
 
 /*--------------------------------------------------------------------------
@@ -6245,22 +5819,23 @@ static hbool_t
 H5S_hyper_rebuild_helper(const H5S_hyper_span_t *span, H5S_hyper_dim_t span_slab_info[],
     unsigned rank)
 {
-    hbool_t ret_value = TRUE;   /* Return value */
+    hsize_t curr_stride, next_stride;
+    hsize_t curr_block, next_block;
+    hsize_t curr_start;
+    hsize_t curr_low;
+    size_t outcount;
+    unsigned u;
+    H5S_hyper_dim_t      canon_down_span_slab_info[H5S_MAX_RANK];
+    hbool_t ret_value = TRUE;
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     if(span) {
-        H5S_hyper_dim_t canon_down_span_slab_info[H5S_MAX_RANK];
-        hsize_t curr_stride;
-        hsize_t curr_block;
-        hsize_t curr_start;
-        hsize_t curr_low;
-        size_t outcount;        /* Number of spans encountered in this dimension */
-
         /* Initialization */
         curr_stride     = 1;
-        curr_low        = 0;
+        curr_block      = 0;
         outcount        = 0;
+        curr_low        = 0;
 
         /* Get "canonical" down span information */
         if(span->down) {
@@ -6279,13 +5854,9 @@ H5S_hyper_rebuild_helper(const H5S_hyper_span_t *span, H5S_hyper_dim_t span_slab
 
         /* Loop the span */
         while(span) {
-            hsize_t next_stride;
-            hsize_t next_block;
-
             if(outcount > 0) {
                 if(span->down) {
-                    H5S_hyper_dim_t *curr_down_span_slab_info;
-                    unsigned u;                 /* Local index variable */
+                    H5S_hyper_dim_t      *curr_down_span_slab_info;
 
                     HDassert(span->down->head);
 
@@ -6296,7 +5867,7 @@ H5S_hyper_rebuild_helper(const H5S_hyper_span_t *span, H5S_hyper_dim_t span_slab
                     /* Compare the slab information of the adjacent spans in the down span tree.
                        We have to compare all the sub-tree slab information with the canon_down_span_slab_info.*/
 
-                    for(u = 0; u < rank - 1; u++) {
+                    for( u = 0; u < rank - 1; u++) {
                        curr_down_span_slab_info = &span_slab_info[u];
 
                        if(curr_down_span_slab_info->count > 0 && canon_down_span_slab_info[u].count > 0) {
@@ -6306,9 +5877,9 @@ H5S_hyper_rebuild_helper(const H5S_hyper_span_t *span, H5S_hyper_dim_t span_slab
                               || curr_down_span_slab_info->count != canon_down_span_slab_info[u].count)
                           HGOTO_DONE(FALSE)
                        } /* end if */
-                       else if(!((curr_down_span_slab_info->count == 0) && (canon_down_span_slab_info[u].count == 0)))
+                       else if (!((curr_down_span_slab_info->count == 0) && (canon_down_span_slab_info[u].count == 0)))
                           HGOTO_DONE(FALSE)
-                    } /* end for */
+                    }
                 } /* end if */
             } /* end if */
 
@@ -6370,19 +5941,22 @@ done:
 
  EXAMPLES
  REVISION LOG
+
     This routine is the optimization of the old version. The previous version
     can only detect a singluar selection. This version is general enough to
     detect any regular selection.
     KY, 2005/9/22
 --------------------------------------------------------------------------*/
-htri_t
+static htri_t
 H5S_hyper_rebuild(H5S_t *space)
 {
     H5S_hyper_dim_t top_span_slab_info[H5O_LAYOUT_NDIMS];
-    unsigned rank;              /* Dataspace rank */
-    htri_t ret_value = TRUE;    /* Return value */
+    H5S_hyper_dim_t *diminfo;
+    H5S_hyper_dim_t *app_diminfo;
+    unsigned rank, curr_dim;
+    htri_t ret_value = TRUE;      /* Return value */
 
-    FUNC_ENTER_NOAPI_NOERR
+    FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     /* Check args */
     HDassert(space);
@@ -6393,32 +5967,27 @@ H5S_hyper_rebuild(H5S_t *space)
 
     /* Check whether the slab can be rebuilt. Only regular selection can be rebuilt. If yes, fill in correct values.*/
     if(!H5S_hyper_rebuild_helper(space->select.sel_info.hslab->span_lst->head, top_span_slab_info, rank)) {
-        space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_IMPOSSIBLE;
         HGOTO_DONE(FALSE)
     } /* end if */
     else {
-        H5S_hyper_dim_t *opt_diminfo;   /* Convenience pointer to optimized dimension info */
-        H5S_hyper_dim_t *app_diminfo;   /* Convenience pointer to application dimension info */
-        unsigned u;                     /* Local index variable */
+        diminfo=space->select.sel_info.hslab->opt_diminfo;
+        app_diminfo=space->select.sel_info.hslab->app_diminfo;
 
-        /* Set the convenience pointers */
-        opt_diminfo = space->select.sel_info.hslab->opt_diminfo;
-        app_diminfo = space->select.sel_info.hslab->app_diminfo;
+        for(curr_dim = 0; curr_dim < rank; curr_dim++) {
+
+            app_diminfo[(rank - curr_dim) - 1].start  = diminfo[(rank - curr_dim) - 1].start = top_span_slab_info[curr_dim].start;
+            app_diminfo[(rank - curr_dim) - 1].stride = diminfo[(rank - curr_dim) - 1].stride = top_span_slab_info[curr_dim].stride;
+            app_diminfo[(rank - curr_dim) - 1].count  = diminfo[(rank - curr_dim) - 1].count = top_span_slab_info[curr_dim].count;
+            app_diminfo[(rank - curr_dim) - 1].block  = diminfo[(rank - curr_dim) - 1].block = top_span_slab_info[curr_dim].block;
 
-        /* Set the dimension info for the dataspace, from the rebuilt info */
-        for(u = 0; u < rank; u++) {
-            app_diminfo[(rank - u) - 1].start  = opt_diminfo[(rank - u) - 1].start = top_span_slab_info[u].start;
-            app_diminfo[(rank - u) - 1].stride = opt_diminfo[(rank - u) - 1].stride = top_span_slab_info[u].stride;
-            app_diminfo[(rank - u) - 1].count  = opt_diminfo[(rank - u) - 1].count = top_span_slab_info[u].count;
-            app_diminfo[(rank - u) - 1].block  = opt_diminfo[(rank - u) - 1].block = top_span_slab_info[u].block;
         } /* end for */
 
-        space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_YES;
+        space->select.sel_info.hslab->diminfo_valid = TRUE;
     } /* end else */
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_rebuild() */
+}   /* H5S_hyper_rebuild() */
 
 
 /*--------------------------------------------------------------------------
@@ -6442,12 +6011,12 @@ done:
 static herr_t
 H5S_hyper_generate_spans(H5S_t *space)
 {
-    hsize_t tmp_start[H5O_LAYOUT_NDIMS];    /* Temporary start information */
+    hsize_t tmp_start[H5O_LAYOUT_NDIMS];   /* Temporary start information */
     hsize_t tmp_stride[H5O_LAYOUT_NDIMS];   /* Temporary stride information */
     hsize_t tmp_count[H5O_LAYOUT_NDIMS];    /* Temporary count information */
     hsize_t tmp_block[H5O_LAYOUT_NDIMS];    /* Temporary block information */
-    unsigned u;                             /* Local index variable */
-    herr_t ret_value = SUCCEED;             /* Return value */
+    unsigned u;                             /* Counter */
+    herr_t      ret_value=SUCCEED;       /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
@@ -6455,367 +6024,203 @@ H5S_hyper_generate_spans(H5S_t *space)
     HDassert(H5S_GET_SELECT_TYPE(space) == H5S_SEL_HYPERSLABS);
 
     /* Get the diminfo */
-    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;
-        tmp_block[u] = space->select.sel_info.hslab->opt_diminfo[u].block;
+    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;
+        tmp_block[u]=space->select.sel_info.hslab->opt_diminfo[u].block;
     } /* end for */
 
     /* Build the hyperslab information also */
-    if(H5S_generate_hyperslab(space, H5S_SELECT_SET, tmp_start, tmp_stride, tmp_count, tmp_block) < 0)
+    if(H5S_generate_hyperslab (space, H5S_SELECT_SET, tmp_start, tmp_stride, tmp_count, tmp_block)<0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't generate hyperslabs")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_generate_spans() */
+}   /* H5S_hyper_generate_spans() */
 
-/*--------------------------------------------------------------------------
- NAME
-    H5S_hyper_update_bound_box
- PURPOSE
-    Update the bounding box of the hyperslab depending on the selection operator
- USAGE
-    herr_t H5S_hyper_update_bound_box(space, op, low_bounds, high_bounds, overlapped)
-        H5S_t *space;              IN/OUT: Dataspace containing the 1st space
-        H5S_seloper_t op;          IN: Selection operator
-        const hszie_t low_bounds;  IN: The lower bounds of the 2nd space
-        const hsize_t high_bounds; IN: The higher bounds of the 2nd space
- RETURNS
-    Non-negative on success, negative on failure
- DESCRIPTION
- GLOBAL VARIABLES
- COMMENTS, BUGS
- ASSUMPTIONS
-    This function assumes that the two bound boxes are not overlapped. If two bound
-    boxes are overlapped, the "space"'s bound box should be calculated recursively,
-    which has been done in H5S_fill_in_new_space function.
- EXAMPLES
- REVISION LOG
---------------------------------------------------------------------------*/
+#ifndef NEW_HYPERSLAB_API
+
+/*-------------------------------------------------------------------------
+ * Function:	H5S_generate_hyperlab
+ *
+ * Purpose:	Generate hyperslab information from H5S_select_hyperslab()
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Quincey Koziol (split from HS_select_hyperslab()).
+ *              Tuesday, September 12, 2000
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
 static herr_t
-H5S_hyper_update_bound_box(H5S_t *space, H5S_seloper_t op,
-    const hsize_t low_bounds[], const hsize_t high_bounds[])
+H5S_generate_hyperslab (H5S_t *space, H5S_seloper_t op,
+		      const hsize_t start[],
+		      const hsize_t stride[],
+		      const hsize_t count[],
+		      const hsize_t block[])
 {
-    herr_t ret_value = SUCCEED;         /* Return value */
+    H5S_hyper_span_info_t *new_spans=NULL;  /* Span tree for new hyperslab */
+    H5S_hyper_span_info_t *a_not_b=NULL;    /* Span tree for hyperslab spans in old span tree and not in new span tree */
+    H5S_hyper_span_info_t *a_and_b=NULL;    /* Span tree for hyperslab spans in both old and new span trees */
+    H5S_hyper_span_info_t *b_not_a=NULL;    /* Span tree for hyperslab spans in new span tree and not in old span tree */
+    herr_t      ret_value=SUCCEED;       /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
+    /* Check args */
     HDassert(space);
-    HDassert(H5S_GET_SELECT_TYPE(space) == H5S_SEL_HYPERSLABS);
+    HDassert(op > H5S_SELECT_NOOP && op < H5S_SELECT_INVALID);
+    HDassert(start);
+    HDassert(stride);
+    HDassert(count);
+    HDassert(block);
 
-    /* The offset of the dataspace is ignored here */
-    switch(op) {
-        case H5S_SELECT_OR:
-        case H5S_SELECT_XOR:
-            {
-                unsigned u;     /* Local index variable */
+    /* Generate span tree for new hyperslab information */
+    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")
 
-                for(u = 0; u < space->extent.rank; u++) {
-                    /* choose the smaller value for the low bound as the op is (X)OR */
-                    space->select.low_bounds[u] = MIN(low_bounds[u], space->select.low_bounds[u]);
+    /* Generate list of blocks to add/remove based on selection operation */
+    if(op==H5S_SELECT_SET) {
+        /* Add new spans to current selection */
+        if(H5S_hyper_merge_spans(space,new_spans,TRUE)<0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs")
 
-                    /* choose the larger value for the high bound as the op is (X)OR */
-                    space->select.high_bounds[u] = MAX(high_bounds[u], space->select.high_bounds[u]);
-                } /* end for */
-            }
-            break;
+        /* Set the number of elements in current selection */
+        space->select.num_elem=H5S_hyper_spans_nelem(new_spans);
 
-        case H5S_SELECT_AND:
-            {
-                hsize_t tmp = HSIZET_MAX;
+        /* Indicate that the new_spans are owned */
+        new_spans=NULL;
+    } /* end if */
+    else {
+        hbool_t updated_spans = FALSE;  /* Whether the spans in the selection were modified */
 
-                H5VM_array_fill(space->select.low_bounds, &tmp, sizeof(hsize_t), space->extent.rank);
-                HDmemset(space->select.high_bounds, 0, sizeof(hsize_t) * space->extent.rank);
-            }
-            break;
+        /* Generate lists of spans which overlap and don't overlap */
+        if(H5S_hyper_clip_spans(space->select.sel_info.hslab->span_lst,new_spans,&a_not_b,&a_and_b,&b_not_a)<0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information")
 
-        case H5S_SELECT_NOTB:
-            /* Since the two spaces don't overlap, the bound box needs no update */
-            break;
+        switch(op) {
+            case H5S_SELECT_OR:
+                /* Add any new spans from b_not_a to current selection */
+                if(b_not_a!=NULL) {
+                    if(H5S_hyper_merge_spans(space,b_not_a,FALSE)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs")
 
-        case H5S_SELECT_NOTA:
-            /* Since the two spaces don't overlap, the bound box is same with 2nd space */
-            HDmemcpy(space->select.low_bounds, low_bounds, sizeof(hsize_t) * space->extent.rank);
-            HDmemcpy(space->select.high_bounds, high_bounds, sizeof(hsize_t) * space->extent.rank);
-            break;
+                    /* Update the number of elements in current selection */
+                    space->select.num_elem+=H5S_hyper_spans_nelem(b_not_a);
 
-        case H5S_SELECT_NOOP:
-        case H5S_SELECT_SET:
-        case H5S_SELECT_APPEND:
-        case H5S_SELECT_PREPEND:
-        case H5S_SELECT_INVALID:
-        default:
-            HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
-    } /* end switch(op) */
+                    /* Indicate that the spans were updated */
+                    updated_spans = TRUE;
+                } /* end if */
+                break;
 
-done:
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_hyper_update_bound_box() */
+            case H5S_SELECT_AND:
+                /* Free the current selection */
+                if(H5S_hyper_free_span_info(space->select.sel_info.hslab->span_lst)<0)
+                    HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans")
+                space->select.sel_info.hslab->span_lst=NULL;
 
-
-/*--------------------------------------------------------------------------
- NAME
-    H5S_fill_in_new_space
- PURPOSE
-    Combine two span lists, one from an existing dataspace and the
-    other from input arguments, into a new selection depending on the
-    selection operator. The new selection is put into a resulting dataspace
-    which could be allocated inside the function.
- USAGE
-    herr_t H5S_fill_in_new_space(space1, op, space2_span_lst, space2_low_bound,
-                                space2_high_bound, can_own_span2,
-                                span2_owned, result)
-        H5S_t *space1;           IN: Dataspace containing the first span list
-        H5S_seloper_t op;        IN: Selection operation
-        H5S_hyper_span_info_t *space2_span_lst; IN: Second span list
-        const hsize_t *span2_low_bound; IN: The lower bound box for 2nd span list
-        const hsize_t *span2_high_bound; IN: The higher bound box for 2nd span list
-        hbool_t can_own_span2;   IN: Indicates whether the 2nd span list could be
-                                     owned by the result. If not, the 2nd span list
-                                     has to be copied.
-        hbool_t *span2_owned;  OUT: Indicates if the 2nd span list is actually owned
-        H5S_t **result;  OUT: The dataspace containing the the new selection. It
-                              could be same with the 1st dataspace.
- RETURNS
-    Non-negative on success, negative on failure
- PROGRAMMER
-    Chao Mei July 8, 2011
- GLOBAL VARIABLES
- COMMENTS, BUGS, ASSUMPTIONS
-    The function is extracted from H5S_generate_hyperslab, and then modified
-    to be general enough for hyperslab selection operations.
- EXAMPLES
- REVISION LOG
---------------------------------------------------------------------------*/
-static herr_t
-H5S_fill_in_new_space(H5S_t *space1, H5S_seloper_t op,
-    H5S_hyper_span_info_t *space2_span_lst, const hsize_t *space2_low_bound,
-    const hsize_t *space2_high_bound, hbool_t can_own_span2, hbool_t *span2_owned,
-    hbool_t *updated_spans, H5S_t **result)
-{
-    H5S_hyper_span_info_t *a_not_b = NULL;      /* Span tree for hyperslab spans in old span tree and not in new span tree */
-    H5S_hyper_span_info_t *a_and_b = NULL;      /* Span tree for hyperslab spans in both old and new span trees */
-    H5S_hyper_span_info_t *b_not_a = NULL;      /* Span tree for hyperslab spans in new span tree and not in old span tree */
-    hsize_t *space1_low_bound = space1->select.low_bounds;
-    hsize_t *space1_high_bound = space1->select.high_bounds;
-    hbool_t overlapped = FALSE;
-    hbool_t is_result_new = FALSE;
-    unsigned u;                         /* Local index variable */
-    herr_t ret_value = SUCCEED;         /* Return value */
+                /* Reset the number of items in selection */
+                space->select.num_elem=0;
 
-    FUNC_ENTER_NOAPI_NOINIT
+                /* Check if there are any overlapped selections */
+                if(a_and_b!=NULL) {
+                    if(H5S_hyper_merge_spans(space,a_and_b,TRUE)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs")
 
-    HDassert(space1);
-    HDassert(space2_span_lst);
-    HDassert(op >= H5S_SELECT_OR && op <= H5S_SELECT_NOTA);
-    /* The result is either a to-be-created space or an empty one */
-    HDassert(*result == NULL || *result == space1);
-    HDassert(space1->select.sel_info.hslab->span_lst);
-    HDassert(span2_owned);
-
-    /* Reset flags to return */
-    *span2_owned = FALSE;
-    *updated_spans = FALSE;
-
-    /* The result shares the same info from space1 */
-    if(*result == NULL) {
-        if(NULL == ((*result) = H5S_copy(space1, TRUE, TRUE)))
-            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to copy dataspace")
-        space1->select.sel_info.hslab->span_lst->count--;
-        (*result)->select.sel_info.hslab->span_lst = NULL;
-        is_result_new = TRUE;
-    } /* end if */
+                    /* Update the number of elements in current selection */
+                    space->select.num_elem=H5S_hyper_spans_nelem(a_and_b);
 
-    /* Check bound box of both spaces to see if they overlap or border */
-    for(u = 0; u < space1->extent.rank; u++) {
-        /*
-         * Three conditions for overlapping/bordering:
-         * 1. the lower bound of the new span is between the lower and
-         * higher bound of the existing one. In other words, the left
-         * part of new span will at least overlap or border with the
-         * existing one.
-         * 2. the higher bound of the new span is between the lower and
-         * higher bound of the exisiting one. In other words, the right
-         * part of new span will at least overlap or border with the
-         * existing one.
-         * 3. The new span includes the existing one where the lower bound
-         * is smaller than that of the existing one, and the higher bound
-         * is larger than that of the existing one.
-         */
-            /* condition 1 */
-        if((space1_low_bound[u] >= space2_low_bound[u] &&
-                    space1_low_bound[u] <= (space2_high_bound[u] + 1)) ||
-                /* condition 2 */
-               ((space1_high_bound[u] + 1) >= space2_low_bound[u] &&
-                    space1_high_bound[u] <= space2_high_bound[u]) ||
-                /* condition 3 */
-               (space1_low_bound[u] < space2_low_bound[u] &&
-                    space1_high_bound[u] > space2_high_bound[u])) {
-            overlapped = TRUE;
-            break;
-        } /* end if */
-    } /* end for */
+                    /* Indicate that the a_and_b spans are owned */
+                    a_and_b=NULL;
 
-    /* If two spans are disjoint in terms of bound box, then work could be much simplified. */
-    if(!overlapped) {
-        switch(op) {
-            case H5S_SELECT_OR:
-            case H5S_SELECT_XOR:
-                /* Add the new disjoint spans to the space */
-                /* A copy of space1's spans to *result, and another copy of space2's spans */
-                if(is_result_new)
-                    (*result)->select.sel_info.hslab->span_lst = H5S_hyper_copy_span(space1->select.sel_info.hslab->span_lst);
-                if(!can_own_span2) {
-                    b_not_a = H5S_hyper_copy_span(space2_span_lst);
-                    if(H5S_hyper_add_disjoint_spans(*result, b_not_a) < 0)
-                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't append hyperslabs")
-
-                    /* The new_spans is now owned by space, so its memory space should not be released */
-                    b_not_a = NULL;
+                    /* Indicate that the spans were updated */
+                    updated_spans = TRUE;
                 } /* end if */
-                else {
-                    if(H5S_hyper_add_disjoint_spans(*result, space2_span_lst) < 0)
-                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't append hyperslabs")
-                    *span2_owned = TRUE;
-                } /* end else */
-
-                /* Indicate that the spans changed */
-                *updated_spans = TRUE;
                 break;
 
-            case H5S_SELECT_AND:
-                /* Convert *result to "none" selection */
-                if(H5S_select_none(*result) < 0)
-                    HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection")
-                HGOTO_DONE(SUCCEED);
+            case H5S_SELECT_XOR:
+                /* Free the current selection */
+                if(H5S_hyper_free_span_info(space->select.sel_info.hslab->span_lst)<0)
+                    HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans")
+                space->select.sel_info.hslab->span_lst=NULL;
 
-            case H5S_SELECT_NOTB:
-                /* Copy space1's spans to *result */
-                if(is_result_new)
-                    (*result)->select.sel_info.hslab->span_lst = H5S_hyper_copy_span(space1->select.sel_info.hslab->span_lst);
+                /* Reset the number of items in selection */
+                space->select.num_elem=0;
 
-                /* Indicate that the spans changed */
-                *updated_spans = TRUE;
-                break;
+                /* Check if there are any non-overlapped selections */
+                if(a_not_b!=NULL) {
+                    if(H5S_hyper_merge_spans(space,a_not_b,FALSE)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs")
 
-            case H5S_SELECT_NOTA:
-                if(!is_result_new) {
-                    HDassert(space1 == *result);
+                    /* Update the number of elements in current selection */
+                    space->select.num_elem=H5S_hyper_spans_nelem(a_not_b);
 
-                    /* Free the current selection */
-                    if(H5S_hyper_free_span_info(space1->select.sel_info.hslab->span_lst) < 0)
-                        HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans")
+                    /* Indicate that the spans were updated */
+                    updated_spans = TRUE;
                 } /* end if */
+                if(b_not_a!=NULL) {
+                    if(H5S_hyper_merge_spans(space,b_not_a,FALSE)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs")
 
-                /* Copy space2's spans to *result */
-                if(!can_own_span2)
-                    (*result)->select.sel_info.hslab->span_lst = H5S_hyper_copy_span(space2_span_lst);
-                else {
-                    (*result)->select.sel_info.hslab->span_lst = space2_span_lst;
-                    *span2_owned = TRUE;
-                } /* end else */
-
-                /* Reset the number of items in selection */
-                (*result)->select.num_elem = H5S_hyper_spans_nelem(space2_span_lst);
+                    /* Update the number of elements in current selection */
+                    space->select.num_elem+=H5S_hyper_spans_nelem(b_not_a);
 
-                /* Indicate that the spans changed */
-                *updated_spans = TRUE;
+                    /* Indicate that the spans were updated */
+                    updated_spans = TRUE;
+                } /* end if */
                 break;
 
-            case H5S_SELECT_NOOP:
-            case H5S_SELECT_SET:
-            case H5S_SELECT_APPEND:
-            case H5S_SELECT_PREPEND:
-            case H5S_SELECT_INVALID:
-            default:
-                HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
-        } /* end switch */
-
-        /* update bound box of the selection result */
-        if(H5S_hyper_update_bound_box(*result, op, space2_low_bound, space2_high_bound) < 0)
-            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't update the bound box")
-    } /* end if */
-    else {
-        const hsize_t *span_a_b_bounds[4];      /* Pointers to space1 & space2 bound boxes */
-        hsize_t bounds_array[6 * H5S_MAX_RANK]; /* Array for bounding boxes */
-        hsize_t *tmp_bounds_array;              /* Temp. pointer to array for bounding boxes */
-        hsize_t tmp = HSIZET_MAX;
-        unsigned selector = 0;                  /* Select which clipping spans to generate */
+            case H5S_SELECT_NOTB:
+                /* Free the current selection */
+                if(H5S_hyper_free_span_info(space->select.sel_info.hslab->span_lst)<0)
+                    HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans")
+                space->select.sel_info.hslab->span_lst=NULL;
 
-        /* Generate mask for clip operation depending on the op */
-        switch(op) {
-            case H5S_SELECT_OR:
-                selector = H5S_HYPER_COMPUTE_B_NOT_A; /* a + b_not_a */
-                break;
+                /* Reset the number of items in selection */
+                space->select.num_elem=0;
 
-            case H5S_SELECT_XOR: /* a_not_b + b_not_a */
-                selector = H5S_HYPER_COMPUTE_A_NOT_B | H5S_HYPER_COMPUTE_B_NOT_A;
-                break;
+                /* Check if there are any non-overlapped selections */
+                if(a_not_b!=NULL) {
+                    if(H5S_hyper_merge_spans(space,a_not_b,TRUE)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs")
 
-            case H5S_SELECT_AND: /* a_and_b */
-                selector = H5S_HYPER_COMPUTE_A_AND_B;
-                break;
+                    /* Update the number of elements in current selection */
+                    space->select.num_elem=H5S_hyper_spans_nelem(a_not_b);
 
-            case H5S_SELECT_NOTB: /* a_not_b */
-                selector = H5S_HYPER_COMPUTE_A_NOT_B;
-                break;
+                    /* Indicate that the a_not_b are owned */
+                    a_not_b=NULL;
 
-            case H5S_SELECT_NOTA: /* b_not_a */
-                selector = H5S_HYPER_COMPUTE_B_NOT_A;
+                    /* Indicate that the spans were updated */
+                    updated_spans = TRUE;
+                } /* end if */
                 break;
 
-            case H5S_SELECT_NOOP:
-            case H5S_SELECT_SET:
-            case H5S_SELECT_APPEND:
-            case H5S_SELECT_PREPEND:
-            case H5S_SELECT_INVALID:
-            default:
-                HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
-        } /* end switch */
+            case H5S_SELECT_NOTA:
+                /* Free the current selection */
+                if(H5S_hyper_free_span_info(space->select.sel_info.hslab->span_lst)<0)
+                    HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans")
+                space->select.sel_info.hslab->span_lst=NULL;
 
-        /* Initialize arrays for 3 pairs of low/high bounds to default values */
-        tmp_bounds_array = bounds_array;
-        for(u = 0; u < 3; u++) {
-            /* set the bounds to be the default value */
-            H5VM_array_fill(tmp_bounds_array, &tmp, sizeof(hsize_t), space1->extent.rank);
-            tmp_bounds_array += space1->extent.rank;
-            HDmemset(tmp_bounds_array, 0, sizeof(hsize_t) * space1->extent.rank);
-            tmp_bounds_array += space1->extent.rank;
-        } /* end for */
+                /* Reset the number of items in selection */
+                space->select.num_elem=0;
 
-        /* Initialize array of pointers to space1 & space2's bound arrays */
-        span_a_b_bounds[0] = space1->select.low_bounds;
-        span_a_b_bounds[1] = space1->select.high_bounds;
-        span_a_b_bounds[2] = space2_low_bound;
-        span_a_b_bounds[3] = space2_high_bound;
+                /* Check if there are any non-overlapped selections */
+                if(b_not_a!=NULL) {
+                    if(H5S_hyper_merge_spans(space,b_not_a,TRUE)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs")
 
-        /* Generate lists of spans which overlap and don't overlap */
-        if(H5S_hyper_clip_spans(space1->select.sel_info.hslab->span_lst,
-                space2_span_lst, selector, 0, space1->extent.rank,
-                span_a_b_bounds, bounds_array, &a_not_b, &a_and_b, &b_not_a) < 0)
-            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information")
-        switch(op) {
-            case H5S_SELECT_OR:
-                if(is_result_new)
-                    (*result)->select.sel_info.hslab->span_lst = H5S_hyper_copy_span(space1->select.sel_info.hslab->span_lst);
-                break;
+                    /* Update the number of elements in current selection */
+                    space->select.num_elem=H5S_hyper_spans_nelem(b_not_a);
 
-            case H5S_SELECT_AND:
-            case H5S_SELECT_XOR:
-            case H5S_SELECT_NOTB:
-            case H5S_SELECT_NOTA:
-                if(!is_result_new) {
-                    HDassert(space1 == *result);
+                    /* Indicate that the b_not_a are owned */
+                    b_not_a=NULL;
 
-                    /* Free the current selection */
-                    if(H5S_hyper_free_span_info(space1->select.sel_info.hslab->span_lst) < 0)
-                        HGOTO_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release hyperslab spans")
-                    space1->select.sel_info.hslab->span_lst = NULL;
+                    /* Indicate that the spans were updated */
+                    updated_spans = TRUE;
                 } /* end if */
-
-                /* Reset the number of items in selection */
-                (*result)->select.num_elem = 0;
                 break;
 
             case H5S_SELECT_NOOP:
@@ -6827,110 +6232,40 @@ H5S_fill_in_new_space(H5S_t *space1, H5S_seloper_t op,
                 HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
         } /* end switch */
 
-        /* Check if there are any non-overlapped selections */
-        if(a_not_b) {
-            hsize_t *a_not_b_low_bounds = bounds_array;
-            hsize_t *a_not_b_high_bounds = bounds_array + space1->extent.rank;
-
-            /* Other than OR, the span_lst is set to NULL. And in OR, a_not_b is not needed */
-            HDassert(NULL == (*result)->select.sel_info.hslab->span_lst);
-
-            if(H5S_hyper_merge_spans(*result, a_not_b) < 0)
-                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs")
-
-            /* Update the bound box: just use a_not_b's bound box as no span tree is in result */
-            HDmemcpy((*result)->select.low_bounds, a_not_b_low_bounds, sizeof(hsize_t) * space1->extent.rank);
-            HDmemcpy((*result)->select.high_bounds, a_not_b_high_bounds, sizeof(hsize_t) * space1->extent.rank);
-
-            /* Update the number of elements in current selection */
-            (*result)->select.num_elem += H5S_hyper_spans_nelem(a_not_b);
+        /* Check if the resulting hyperslab span tree is empty */
+        if(space->select.sel_info.hslab->span_lst==NULL) {
+            H5S_hyper_span_info_t *spans;     /* Empty hyperslab span tree */
 
-            /* Indicate that the spans were updated */
-            *updated_spans = TRUE;
-
-            /* Indicate that the a_not_b spans are owned */
-            a_not_b = NULL;
-        } /* end if */
-
-        if(a_and_b) {
-            hsize_t *a_and_b_low_bounds = bounds_array + 2 * space1->extent.rank;
-            hsize_t *a_and_b_high_bounds = bounds_array + 3 * space1->extent.rank;
-
-            /**
-             * 1. Other than OR, the span_lst is set to NULL. And in OR,
-             * a_and_b is not needed
-             * 2. a_not_b will never be computed together with a_and_b
-             * because merging these two equals to a.
-             */
-            HDassert(NULL == (*result)->select.sel_info.hslab->span_lst);
+            /* Sanity check */
+            HDassert(space->select.num_elem == 0);
 
-            if(H5S_hyper_merge_spans(*result, a_and_b) < 0)
-                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs")
+            /* Allocate a span info node */
+            if((spans = H5FL_MALLOC(H5S_hyper_span_info_t))==NULL)
+                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab span")
 
-            /* Update the bound box: just use a_not_b's bound box as no span tree is in result */
-            HDmemcpy((*result)->select.low_bounds, a_and_b_low_bounds, sizeof(hsize_t) * space1->extent.rank);
-            HDmemcpy((*result)->select.high_bounds, a_and_b_high_bounds, sizeof(hsize_t) * space1->extent.rank);
+            /* Set the reference count */
+            spans->count=1;
 
-            /* Update the number of elements in current selection */
-            (*result)->select.num_elem += H5S_hyper_spans_nelem(a_and_b);
+            /* Reset the scratch pad space */
+            spans->scratch=0;
 
-            /* Indicate that the spans were updated */
-            *updated_spans = TRUE;
+            /* Set to empty tree */
+            spans->head=NULL;
 
-            /* Indicate that the a_and_b spans are owned */
-            a_and_b = NULL;
+            /* Set pointer to empty span tree */
+            space->select.sel_info.hslab->span_lst=spans;
         } /* end if */
-
-        if(b_not_a) {
-            hsize_t *b_not_a_low_bounds = bounds_array + 4 * space1->extent.rank;
-            hsize_t *b_not_a_high_bounds = bounds_array + 5 * space1->extent.rank;
-            hbool_t has_span_tree = (NULL != (*result)->select.sel_info.hslab->span_lst);
-
-            if(H5S_hyper_merge_spans(*result, b_not_a) < 0)
-                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs")
-
-            /* Update the bound box */
-            if(has_span_tree) {
-                /* Since two span trees are merged, the update on bound box is like an OR operation */
-                for(u = 0; u < space1->extent.rank; u++) {
-                    (*result)->select.low_bounds[u] = MIN((*result)->select.low_bounds[u], b_not_a_low_bounds[u]);
-                    (*result)->select.high_bounds[u] = MAX((*result)->select.high_bounds[u], b_not_a_high_bounds[u]);
-                } /* end for */
+        else {
+            /* Check if we updated the spans */
+            if(updated_spans) {
+                /* Attempt to rebuild "optimized" start/stride/count/block information.
+                 * from resulting hyperslab span tree
+                 */
+                if(H5S_hyper_rebuild(space) < 0)
+                    HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't rebuild hyperslab info")
             } /* end if */
-            else {
-                /* Just use b_not_a's bound box as no span tree is in result */
-                HDmemcpy((*result)->select.low_bounds, b_not_a_low_bounds, sizeof(hsize_t) * space1->extent.rank);
-                HDmemcpy((*result)->select.high_bounds, b_not_a_high_bounds, sizeof(hsize_t) * space1->extent.rank);
-            } /* end else */
-
-            /* Update the number of elements in current selection */
-            (*result)->select.num_elem += H5S_hyper_spans_nelem(b_not_a);
-
-            /* Indicate that the spans were updated */
-            *updated_spans = TRUE;
-
-            /* Indicate that the b_not_a spans are owned */
-            b_not_a = NULL;
-        } /* end if */
-    } /* end else for the case the new span overlaps with the old (i.e. space) */
-
-    /* Check if the spans weren't updated, and reset selection if so */
-    if(!*updated_spans) {
-        /** If updated_spans remains FALSE as in this branch, it
-         *  means the result has been cleared in cases
-         *  XOR/AND/NOTB/NOTA, and the result is a copy of the
-         *  dataspace in the case OR.
-         *
-         *  If two dataspaces have generated any of the three clipped
-         *  span trees (i.e. a_not_b, a_and_b, and b_not_a), the
-         *  updated_spans must be TRUE.
-         */
-        if(H5S_SELECT_OR != op) {
-            /* Convert *result to "none" selection */
-            if(H5S_select_none(*result) < 0)
-                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection")
         } /* end else */
-    } /* end if */
+    } /* end else */
 
 done:
     /* Free resources */
@@ -6943,108 +6278,6 @@ done:
     if(b_not_a)
         if(H5S_hyper_free_span_info(b_not_a) < 0)
             HDONE_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release temporary hyperslab spans")
-
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_fill_in_new_space() */
-
-
-/*-------------------------------------------------------------------------
- * Function:	H5S_generate_hyperlab
- *
- * Purpose:	Generate hyperslab information from H5S_select_hyperslab()
- *
- * Return:	Non-negative on success/Negative on failure
- *
- * Programmer:	Quincey Koziol
- *              Tuesday, September 12, 2000
- *
- *-------------------------------------------------------------------------
- */
-static herr_t
-H5S_generate_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
-    const hsize_t stride[], const hsize_t count[], const hsize_t block[])
-{
-    H5S_hyper_span_info_t *new_spans=NULL;  /* Span tree for new hyperslab */
-    hsize_t new_spans_low_bounds[H5S_MAX_RANK]; /* The lower bound box for the new hyperslab */
-    hsize_t new_spans_high_bounds[H5S_MAX_RANK]; /* The upper bound box for the new hyperslab */
-    unsigned u;                         /* Local index variable */
-    herr_t ret_value = SUCCEED;         /* Return value */
-
-    FUNC_ENTER_NOAPI_NOINIT
-
-    /* Check args */
-    HDassert(space);
-    HDassert(op > H5S_SELECT_NOOP && op < H5S_SELECT_INVALID);
-    HDassert(start);
-    HDassert(stride);
-    HDassert(count);
-    HDassert(block);
-
-    /* Generate span tree for new hyperslab information */
-    if(NULL == (new_spans = H5S_hyper_make_spans(space->extent.rank, start, stride, count, block)))
-        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't create hyperslab information")
-
-    /* Generate the bound box for the new hyperslab */
-    for(u = 0; u < space->extent.rank; u++) {
-        new_spans_low_bounds[u] = start[u];
-        new_spans_high_bounds[u] = new_spans_low_bounds[u] + stride[u] * (count[u] - 1) + (block[u] - 1);
-    } /* end for */
-
-    /* Generate list of blocks to add/remove based on selection operation */
-    if(op == H5S_SELECT_SET) {
-        H5S_hyper_span_info_t *existing_spans = space->select.sel_info.hslab->span_lst;
-
-        /* Add new spans to current selection */
-        if(NULL != existing_spans)
-            if(H5S_hyper_free_span_info(existing_spans) < 0)
-                HDONE_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release existing hyperslab spans")
-
-        space->select.sel_info.hslab->span_lst = new_spans;
-
-        /* Set the number of elements in current selection */
-        space->select.num_elem = H5S_hyper_spans_nelem(new_spans);
-
-        /* Update the bound box of this hyperslab */
-        HDmemcpy(space->select.low_bounds, new_spans_low_bounds, sizeof(hsize_t) * space->extent.rank);
-        HDmemcpy(space->select.high_bounds, new_spans_high_bounds, sizeof(hsize_t) * space->extent.rank);
-
-        /* Indicate that the new_spans are owned */
-        new_spans = NULL;
-    } /* end if */
-    else {
-        hbool_t new_spans_owned;
-        hbool_t updated_spans;
-
-        /* Generate new spans for space */
-        if(H5S_fill_in_new_space(space, op, new_spans, new_spans_low_bounds, new_spans_high_bounds, TRUE, &new_spans_owned, &updated_spans, &space) < 0)
-            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't generate the specified hyperslab")
-
-        /* Check if the spans were updated by H5S_fill_in_new_space */
-        if(updated_spans) {
-            H5S_hyper_dim_t new_hyper_diminfo[H5S_MAX_RANK];
-
-            /* Sanity check */
-            HDassert(space->select.sel_info.hslab->span_lst->head);
-
-            /* Build diminfo struct */
-            for(u = 0; u <space->extent.rank; u++) {
-                new_hyper_diminfo[u].start = start[u];
-                new_hyper_diminfo[u].stride = stride[u];
-                new_hyper_diminfo[u].count = count[u];
-                new_hyper_diminfo[u].block = block[u];
-            } /* end for */
-
-            /* Update space's dim info */
-            if(H5S_hyper_update_diminfo(space, op, new_hyper_diminfo) < 0)
-                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't update hyperslab info")
-        } /* end if */
-
-        /* Indicate that the new_spans are owned, there's no need to free */
-        if(new_spans_owned)
-            new_spans = NULL;
-    } /* end else */
-
-done:
     if(new_spans)
         if(H5S_hyper_free_span_info(new_spans) < 0)
             HDONE_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release temporary hyperslab spans")
@@ -7066,17 +6299,20 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
-    const hsize_t *stride, const hsize_t count[], const hsize_t *block)
+H5S_select_hyperslab (H5S_t *space, H5S_seloper_t op,
+		      const hsize_t start[],
+		      const hsize_t *stride,
+		      const hsize_t count[],
+		      const hsize_t *block)
 {
     hsize_t int_stride[H5O_LAYOUT_NDIMS];   /* Internal storage for stride information */
     hsize_t int_count[H5O_LAYOUT_NDIMS];    /* Internal storage for count information */
     hsize_t int_block[H5O_LAYOUT_NDIMS];    /* Internal storage for block information */
-    const hsize_t *opt_stride;          /* Optimized stride information */
-    const hsize_t *opt_count;           /* Optimized count information */
-    const hsize_t *opt_block;           /* Optimized block information */
-    unsigned u;                         /* Local index variable */
-    herr_t ret_value = SUCCEED;         /* Return value */
+    const hsize_t *opt_stride;      /* Optimized stride information */
+    const hsize_t *opt_count;       /* Optimized count information */
+    const hsize_t *opt_block;       /* Optimized block information */
+    unsigned u;                     /* Counters */
+    herr_t      ret_value=SUCCEED;       /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
@@ -7109,8 +6345,8 @@ H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
                 case H5S_SELECT_AND:   /* Binary "and" operation for hyperslabs */
                 case H5S_SELECT_NOTA:  /* Binary "B not A" operation for hyperslabs */
                     /* Convert to "none" selection */
-                    if(H5S_select_none(space) < 0)
-                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection")
+                    if(H5S_select_none(space)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't convert selection")
                     HGOTO_DONE(SUCCEED);
 
                 case H5S_SELECT_OR:    /* Binary "or" operation for hyperslabs */
@@ -7229,8 +6465,8 @@ H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
 
                 case H5S_SELECT_NOTA:  /* Binary "B not A" operation for hyperslabs */
                     /* Convert to "none" selection */
-                    if(H5S_select_none(space) < 0)
-                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection")
+                    if(H5S_select_none(space)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't convert selection")
                     HGOTO_DONE(SUCCEED);
 
                 case H5S_SELECT_NOOP:
@@ -7279,21 +6515,14 @@ H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
             space->select.sel_info.hslab->opt_diminfo[u].count = opt_count[u];
             space->select.sel_info.hslab->opt_diminfo[u].block = opt_block[u];
 
-            /* update bound box of the hyperslab selection */
-            space->select.low_bounds[u] = start[u];
-            space->select.high_bounds[u] = space->select.low_bounds[u] + stride[u] * (count[u] - 1) + (block[u] - 1);
-
             space->select.num_elem *= (opt_count[u] * opt_block[u]);
         } /* end for */
 
         /* Indicate that the dimension information is valid */
-        space->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_YES;
+        space->select.sel_info.hslab->diminfo_valid = TRUE;
 
         /* Indicate that there's no slab information */
         space->select.sel_info.hslab->span_lst = NULL;
-
-        /* Set selection type */
-        space->select.type = H5S_sel_hyper;
     } /* end if */
     else if(op >= H5S_SELECT_OR && op <= H5S_SELECT_NOTA) {
         /* Sanity check */
@@ -7304,9 +6533,8 @@ H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
             if(H5S_hyper_generate_spans(space) < 0)
                 HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "dataspace does not have span tree")
 
-        /* Set selection type */
-        /* (Could be overridden by resetting selection to 'none', below) */
-        space->select.type = H5S_sel_hyper;
+        /* Indicate that the regular dimensions are no longer valid */
+        space->select.sel_info.hslab->diminfo_valid = FALSE;
 
         /* Add in the new hyperslab information */
         if(H5S_generate_hyperslab(space, op, start, opt_stride, opt_count, opt_block) < 0)
@@ -7315,9 +6543,12 @@ H5S_select_hyperslab(H5S_t *space, H5S_seloper_t op, const hsize_t start[],
     else
         HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
 
+    /* Set selection type */
+    space->select.type = H5S_sel_hyper;
+
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_select_hyperslab() */
+}   /* end H5S_select_hyperslab() */
 
 
 /*--------------------------------------------------------------------------
@@ -7348,9 +6579,10 @@ done:
 --------------------------------------------------------------------------*/
 herr_t
 H5Sselect_hyperslab(hid_t space_id, H5S_seloper_t op, const hsize_t start[],
-    const hsize_t stride[], const hsize_t count[], const hsize_t block[])
+         const hsize_t stride[], const hsize_t count[], const hsize_t block[])
 {
     H5S_t *space;               /* Dataspace to modify selection of */
+    unsigned u;                 /* Local index variable */
     herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_API(FAIL)
@@ -7358,7 +6590,7 @@ H5Sselect_hyperslab(hid_t space_id, H5S_seloper_t op, const hsize_t start[],
 
     /* Check args */
     if(NULL == (space = (H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space")
     if(H5S_SCALAR == H5S_GET_EXTENT_TYPE(space))
         HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "hyperslab doesn't support H5S_SCALAR space")
     if(H5S_NULL == H5S_GET_EXTENT_TYPE(space))
@@ -7367,283 +6599,617 @@ H5Sselect_hyperslab(hid_t space_id, H5S_seloper_t op, const hsize_t start[],
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hyperslab not specified")
     if(!(op > H5S_SELECT_NOOP && op < H5S_SELECT_INVALID))
         HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
-    if(stride != NULL) {
-        unsigned u;             /* Local index variable */
-
+    if(stride!=NULL) {
         /* Check for 0-sized strides */
-        for(u = 0; u < space->extent.rank; u++) {
-            if(stride[u] == 0)
+        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 */
     } /* end if */
 
-    if(H5S_select_hyperslab(space, op, start, stride, count, block) < 0)
+    if (H5S_select_hyperslab(space, op, start, stride, count, block)<0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to set hyperslab selection")
 
 done:
     FUNC_LEAVE_API(ret_value)
 } /* end H5Sselect_hyperslab() */
+#else /* NEW_HYPERSLAB_API */ /* Works */
+
+/*-------------------------------------------------------------------------
+ * Function:	H5S_operate_hyperslab
+ *
+ * Purpose:	Combines two hyperslabs with an operation, putting the
+ *              result into a third hyperslab selection
+ *
+ * Return:	non-negative on success/NULL on failure
+ *
+ * Programmer:	Quincey Koziol
+ *              Tuesday, October 30, 2001
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+static herr_t
+H5S_operate_hyperslab (H5S_t *result, H5S_hyper_span_info_t *spans1, H5S_seloper_t op, H5S_hyper_span_info_t *spans2,
+    hbool_t can_own_span2, hbool_t *span2_owned)
+{
+    H5S_hyper_span_info_t *a_not_b=NULL;    /* Span tree for hyperslab spans in old span tree and not in new span tree */
+    H5S_hyper_span_info_t *a_and_b=NULL;    /* Span tree for hyperslab spans in both old and new span trees */
+    H5S_hyper_span_info_t *b_not_a=NULL;    /* Span tree for hyperslab spans in new span tree and not in old span tree */
+    herr_t      ret_value=SUCCEED;       /* Return value */
+
+    FUNC_ENTER_NOAPI_NOINIT
+
+    /* Check args */
+    HDassert(result);
+    HDassert(spans2);
+    HDassert(op > H5S_SELECT_NOOP && op < H5S_SELECT_INVALID);
+
+    /* Just copy the selection from spans2 if we are setting the selection */
+    /* ('space1' to 'result' aliasing happens at the next layer up) */
+    if(op==H5S_SELECT_SET) {
+        if(H5S_hyper_merge_spans(result,spans2,can_own_span2)<0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs")
+
+        /* Update the number of elements in current selection */
+        result->select.num_elem=H5S_hyper_spans_nelem(spans2);
+
+        /* Indicate that we took ownership of span2, if allowed */
+        if(can_own_span2)
+            *span2_owned=TRUE;
+    } /* end if */
+    else {
+        hbool_t updated_spans = FALSE;  /* Whether the spans in the selection were modified */
+
+        HDassert(spans1);
+
+        /* Generate lists of spans which overlap and don't overlap */
+        if(H5S_hyper_clip_spans(spans1,spans2,&a_not_b,&a_and_b,&b_not_a)<0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information")
+
+        /* Switch on the operation */
+        switch(op) {
+            case H5S_SELECT_OR:
+                /* Copy spans from spans1 to current selection */
+                if(spans1!=NULL) {
+                    if(H5S_hyper_merge_spans(result,spans1,FALSE)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs")
+
+                    /* Update the number of elements in current selection */
+                    result->select.num_elem=H5S_hyper_spans_nelem(spans1);
+                } /* end if */
+
+                /* Add any new spans from spans2 to current selection */
+                if(b_not_a!=NULL) {
+                    if(H5S_hyper_merge_spans(result,b_not_a,FALSE)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs")
+
+                    /* Update the number of elements in current selection */
+                    result->select.num_elem+=H5S_hyper_spans_nelem(b_not_a);
+
+                    /* Indicate that the spans were updated */
+                    updated_spans = TRUE;
+                } /* end if */
+                break;
+
+            case H5S_SELECT_AND:
+                /* Check if there are any overlapped selections */
+                if(a_and_b!=NULL) {
+                    if(H5S_hyper_merge_spans(result,a_and_b,TRUE)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs")
+
+                    /* Update the number of elements in current selection */
+                    result->select.num_elem=H5S_hyper_spans_nelem(a_and_b);
+
+                    /* Indicate that the result owns the a_and_b spans */
+                    a_and_b=NULL;
+
+                    /* Indicate that the spans were updated */
+                    updated_spans = TRUE;
+                } /* end if */
+                break;
+
+            case H5S_SELECT_XOR:
+                /* Check if there are any non-overlapped selections */
+                if(a_not_b!=NULL) {
+                    if(H5S_hyper_merge_spans(result,a_not_b,FALSE)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs")
+
+                    /* Update the number of elements in current selection */
+                    result->select.num_elem=H5S_hyper_spans_nelem(a_not_b);
+
+                    /* Indicate that the spans were updated */
+                    updated_spans = TRUE;
+                } /* end if */
+                if(b_not_a!=NULL) {
+                    if(H5S_hyper_merge_spans(result,b_not_a,FALSE)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs")
+
+                    /* Update the number of elements in current selection */
+                    result->select.num_elem+=H5S_hyper_spans_nelem(b_not_a);
+
+                    /* Indicate that the spans were updated */
+                    updated_spans = TRUE;
+                } /* end if */
+                break;
+
+            case H5S_SELECT_NOTB:
+                /* Check if there are any non-overlapped selections */
+                if(a_not_b!=NULL) {
+                    if(H5S_hyper_merge_spans(result,a_not_b,TRUE)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs")
+
+                    /* Update the number of elements in current selection */
+                    result->select.num_elem=H5S_hyper_spans_nelem(a_not_b);
+
+                    /* Indicate that the result owns the a_not_b spans */
+                    a_not_b=NULL;
+
+                    /* Indicate that the spans were updated */
+                    updated_spans = TRUE;
+                } /* end if */
+                break;
+
+            case H5S_SELECT_NOTA:
+                /* Check if there are any non-overlapped selections */
+                if(b_not_a!=NULL) {
+                    if(H5S_hyper_merge_spans(result,b_not_a,TRUE)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslabs")
+
+                    /* Update the number of elements in current selection */
+                    result->select.num_elem=H5S_hyper_spans_nelem(b_not_a);
+
+                    /* Indicate that the result owns the b_not_a spans */
+                    b_not_a=NULL;
+
+                    /* Indicate that the spans were updated */
+                    updated_spans = TRUE;
+                } /* end if */
+                break;
+
+            default:
+                HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
+        } /* end switch */
+
+        /* Free the hyperslab trees generated from the clipping algorithm */
+        if(a_not_b)
+            H5S_hyper_free_span_info(a_not_b);
+        if(a_and_b)
+            H5S_hyper_free_span_info(a_and_b);
+        if(b_not_a)
+            H5S_hyper_free_span_info(b_not_a);
+
+        /* Check if the resulting hyperslab span tree is empty */
+        if(result->select.sel_info.hslab->span_lst==NULL) {
+            H5S_hyper_span_info_t *spans;     /* Empty hyperslab span tree */
+
+            /* Sanity check */
+            HDassert(result->select.num_elem == 0);
+
+            /* Allocate a span info node */
+            if((spans = H5FL_MALLOC(H5S_hyper_span_info_t))==NULL)
+                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab span")
+
+            /* Set the reference count */
+            spans->count=1;
+
+            /* Reset the scratch pad space */
+            spans->scratch=0;
+
+            /* Set to empty tree */
+            spans->head=NULL;
+
+            /* Set pointer to empty span tree */
+            result->select.sel_info.hslab->span_lst=spans;
+        } /* end if */
+        else {
+            /* Check if we updated the spans */
+            if(updated_spans) {
+                /* Attempt to rebuild "optimized" start/stride/count/block information.
+                 * from resulting hyperslab span tree
+                 */
+                if(H5S_hyper_rebuild(result) < 0)
+                    HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't rebuild hyperslab info")
+            } /* end if */
+        } /* end else */
+    } /* end else */
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+}   /* end H5S_operate_hyperslab() */
 
 
-/*--------------------------------------------------------------------------
- NAME
-    H5S_fill_in_hyperslab
- PURPOSE
-    Specify a hyperslab to combine with the current hyperslab selection, and
-    store the result in the new hyperslab selection.
- USAGE
-    herr_t H5S_fill_in_hyperslab(new_space, old_space, op, start, stride, count, block)
-        H5S_t old_space;             IN: The old space the selection is performed on
-        H5S_seloper_t op;            IN: Operation to perform on current selection
-        const hsize_t *start;        IN: Offset of start of hyperslab
-        const hsize_t *stride;       IN: Hyperslab stride
-        const hsize_t *count;        IN: Number of blocks included in hyperslab
-        const hsize_t *block;        IN: Size of block in hyperslab
-        H5S_t *new_space;            OUT: The new dataspace to store the selection result
- RETURNS
-    Non-negative on success/Negative on failure
- DESCRIPTION
-    Combines a hyperslab selection with the current selection for a dataspace.
-    If STRIDE or BLOCK is NULL, they are assumed to be set to all '1'.
- GLOBAL VARIABLES
- COMMENTS, BUGS, ASSUMPTIONS
-    In some cases, the whole span tree in the old_space could be avoided from copying
-    into the new_space. In order to deal with such cases, H5S_select_hyperslab could
-    not be directly called. Otherwise, this function equals two steps:
-    1. copy the whole span tree from old_space into new_space
-    2. call H5S_select_hyperslab with the new_space.
- EXAMPLES
- REVISION LOG
---------------------------------------------------------------------------*/
+/*-------------------------------------------------------------------------
+ * Function:	H5S_generate_hyperlab
+ *
+ * Purpose:	Generate hyperslab information from H5S_select_hyperslab()
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Quincey Koziol (split from HS_select_hyperslab()).
+ *              Tuesday, September 12, 2000
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
 static herr_t
-H5S_fill_in_hyperslab(H5S_t *old_space, H5S_seloper_t op, const hsize_t start[],
-    const hsize_t *stride, const hsize_t count[], const hsize_t *block,
-    H5S_t **new_space)
+H5S_generate_hyperslab (H5S_t *space, H5S_seloper_t op,
+		      const hsize_t start[],
+		      const hsize_t stride[],
+		      const hsize_t count[],
+		      const hsize_t block[])
 {
-    unsigned u;                     /* Local index variable */
-    herr_t ret_value = SUCCEED;     /* Return value */
+    H5S_hyper_span_info_t *new_spans=NULL;   /* Span tree for new hyperslab */
+    H5S_hyper_span_info_t *tmp_spans=NULL;   /* Temporary copy of selection */
+    hbool_t span2_owned=FALSE;          /* Flag to indicate that span2 was used in H5S_operate_hyperslab() */
+    herr_t      ret_value=SUCCEED;       /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
     /* Check args */
-    HDassert(old_space);
+    HDassert(space);
+    HDassert(op > H5S_SELECT_NOOP && op < H5S_SELECT_INVALID);
     HDassert(start);
+    HDassert(stride);
     HDassert(count);
-    HDassert(op >= H5S_SELECT_SET && op <= H5S_SELECT_NOTA);
-    HDassert(new_space);
-    HDassert(*new_space == NULL);
+    HDassert(block);
+
+    /* Generate span tree for new hyperslab information */
+    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")
+
+    /* Copy the original dataspace */
+    if(space->select.sel_info.hslab->span_lst!=NULL) {
+        /* Take ownership of the dataspace's hyperslab spans */
+        /* (These are freed later) */
+        tmp_spans=space->select.sel_info.hslab->span_lst;
+        space->select.sel_info.hslab->span_lst=NULL;
+
+        /* Reset the other dataspace selection information */
+        if(H5S_SELECT_RELEASE(space)<0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't release selection")
+
+        /* Allocate space for the hyperslab selection information */
+        if((space->select.sel_info.hslab=H5FL_MALLOC(H5S_hyper_sel_t))==NULL)
+            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab info")
+    } /* end if */
+
+    /* Combine tmp_space (really space) & new_space, with the result in space */
+    if(H5S_operate_hyperslab(space,tmp_spans,op,new_spans,TRUE,&span2_owned)<0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information")
+
+done:
+    /* Free temporary data structures */
+    if(tmp_spans!=NULL)
+        if(H5S_hyper_free_span_info(tmp_spans)<0)
+            HDONE_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release temporary hyperslab spans")
+    if(new_spans!=NULL && span2_owned==FALSE)
+        if(H5S_hyper_free_span_info(new_spans)<0)
+            HDONE_ERROR(H5E_INTERNAL, H5E_CANTFREE, FAIL, "failed to release temporary hyperslab spans")
+
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5S_generate_hyperslab() */
+
+
+/*-------------------------------------------------------------------------
+ * Function:	H5S_select_hyperslab
+ *
+ * Purpose:	Internal version of H5Sselect_hyperslab().
+ *
+ * Return:	Non-negative on success/Negative on failure
+ *
+ * Programmer:	Quincey Koziol
+ *              Wednesday, January 10, 2001
+ *
+ * Modifications:
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5S_select_hyperslab (H5S_t *space, H5S_seloper_t op,
+		      const hsize_t start[],
+		      const hsize_t *stride,
+		      const hsize_t count[],
+		      const hsize_t *block)
+{
+    hsize_t int_stride[H5O_LAYOUT_NDIMS];   /* Internal storage for stride information */
+    hsize_t int_count[H5O_LAYOUT_NDIMS];    /* Internal storage for count information */
+    hsize_t int_block[H5O_LAYOUT_NDIMS];    /* Internal storage for block information */
+    const hsize_t *opt_stride;      /* Optimized stride information */
+    const hsize_t *opt_count;       /* Optimized count information */
+    const hsize_t *opt_block;       /* Optimized block information */
+    unsigned u;                    /* Counters */
+    herr_t      ret_value=SUCCEED;       /* Return value */
+
+    FUNC_ENTER_NOAPI(FAIL)
+
+    /* Check args */
+    HDassert(space);
+    HDassert(start);
+    HDassert(count);
+    HDassert(op > H5S_SELECT_NOOP && op < H5S_SELECT_INVALID);
 
     /* Point to the correct stride values */
-    if(stride == NULL)
+    if(stride==NULL)
         stride = _ones;
 
     /* Point to the correct block values */
-    if(block == NULL)
+    if(block==NULL)
         block = _ones;
 
-    /* Check new selection. */
-    for(u = 0; u < old_space->extent.rank; u++) {
+    /*
+     * Check new selection.
+     */
+    for(u=0; u<space->extent.rank; u++) {
         /* Check for overlapping hyperslab blocks in new selection. */
-        if(count[u] > 1 && stride[u] < block[u])
+        if(count[u]>1 && stride[u]<block[u])
             HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hyperslab blocks overlap")
 
         /* Detect zero-sized hyperslabs in new selection */
         if(count[u] == 0 || block[u] == 0) {
             switch(op) {
+                case H5S_SELECT_SET:   /* Select "set" operation */
                 case H5S_SELECT_AND:   /* Binary "and" operation for hyperslabs */
                 case H5S_SELECT_NOTA:  /* Binary "B not A" operation for hyperslabs */
                     /* Convert to "none" selection */
-                    /* Copy the first dataspace without sharing the list of spans */
-                    if(NULL == ((*new_space) = H5S_copy(old_space, TRUE, TRUE)))
-                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to copy dataspace")
-                    if(H5S_select_none((*new_space)) < 0)
-                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection")
+                    if(H5S_select_none(space)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't convert selection")
                     HGOTO_DONE(SUCCEED);
 
                 case H5S_SELECT_OR:    /* Binary "or" operation for hyperslabs */
                 case H5S_SELECT_XOR:   /* Binary "xor" operation for hyperslabs */
                 case H5S_SELECT_NOTB:  /* Binary "A not B" operation for hyperslabs */
-                    /* Copy the first dataspace with sharing the list of spans */
-                    if(NULL == ((*new_space) = H5S_copy(old_space, FALSE, TRUE)))
-                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to copy dataspace")
                     HGOTO_DONE(SUCCEED);        /* Selection stays same */
 
-                case H5S_SELECT_NOOP:
-                case H5S_SELECT_SET:
-                case H5S_SELECT_APPEND:
-                case H5S_SELECT_PREPEND:
-                case H5S_SELECT_INVALID:
                 default:
                     HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
             } /* end switch */
         } /* end if */
     } /* end for */
 
-    if(H5S_GET_SELECT_TYPE(old_space) == H5S_SEL_HYPERSLABS) {
-        hsize_t new_low_bound[H5S_MAX_RANK];
-        hsize_t new_high_bound[H5S_MAX_RANK];
-        hbool_t overlapped = FALSE;
-
-        /* Generate bounding box for hyperslab parameters */
-        for(u = 0; u < old_space->extent.rank; u++) {
-            new_low_bound[u] = start[u];
-            new_high_bound[u] = new_low_bound[u] + stride[u] * (count[u]-1) + (block[u]-1);
-        } /* end for */
-
-        /* Check bounding box to see if two are disjoint */
-        for(u = 0; u < old_space->extent.rank; u++) {
-            /* Note: offset of this old_space is neglected */
-            hsize_t old_low_bound = old_space->select.low_bounds[u];
-            hsize_t old_high_bound = old_space->select.high_bounds[u];
-
-            /* The following condition tests are copied from H5S_fill_in_new_space */
-            if((new_low_bound[u] >= old_low_bound && new_low_bound[u] <= old_high_bound) ||
-                   (new_high_bound[u] >= old_low_bound && new_high_bound[u] <= old_high_bound) ||
-                   (new_low_bound[u] <= old_low_bound && new_high_bound[u] >= old_high_bound)) {
-                overlapped = TRUE;
-                break;
+    /* Optimize hyperslab parameters to merge contiguous blocks, etc. */
+    if(stride == _ones && block == _ones) {
+        /* Point to existing arrays */
+        opt_stride = _ones;
+        opt_count = _ones;
+        opt_block = count;
+    } /* end if */
+    else {
+        /* Point to local arrays */
+        opt_stride = int_stride;
+        opt_count = int_count;
+        opt_block = int_block;
+        for(u=0; u<space->extent.rank; u++) {
+            /* contiguous hyperslabs have the block size equal to the stride */
+            if(stride[u]==block[u]) {
+                int_count[u]=1;
+                int_stride[u]=1;
+                if(block[u]==1)
+                    int_block[u]=count[u];
+                else
+                    int_block[u]=block[u]*count[u];
             } /* end if */
+            else {
+                if(count[u]==1)
+                    int_stride[u]=1;
+                else {
+                    HDassert(stride[u] > block[u]);
+                    int_stride[u]=stride[u];
+                } /* end else */
+                int_count[u]=count[u];
+                int_block[u]=block[u];
+            } /* end else */
         } /* end for */
+    } /* end else */
 
-        if(!overlapped) {
-            H5S_hyper_span_info_t *new_spans = NULL;
-            H5S_hyper_dim_t new_hyper_diminfo[H5S_MAX_RANK];
+    /* Fixup operation for non-hyperslab selections */
+    switch(H5S_GET_SELECT_TYPE(space)) {
+        case H5S_SEL_NONE:   /* No elements selected in dataspace */
+            switch(op) {
+                case H5S_SELECT_SET:   /* Select "set" operation */
+                    /* Change "none" selection to hyperslab selection */
+                    break;
 
-            if(NULL == ((*new_space) = H5S_copy(old_space, TRUE, TRUE)))
-                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to copy dataspace")
-            if(NULL != (*new_space)->select.sel_info.hslab->span_lst) {
-                old_space->select.sel_info.hslab->span_lst->count--;
-                (*new_space)->select.sel_info.hslab->span_lst = NULL;
-            } /* end if */
+                case H5S_SELECT_OR:    /* Binary "or" operation for hyperslabs */
+                case H5S_SELECT_XOR:   /* Binary "xor" operation for hyperslabs */
+                case H5S_SELECT_NOTA:  /* Binary "B not A" operation for hyperslabs */
+                    op=H5S_SELECT_SET; /* Maps to "set" operation when applied to "none" selection */
+                    break;
+
+                case H5S_SELECT_AND:   /* Binary "and" operation for hyperslabs */
+                case H5S_SELECT_NOTB:  /* Binary "A not B" operation for hyperslabs */
+                    HGOTO_DONE(SUCCEED);        /* Selection stays "none" */
+
+                default:
+                    HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
+            } /* end switch */
+            break;
 
-            /* Generate hyperslab info for new space */
+        case H5S_SEL_ALL:    /* All elements selected in dataspace */
             switch(op) {
-                case H5S_SELECT_OR:
-                case H5S_SELECT_XOR:
-                    /* Add the new space to the space */
-                    if(NULL == (new_spans = H5S_hyper_make_spans(old_space->extent.rank, start, stride, count, block)))
-                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't create hyperslab information")
-                    if(NULL != old_space->select.sel_info.hslab->span_lst)
-                        (*new_space)->select.sel_info.hslab->span_lst = H5S_hyper_copy_span(old_space->select.sel_info.hslab->span_lst);
-                    if(H5S_hyper_add_disjoint_spans(*new_space, new_spans) < 0)
-                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't append hyperslabs")
+                case H5S_SELECT_SET:   /* Select "set" operation */
+                    /* Change "all" selection to hyperslab selection */
                     break;
 
-                case H5S_SELECT_AND:
-                    if(H5S_select_none((*new_space)) < 0)
-                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection")
-                    HGOTO_DONE(SUCCEED);
+                case H5S_SELECT_OR:    /* Binary "or" operation for hyperslabs */
+                    HGOTO_DONE(SUCCEED);        /* Selection stays "all" */
 
-                case H5S_SELECT_NOTB:
-                    if(old_space->select.sel_info.hslab->span_lst != NULL)
-                        (*new_space)->select.sel_info.hslab->span_lst = H5S_hyper_copy_span(old_space->select.sel_info.hslab->span_lst);
-                    else {
-                        if(H5S_select_none((*new_space)) < 0)
-                            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't convert selection")
-                        HGOTO_DONE(SUCCEED);
-                    } /* end else */
+                case H5S_SELECT_AND:   /* Binary "and" operation for hyperslabs */
+                    op=H5S_SELECT_SET; /* Maps to "set" operation when applied to "none" selection */
                     break;
 
-                case H5S_SELECT_NOTA:
-                    if(NULL == (new_spans = H5S_hyper_make_spans(old_space->extent.rank, start, stride, count, block)))
-                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't create hyperslab information")
-                    (*new_space)->select.sel_info.hslab->span_lst = new_spans;
-                    (*new_space)->select.num_elem = H5S_hyper_spans_nelem(new_spans);
+                case H5S_SELECT_XOR:   /* Binary "xor" operation for hyperslabs */
+                case H5S_SELECT_NOTB:  /* Binary "A not B" operation for hyperslabs */
+                    /* Convert current "all" selection to "real" hyperslab selection */
+                    /* Then allow operation to proceed */
+                    {
+                        hsize_t tmp_start[H5O_LAYOUT_NDIMS];   /* Temporary start information */
+                        hsize_t tmp_stride[H5O_LAYOUT_NDIMS];   /* Temporary stride information */
+                        hsize_t tmp_count[H5O_LAYOUT_NDIMS];    /* Temporary count information */
+                        hsize_t tmp_block[H5O_LAYOUT_NDIMS];    /* Temporary block information */
+
+                        /* Fill in temporary information for the dimensions */
+                        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.size[u];
+                        } /* end for */
+
+                        /* Convert to hyperslab selection */
+                        if(H5S_select_hyperslab(space,H5S_SELECT_SET,tmp_start,tmp_stride,tmp_count,tmp_block)<0)
+                            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't convert selection")
+                    } /* end case */
                     break;
 
-                case H5S_SELECT_NOOP:
-                case H5S_SELECT_SET:
-                case H5S_SELECT_APPEND:
-                case H5S_SELECT_PREPEND:
-                case H5S_SELECT_INVALID:
+                case H5S_SELECT_NOTA:  /* Binary "B not A" operation for hyperslabs */
+                    /* Convert to "none" selection */
+                    if(H5S_select_none(space)<0)
+                        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't convert selection")
+                    HGOTO_DONE(SUCCEED);
+
                 default:
                     HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
             } /* end switch */
+            break;
 
-            /* Update bound box */
-            if(H5S_hyper_update_bound_box(*new_space, op, new_low_bound, new_high_bound)<0)
-                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't update the bound box")
+        case H5S_SEL_HYPERSLABS:
+            /* Hyperslab operation on hyperslab selection, OK */
+            break;
 
-            /* Build diminfo struct */
-            for(u = 0; u < (*new_space)->extent.rank; u++) {
-                new_hyper_diminfo[u].start = start[u];
-                new_hyper_diminfo[u].stride = stride[u];
-                new_hyper_diminfo[u].count = count[u];
-                new_hyper_diminfo[u].block = block[u];
-            } /* end for */
+        case H5S_SEL_POINTS: /* Can't combine hyperslab operations and point selections currently */
+            if(op==H5S_SELECT_SET)      /* Allow only "set" operation to proceed */
+                break;
+            /* Else fall through to error */
 
-            /* Update space's dim info */
-            if(H5S_hyper_update_diminfo(*new_space, op, new_hyper_diminfo) < 0)
-                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't update hyperslab info")
+        default:
+            HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
+    } /* end switch */
 
-            HGOTO_DONE(SUCCEED);
-        } /* end if(!overlapped) */
-    } /* end if the selection of old space is H5S_SEL_HYPERSLABS*/
 
-    /* Copy the first dataspace with sharing the list of spans */
-    if(NULL == ((*new_space) = H5S_copy(old_space, FALSE, TRUE)))
-        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to copy dataspace")
+    if(op==H5S_SELECT_SET) {
+        /* If we are setting a new selection, remove current selection first */
+        if(H5S_SELECT_RELEASE(space)<0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't release hyperslab")
 
-    /* Note: a little overhead in calling the function as some conditions are checked again */
-    if(H5S_select_hyperslab(*new_space, op, start, stride, count, block) < 0)
-        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to set hyperslab selection")
+        /* Allocate space for the hyperslab selection information */
+        if((space->select.sel_info.hslab=H5FL_MALLOC(H5S_hyper_sel_t))==NULL)
+            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab info")
+
+        /* Save the diminfo */
+        space->select.num_elem=1;
+        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];
+            space->select.sel_info.hslab->app_diminfo[u].block = block[u];
+
+            space->select.sel_info.hslab->opt_diminfo[u].start = start[u];
+            space->select.sel_info.hslab->opt_diminfo[u].stride = opt_stride[u];
+            space->select.sel_info.hslab->opt_diminfo[u].count = opt_count[u];
+            space->select.sel_info.hslab->opt_diminfo[u].block = opt_block[u];
+
+            space->select.num_elem*=(opt_count[u]*opt_block[u]);
+        } /* end for */
+
+        /* Indicate that the dimension information is valid */
+        space->select.sel_info.hslab->diminfo_valid=TRUE;
+
+        /* Indicate that there's no slab information */
+        space->select.sel_info.hslab->span_lst=NULL;
+    } /* end if */
+    else if(op>=H5S_SELECT_OR && op<=H5S_SELECT_NOTA) {
+        /* Sanity check */
+        HDassert(H5S_GET_SELECT_TYPE(space) == H5S_SEL_HYPERSLABS);
+
+        /* Check if there's no hyperslab span information currently */
+        if(space->select.sel_info.hslab->span_lst==NULL)
+            if(H5S_hyper_generate_spans(space)<0)
+                HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "dataspace does not have span tree")
+
+        /* Add in the new hyperslab information */
+        if(H5S_generate_hyperslab (space, op, start, opt_stride, opt_count, opt_block)<0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't generate hyperslabs")
+
+        /* Indicate that the regular dimensions are no longer valid */
+        space->select.sel_info.hslab->diminfo_valid=FALSE;
+    } /* end if */
+    else
+        HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
+
+    /* Set selection type */
+    space->select.type=H5S_sel_hyper;
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_fill_in_hyperslab() */
+}   /* end H5S_select_hyperslab() */
 
 
-/*-------------------------------------------------------------------------
- * Function:	H5S_fill_in_select
- *
- * Purpose:	Combines two hyperslabs with an operation, putting the
- *              result into a third hyperslab selection
- *
- * Return:	non-negative on success/NULL on failure
- *
- * Programmer:	Chao Mei
- *              Tuesday, July 5, 2011
- *
- *-------------------------------------------------------------------------
- */
-static herr_t
-H5S_fill_in_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2, H5S_t **result)
+/*--------------------------------------------------------------------------
+ NAME
+    H5Sselect_hyperslab
+ PURPOSE
+    Specify a hyperslab to combine with the current hyperslab selection
+ USAGE
+    herr_t H5Sselect_hyperslab(dsid, op, start, stride, count, block)
+        hid_t dsid;             IN: Dataspace ID of selection to modify
+        H5S_seloper_t op;       IN: Operation to perform on current selection
+        const hsize_t *start;        IN: Offset of start of hyperslab
+        const hsize_t *stride;       IN: Hyperslab stride
+        const hsize_t *count;        IN: Number of blocks included in hyperslab
+        const hsize_t *block;        IN: Size of block in hyperslab
+ RETURNS
+    Non-negative on success/Negative on failure
+ DESCRIPTION
+    Combines a hyperslab selection with the current selection for a dataspace.
+    If the current selection is not a hyperslab, it is freed and the hyperslab
+    parameters passed in are combined with the H5S_SEL_ALL hyperslab (ie. a
+    selection composing the entire current extent).  If STRIDE or BLOCK is
+    NULL, they are assumed to be set to all '1'.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+herr_t
+H5Sselect_hyperslab(hid_t space_id, H5S_seloper_t op, const hsize_t start[],
+         const hsize_t stride[], const hsize_t count[], const hsize_t block[])
 {
-    hbool_t span2_owned;
-    hbool_t updated_spans;
-    herr_t ret_value = SUCCEED;         /* Return value */
+    H5S_t	*space = NULL;  /* Dataspace to modify selection of */
+    herr_t      ret_value=SUCCEED;       /* Return value */
 
-    FUNC_ENTER_NOAPI_NOINIT
+    FUNC_ENTER_API(FAIL)
+    H5TRACE6("e", "iSs*h*h*h*h", space_id, op, start, stride, count, block);
 
-    /* Sanity check */
-    HDassert(space1);
-    HDassert(space2);
-    HDassert(op >= H5S_SELECT_OR && op <= H5S_SELECT_NOTA);
-    HDassert(space1->extent.rank == space2->extent.rank);
-    /* The result is either a to-be-created space or an empty one */
-    HDassert(NULL == *result || *result == space1);
-    HDassert(space1->select.sel_info.hslab->span_lst);
-    HDassert(space2->select.sel_info.hslab->span_lst);
-
-    /* Note: the offset of space2 is not considered here for bounding box */
-    if(H5S_fill_in_new_space(space1, op, space2->select.sel_info.hslab->span_lst, space2->select.low_bounds, space2->select.high_bounds, FALSE, &span2_owned, &updated_spans, result) < 0)
-        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTSELECT, FAIL, "can't create the specified selection")
-
-    /* Update diminfo if space2's diminfo was valid, otherwise just mark it as
-     * invalid if the spans were updated */
-    HDassert(result);
-    if(updated_spans) {
-        if(space2->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
-            if(H5S_hyper_update_diminfo(*result, op, space2->select.sel_info.hslab->opt_diminfo) < 0)
-                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCOUNT, FAIL, "can't update hyperslab info")
-        } /* end if */
-        else
-            (*result)->select.sel_info.hslab->diminfo_valid = H5S_DIMINFO_VALID_NO;
+    /* Check args */
+    if (NULL == (space=H5I_object_verify(space_id, H5I_DATASPACE)))
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space")
+    if (H5S_SCALAR==H5S_GET_EXTENT_TYPE(space))
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "hyperslab doesn't support H5S_SCALAR space")
+    if (H5S_NULL==H5S_GET_EXTENT_TYPE(space))
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "hyperslab doesn't support H5S_NULL space")
+    if(start==NULL || count==NULL)
+        HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hyperslab not specified")
+    if(!(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID))
+        HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
+    if(stride!=NULL) {
+        unsigned u;             /* Local index variable */
+
+        /* Check for 0-sized strides */
+        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 */
     } /* end if */
 
+    if (H5S_select_hyperslab(space, op, start, stride, count, block)<0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to set hyperslab selection")
+
 done:
-    FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_fill_in_select() */
+    FUNC_LEAVE_API(ret_value)
+} /* end H5Sselect_hyperslab() */
 
 
 /*--------------------------------------------------------------------------
@@ -7677,33 +7243,38 @@ done:
 --------------------------------------------------------------------------*/
 hid_t
 H5Scombine_hyperslab(hid_t space_id, H5S_seloper_t op, const hsize_t start[],
-    const hsize_t stride[], const hsize_t count[], const hsize_t block[])
+         const hsize_t stride[], const hsize_t count[], const hsize_t block[])
 {
-    H5S_t	*space;                 /* Dataspace to modify selection of */
-    H5S_t	*new_space = NULL;      /* New dataspace created */
-    hid_t	ret_value;              /* Return value */
+    H5S_t	*space = NULL;  /* Dataspace to modify selection of */
+    H5S_t	*new_space = NULL;  /* New dataspace created */
+    hid_t	ret_value;
 
     FUNC_ENTER_API(FAIL)
     H5TRACE6("i", "iSs*h*h*h*h", space_id, op, start, stride, count, block);
 
     /* Check args */
-    if(NULL == (space = (H5S_t *)H5I_object_verify(space_id, H5I_DATASPACE)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")
-    if(start == NULL || count == NULL)
+    if (NULL == (space=H5I_object_verify(space_id, H5I_DATASPACE)))
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space")
+    if(start==NULL || count==NULL)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "hyperslab not specified")
-    if(!(op >= H5S_SELECT_SET && op <= H5S_SELECT_NOTA))
+
+    if(!(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID))
         HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
 
-    /* Generate new space, with combination of selections */
-    if(H5S_fill_in_hyperslab(space, op, start, stride, count, block, &new_space) < 0)
+    /* Copy the first dataspace */
+    if (NULL == (new_space = H5S_copy (space, TRUE, TRUE)))
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, NULL, "unable to copy data space")
+
+    /* Go modify the selection in the new dataspace */
+    if (H5S_select_hyperslab(new_space, op, start, stride, count, block)<0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to set hyperslab selection")
 
     /* Atomize */
-    if((ret_value = H5I_register(H5I_DATASPACE, new_space, TRUE)) < 0)
+    if ((ret_value=H5I_register (H5I_DATASPACE, new_space, TRUE))<0)
         HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register dataspace atom")
 
 done:
-    if(ret_value < 0 && new_space)
+    if (ret_value<0 && new_space)
         H5S_close(new_space);
 
     FUNC_LEAVE_API(ret_value)
@@ -7720,62 +7291,57 @@ done:
  * Programmer:	Quincey Koziol
  *              Tuesday, October 30, 2001
  *
- *              Chao Mei
- *              Wednesday, June 29, 2011
+ * Modifications:
  *
  *-------------------------------------------------------------------------
  */
 static H5S_t *
-H5S_combine_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2)
+H5S_combine_select (H5S_t *space1, H5S_seloper_t op, H5S_t *space2)
 {
-    H5S_t *new_space = NULL;    /* New dataspace generated */
-    H5S_t *ret_value = NULL;    /* Return value */
+    H5S_t *new_space=NULL;    /* New dataspace generated */
+    hbool_t span2_owned=FALSE;          /* Flag to indicate that span2 was used in H5S_operate_hyperslab() */
+    H5S_t *ret_value;         /* return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
     /* Check args */
     HDassert(space1);
     HDassert(space2);
-    HDassert(op >= H5S_SELECT_OR && op <= H5S_SELECT_NOTA);
+    HDassert(op > H5S_SELECT_NOOP && op < H5S_SELECT_INVALID);
 
-    /* Check that if space1 selections has span trees */
-    if(NULL == space1->select.sel_info.hslab->span_lst)
-        if(H5S_hyper_generate_spans(space1) < 0)
+    /* Check that the space selections both have span trees */
+    if(space1->select.sel_info.hslab->span_lst==NULL)
+        if(H5S_hyper_generate_spans(space1)<0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, NULL, "dataspace does not have span tree")
+    if(space2->select.sel_info.hslab->span_lst==NULL)
+        if(H5S_hyper_generate_spans(space2)<0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, NULL, "dataspace does not have span tree")
 
-    if(NULL == space2->select.sel_info.hslab->span_lst) {
-        hsize_t tmp_start[H5S_MAX_RANK];
-        hsize_t tmp_stride[H5S_MAX_RANK];
-        hsize_t tmp_count[H5S_MAX_RANK];
-        hsize_t tmp_block[H5S_MAX_RANK];
-        unsigned u;
-
-        for(u = 0; u < space2->extent.rank; u++) {
-            tmp_start[u] = space2->select.sel_info.hslab->opt_diminfo[u].start;
-            tmp_stride[u] = space2->select.sel_info.hslab->opt_diminfo[u].stride;
-            tmp_count[u] = space2->select.sel_info.hslab->opt_diminfo[u].count;
-            tmp_block[u] = space2->select.sel_info.hslab->opt_diminfo[u].block;
-        } /* end for */
+    /* Copy the first dataspace */
+    if (NULL == (new_space = H5S_copy (space1, TRUE, TRUE)))
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, NULL, "unable to copy data space")
 
-        /* call H5S_select_hyperslab directly */
-        if(H5S_fill_in_hyperslab(space1, op, tmp_start, tmp_stride, tmp_count, tmp_block, &new_space) < 0)
-            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, NULL, "unable to set hyperslab selection")
-    } /* end if */
-    else{
-        /* Combine new_space (a copy of space 1) & space2, with the result in new_space */
-        if(H5S_fill_in_select(space1, op, space2, &new_space) < 0)
-            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, NULL, "can't clip hyperslab information")
-    } /* end else */
+    /* Free the current selection for the new dataspace */
+    if(H5S_SELECT_RELEASE(new_space)<0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, NULL, "can't release selection")
+
+    /* Allocate space for the hyperslab selection information */
+    if((new_space->select.sel_info.hslab=H5FL_CALLOC(H5S_hyper_sel_t))==NULL)
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "can't allocate hyperslab info")
+
+    /* Combine space1 & space2, with the result in new_space */
+    if(H5S_operate_hyperslab(new_space,space1->select.sel_info.hslab->span_lst,op,space2->select.sel_info.hslab->span_lst,FALSE,&span2_owned)<0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, NULL, "can't clip hyperslab information")
 
     /* Set return value */
-    ret_value = new_space;
+    ret_value=new_space;
 
 done:
-    if(ret_value == NULL && new_space)
+    if(ret_value==NULL && new_space!=NULL)
         H5S_close(new_space);
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_combine_select() */
+}   /* end H5S_combine_select() */
 
 
 /*--------------------------------------------------------------------------
@@ -7806,47 +7372,37 @@ H5Scombine_select(hid_t space1_id, H5S_seloper_t op, hid_t space2_id)
     H5S_t	*space1;                /* First Dataspace */
     H5S_t	*space2;                /* Second Dataspace */
     H5S_t	*new_space = NULL;      /* New Dataspace */
-    hid_t	ret_value;              /* Return value */
+    hid_t	ret_value;
 
     FUNC_ENTER_API(FAIL)
     H5TRACE3("i", "iSsi", space1_id, op, space2_id);
 
     /* Check args */
-    if(NULL == (space1 = (H5S_t *)H5I_object_verify(space1_id, H5I_DATASPACE)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")
-    if(NULL == (space2 = (H5S_t *)H5I_object_verify(space2_id, H5I_DATASPACE)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")
-    if(!(op >= H5S_SELECT_OR && op <= H5S_SELECT_NOTA))
+    if (NULL == (space1=H5I_object_verify(space1_id, H5I_DATASPACE)))
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space")
+    if (NULL == (space2=H5I_object_verify(space2_id, H5I_DATASPACE)))
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space")
+    if(!(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID))
         HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
 
     /* Check that both dataspaces have the same rank */
-    if(space1->extent.rank != space2->extent.rank)
+    if(space1->extent.rank!=space2->extent.rank)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "dataspaces not same rank")
 
-    /* Note: currently, the offset of each dataspace is ignored */
-#if 0
-    /* Check that both dataspaces have the same offset */
-    /* Same note as in H5Smodify_select */
-    for(u=0; u<space1->extent.rank; u++) {
-        if(space1->select.offset[u] != space2->select.offset[u])
-            HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "dataspaces not same offset")
-    } /* end for */
-#endif
-
     /* Check that both dataspaces have hyperslab selections */
-    if(H5S_GET_SELECT_TYPE(space1) != H5S_SEL_HYPERSLABS || H5S_GET_SELECT_TYPE(space2) != H5S_SEL_HYPERSLABS)
+    if(H5S_GET_SELECT_TYPE(space1)!=H5S_SEL_HYPERSLABS || H5S_GET_SELECT_TYPE(space2)!=H5S_SEL_HYPERSLABS)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "dataspaces don't have hyperslab selections")
 
     /* Go combine the dataspaces */
-    if(NULL == (new_space = H5S_combine_select(space1, op, space2)))
+    if ((new_space=H5S_combine_select(space1, op, space2))==NULL)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to create hyperslab selection")
 
     /* Atomize */
-    if((ret_value = H5I_register(H5I_DATASPACE, new_space, TRUE)) < 0)
+    if ((ret_value=H5I_register (H5I_DATASPACE, new_space, TRUE))<0)
         HGOTO_ERROR(H5E_ATOM, H5E_CANTREGISTER, FAIL, "unable to register dataspace atom")
 
 done:
-    if(ret_value < 0 && new_space)
+    if (ret_value<0 && new_space)
         H5S_close(new_space);
 
     FUNC_LEAVE_API(ret_value)
@@ -7854,74 +7410,74 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5S_modify_select
+ * Function:	H5S_select_select
  *
- * Purpose:	Internal version of H5Smodify_select().
+ * Purpose:	Internal version of H5Sselect_select().
  *
  * Return:	New dataspace on success/NULL on failure
  *
  * Programmer:	Quincey Koziol
  *              Tuesday, October 30, 2001
  *
- *              Chao Mei
- *              Wednesday, June 29, 2011
+ * Modifications:
  *
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5S_modify_select(H5S_t *space1, H5S_seloper_t op, H5S_t *space2)
+H5S_select_select (H5S_t *space1, H5S_seloper_t op, H5S_t *space2)
 {
-    herr_t      ret_value = SUCCEED;       /* Return value */
+    H5S_hyper_span_info_t *tmp_spans=NULL;   /* Temporary copy of selection */
+    hbool_t span2_owned=FALSE;          /* Flag to indicate that span2 was used in H5S_operate_hyperslab() */
+    herr_t      ret_value=SUCCEED;       /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT
 
     /* Check args */
     HDassert(space1);
     HDassert(space2);
-    HDassert(op >= H5S_SELECT_OR && op <= H5S_SELECT_NOTA);
+    HDassert(op > H5S_SELECT_NOOP && op < H5S_SELECT_INVALID);
 
     /* Check that the space selections both have span trees */
-    if(NULL == space1->select.sel_info.hslab->span_lst)
-        if(H5S_hyper_generate_spans(space1) < 0)
+    if(space1->select.sel_info.hslab->span_lst==NULL)
+        if(H5S_hyper_generate_spans(space1)<0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "dataspace does not have span tree")
+    if(space2->select.sel_info.hslab->span_lst==NULL)
+        if(H5S_hyper_generate_spans(space2)<0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_UNINITIALIZED, FAIL, "dataspace does not have span tree")
 
-    if(NULL == space2->select.sel_info.hslab->span_lst) {
-        hsize_t tmp_start[H5S_MAX_RANK];
-        hsize_t tmp_stride[H5S_MAX_RANK];
-        hsize_t tmp_count[H5S_MAX_RANK];
-        hsize_t tmp_block[H5S_MAX_RANK];
-        unsigned u;
-
-        for(u = 0; u < space2->extent.rank; u++) {
-            tmp_start[u] = space2->select.sel_info.hslab->opt_diminfo[u].start;
-            tmp_stride[u] = space2->select.sel_info.hslab->opt_diminfo[u].stride;
-            tmp_count[u] = space2->select.sel_info.hslab->opt_diminfo[u].count;
-            tmp_block[u] = space2->select.sel_info.hslab->opt_diminfo[u].block;
-        } /* end for */
+    /* Take ownership of the dataspace's hyperslab spans */
+    /* (These are freed later) */
+    tmp_spans=space1->select.sel_info.hslab->span_lst;
+    space1->select.sel_info.hslab->span_lst=NULL;
 
-        /* Call H5S_select_hyperslab directly */
-        if(H5S_select_hyperslab(space1, op, tmp_start, tmp_stride, tmp_count, tmp_block) < 0)
-            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to set hyperslab selection")
-    } /* end if */
-    else {
-        /* Combine spans from space1 & spans from space2, with the result in space1 */
-        if(H5S_fill_in_select(space1, op, space2, &space1) < 0)
-            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't perform operation on two selections")
-    } /* end else*/
+    /* Reset the other dataspace selection information */
+    if(H5S_SELECT_RELEASE(space1)<0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't release selection")
+
+    /* Allocate space for the hyperslab selection information */
+    if((space1->select.sel_info.hslab=H5FL_CALLOC(H5S_hyper_sel_t))==NULL)
+        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab info")
+
+    /* Combine tmp_spans (from space1) & spans from space2, with the result in space1 */
+    if(H5S_operate_hyperslab(space1,tmp_spans,op,space2->select.sel_info.hslab->span_lst,FALSE,&span2_owned)<0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTCLIP, FAIL, "can't clip hyperslab information")
 
 done:
+    if(tmp_spans!=NULL)
+        H5S_hyper_free_span_info(tmp_spans);
+
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5S_modify_select() */
+}   /* end H5S_select_select() */
 
 
 /*--------------------------------------------------------------------------
  NAME
-    H5Smodify_select
+    H5Sselect_select
  PURPOSE
     Refine a hyperslab selection with an operation using a second hyperslab
-    to modify it
+    to modify it.
  USAGE
-    herr_t H5Smodify_select(space1, op, space2)
+    herr_t H5Sselect_select(space1, op, space2)
         hid_t space1;           IN/OUT: First Dataspace ID
         H5S_seloper_t op;       IN: Selection operation
         hid_t space2;           IN: Second Dataspace ID
@@ -7937,63 +7493,39 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 herr_t
-H5Smodify_select(hid_t space1_id, H5S_seloper_t op, hid_t space2_id)
+H5Sselect_select(hid_t space1_id, H5S_seloper_t op, hid_t space2_id)
 {
     H5S_t	*space1;                /* First Dataspace */
     H5S_t	*space2;                /* Second Dataspace */
-    herr_t      ret_value = SUCCEED;    /* Return value */
+    herr_t      ret_value=SUCCEED;       /* Return value */
 
     FUNC_ENTER_API(FAIL)
     H5TRACE3("e", "iSsi", space1_id, op, space2_id);
 
     /* Check args */
-    if(NULL == (space1 = (H5S_t *)H5I_object_verify(space1_id, H5I_DATASPACE)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")
-    if(NULL == (space2 = (H5S_t *)H5I_object_verify(space2_id, H5I_DATASPACE)))
-        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a dataspace")
-    if(!(op >= H5S_SELECT_OR && op <= H5S_SELECT_NOTA))
+    if (NULL == (space1=H5I_object_verify(space1_id, H5I_DATASPACE)))
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space")
+    if (NULL == (space2=H5I_object_verify(space2_id, H5I_DATASPACE)))
+        HGOTO_ERROR(H5E_ARGS, H5E_BADTYPE, FAIL, "not a data space")
+    if(!(op>H5S_SELECT_NOOP && op<H5S_SELECT_INVALID))
         HGOTO_ERROR(H5E_ARGS, H5E_UNSUPPORTED, FAIL, "invalid selection operation")
 
     /* Check that both dataspaces have the same rank */
-    if(space1->extent.rank != space2->extent.rank)
+    if(space1->extent.rank!=space2->extent.rank)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "dataspaces not same rank")
 
-    /* Check that both dataspaces have the same offset */
-    /** Note that this is a tricky part of this function. It's
-     *  possible that two dataspaces have different "offset". If the
-     *  space2 has smaller offset value than that of space1 in a
-     *  dimension, then the span elements of this dimension in
-     *  space2 could have negative "low" and "high" values relative
-     *  to the offset in space1. In other words, if the bounds of
-     *  span elements in space2 are adjusted relative to the offset
-     *  in space1, then every span element's bound is computed as
-     *  "origin_bound+offset2-offset1". Therefore, if offset2 (the
-     *  offset of space2) is smaller, then
-     *  "origin_bound+offset2-offset1" could be negative which is
-     *  not allowed by the bound type declaration as hsize_t!
-     *  As a result, if the op is an OR selection, then the final
-     *  result may contain span elements that have negative bound!
-     *  So right now, the difference in the offset is totally
-     *  ignored!!
-     */
-#if 0
-    for(u=0; u<space1->extent.rank; u++) {
-        if(space1->select.offset[u] != space2->select.offset[u])
-            HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "dataspaces not same offset")
-    } /* end for */
-#endif
-
     /* Check that both dataspaces have hyperslab selections */
-    if(H5S_GET_SELECT_TYPE(space1) != H5S_SEL_HYPERSLABS || H5S_GET_SELECT_TYPE(space2) != H5S_SEL_HYPERSLABS)
+    if(H5S_GET_SELECT_TYPE(space1)!=H5S_SEL_HYPERSLABS || H5S_GET_SELECT_TYPE(space2)!=H5S_SEL_HYPERSLABS)
         HGOTO_ERROR(H5E_ARGS, H5E_BADVALUE, FAIL, "dataspaces don't have hyperslab selections")
 
     /* Go refine the first selection */
-    if(H5S_modify_select(space1, op, space2) < 0)
+    if (H5S_select_select(space1, op, space2)<0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINIT, FAIL, "unable to modify hyperslab selection")
 
 done:
     FUNC_LEAVE_API(ret_value)
-} /* end H5Smodify_select() */
+} /* end H5Sselect_select() */
+#endif /* NEW_HYPERSLAB_API */ /* Works */
 
 
 /*--------------------------------------------------------------------------
@@ -8027,7 +7559,7 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S_hyper_get_seq_list_gen(const H5S_t *space, H5S_sel_iter_t *iter,
+H5S_hyper_get_seq_list_gen(const H5S_t *space,H5S_sel_iter_t *iter,
     size_t maxseq, size_t maxelem, size_t *nseq, size_t *nelem,
     hsize_t *off, size_t *len)
 {
@@ -9199,14 +8731,8 @@ H5S_hyper_get_seq_list(const H5S_t *space, unsigned UNUSED flags, H5S_sel_iter_t
     HDassert(off);
     HDassert(len);
 
-    /* Rebuild diminfo if it is invalid and has not been confirmed to be
-     * impossible */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_NO)
-        /* Casting away const OK -NAF */
-        (void)H5S_hyper_rebuild((H5S_t *)space);
-
     /* Check for the special case of just one H5Sselect_hyperslab call made */
-    if(space->select.sel_info.hslab->diminfo_valid == H5S_DIMINFO_VALID_YES) {
+    if(space->select.sel_info.hslab->diminfo_valid) {
         const H5S_hyper_dim_t *tdiminfo;    /* Temporary pointer to diminfo information */
         const hssize_t *sel_off;    /* Selection offset in dataspace */
         hsize_t *mem_size;      /* Size of the source buffer */