summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorRaymond Lu <songyulu@hdfgroup.org>2005-09-01 18:33:32 (GMT)
committerRaymond Lu <songyulu@hdfgroup.org>2005-09-01 18:33:32 (GMT)
commit572688a4e5fc702c5c6313badb5c9dc1fba19ff3 (patch)
tree20105d7a3a3cb7ce0d6c819a96f16c71b3966c77
parent9d452584c69713124501d9b5ebd5af3d42932ec7 (diff)
downloadhdf5-572688a4e5fc702c5c6313badb5c9dc1fba19ff3.zip
hdf5-572688a4e5fc702c5c6313badb5c9dc1fba19ff3.tar.gz
hdf5-572688a4e5fc702c5c6313badb5c9dc1fba19ff3.tar.bz2
[svn-r11332] Purpose: Minor Change to Macro Names
Description: Changed the names of macros defined in H5Tpkg.h from H5T_CONV_INTERIM_XXX_XXX to H5T_CONV_INTERNAL_XXX_XXX to be more descriptive. Platforms tested: fuss - simple change
Diffstat
-rw-r--r--src/H5T.c104
-rw-r--r--src/H5Tconv.c136
-rw-r--r--src/H5Tpkg.h52
3 files changed, 146 insertions, 146 deletions
diff --git a/src/H5T.c b/src/H5T.c
index 18f13da..edf9989 100644
--- a/src/H5T.c
+++ b/src/H5T.c
@@ -1001,16 +1001,16 @@ H5T_init_interface(void)
*/
/* floating point */
-#if H5T_CONV_INTERIM_FP_FP
+#if H5T_CONV_INTERNAL_FP_FP
status |= H5T_register(H5T_PERS_HARD, "flt_dbl", native_float, native_double, H5T_conv_float_double, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "dbl_flt", native_double, native_float, H5T_conv_double_float, H5AC_dxpl_id);
-#endif /*H5T_CONV_INTERIM_FP_FP*/
-#if H5T_CONV_INTERIM_FP_LDOUBLE
+#endif /*H5T_CONV_INTERNAL_FP_FP*/
+#if H5T_CONV_INTERNAL_FP_LDOUBLE
status |= H5T_register(H5T_PERS_HARD, "flt_ldbl", native_float, native_ldouble, H5T_conv_float_ldouble, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "dbl_ldbl", native_double, native_ldouble, H5T_conv_double_ldouble, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "ldbl_flt", native_ldouble, native_float, H5T_conv_ldouble_float, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "ldbl_dbl", native_ldouble, native_double, H5T_conv_ldouble_double, H5AC_dxpl_id);
-#endif /*H5T_CONV_INTERIM_FP_LDOUBLE*/
+#endif /*H5T_CONV_INTERNAL_FP_LDOUBLE*/
/* from long_long */
status |= H5T_register(H5T_PERS_HARD, "llong_ullong", native_llong, native_ullong, H5T_conv_llong_ullong, H5AC_dxpl_id);
@@ -1115,149 +1115,149 @@ H5T_init_interface(void)
/* From char to floats */
status |= H5T_register(H5T_PERS_HARD, "schar_flt", native_schar, native_float, H5T_conv_schar_float, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "schar_dbl", native_schar, native_double, H5T_conv_schar_double, H5AC_dxpl_id);
-#if H5T_CONV_INTERIM_INTEGER_LDOUBLE
+#if H5T_CONV_INTERNAL_INTEGER_LDOUBLE
status |= H5T_register(H5T_PERS_HARD, "schar_ldbl", native_schar, native_ldouble, H5T_conv_schar_ldouble, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_INTEGER_LDOUBLE */
+#endif /* H5T_CONV_INTERNAL_INTEGER_LDOUBLE */
/* From unsigned char to floats */
status |= H5T_register(H5T_PERS_HARD, "uchar_flt", native_uchar, native_float, H5T_conv_uchar_float, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "uchar_dbl", native_uchar, native_double, H5T_conv_uchar_double, H5AC_dxpl_id);
-#if H5T_CONV_INTERIM_INTEGER_LDOUBLE
+#if H5T_CONV_INTERNAL_INTEGER_LDOUBLE
status |= H5T_register(H5T_PERS_HARD, "uchar_ldbl", native_uchar, native_ldouble, H5T_conv_uchar_ldouble, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_INTEGER_LDOUBLE */
+#endif /* H5T_CONV_INTERNAL_INTEGER_LDOUBLE */
/* From short to floats */
status |= H5T_register(H5T_PERS_HARD, "short_flt", native_short, native_float, H5T_conv_short_float, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "short_dbl", native_short, native_double, H5T_conv_short_double, H5AC_dxpl_id);
-#if H5T_CONV_INTERIM_INTEGER_LDOUBLE
+#if H5T_CONV_INTERNAL_INTEGER_LDOUBLE
status |= H5T_register(H5T_PERS_HARD, "short_ldbl", native_short, native_ldouble, H5T_conv_short_ldouble, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_INTEGER_LDOUBLE */
+#endif /* H5T_CONV_INTERNAL_INTEGER_LDOUBLE */
/* From unsigned short to floats */
status |= H5T_register(H5T_PERS_HARD, "ushort_flt", native_ushort, native_float, H5T_conv_ushort_float, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "ushort_dbl", native_ushort, native_double, H5T_conv_ushort_double, H5AC_dxpl_id);
-#if H5T_CONV_INTERIM_INTEGER_LDOUBLE
+#if H5T_CONV_INTERNAL_INTEGER_LDOUBLE
status |= H5T_register(H5T_PERS_HARD, "ushort_ldbl", native_ushort, native_ldouble, H5T_conv_ushort_ldouble, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_INTEGER_LDOUBLE */
+#endif /* H5T_CONV_INTERNAL_INTEGER_LDOUBLE */
/* From int to floats */
status |= H5T_register(H5T_PERS_HARD, "int_flt", native_int, native_float, H5T_conv_int_float, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "int_dbl", native_int, native_double, H5T_conv_int_double, H5AC_dxpl_id);
-#if H5T_CONV_INTERIM_INTEGER_LDOUBLE
+#if H5T_CONV_INTERNAL_INTEGER_LDOUBLE
status |= H5T_register(H5T_PERS_HARD, "int_ldbl", native_int, native_ldouble, H5T_conv_int_ldouble, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_INTEGER_LDOUBLE */
+#endif /* H5T_CONV_INTERNAL_INTEGER_LDOUBLE */
/* From unsigned int to floats */
status |= H5T_register(H5T_PERS_HARD, "uint_flt", native_uint, native_float, H5T_conv_uint_float, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "uint_dbl", native_uint, native_double, H5T_conv_uint_double, H5AC_dxpl_id);
-#if H5T_CONV_INTERIM_INTEGER_LDOUBLE
+#if H5T_CONV_INTERNAL_INTEGER_LDOUBLE
status |= H5T_register(H5T_PERS_HARD, "uint_ldbl", native_uint, native_ldouble, H5T_conv_uint_ldouble, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_INTEGER_LDOUBLE */
+#endif /* H5T_CONV_INTERNAL_INTEGER_LDOUBLE */
/* From long to floats */
status |= H5T_register(H5T_PERS_HARD, "long_flt", native_long, native_float, H5T_conv_long_float, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "long_dbl", native_long, native_double, H5T_conv_long_double, H5AC_dxpl_id);
-#if H5T_CONV_INTERIM_INTEGER_LDOUBLE
+#if H5T_CONV_INTERNAL_INTEGER_LDOUBLE
status |= H5T_register(H5T_PERS_HARD, "long_ldbl", native_long, native_ldouble, H5T_conv_long_ldouble, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_INTEGER_LDOUBLE */
+#endif /* H5T_CONV_INTERNAL_INTEGER_LDOUBLE */
/* From unsigned long to floats */
-#if H5T_CONV_INTERIM_ULONG_FP
+#if H5T_CONV_INTERNAL_ULONG_FP
status |= H5T_register(H5T_PERS_HARD, "ulong_flt", native_ulong, native_float, H5T_conv_ulong_float, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "ulong_dbl", native_ulong, native_double, H5T_conv_ulong_double, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_ULONG_FP */
-#if H5T_CONV_INTERIM_ULONG_LDOUBLE
+#endif /* H5T_CONV_INTERNAL_ULONG_FP */
+#if H5T_CONV_INTERNAL_ULONG_LDOUBLE
status |= H5T_register(H5T_PERS_HARD, "ulong_ldbl", native_ulong, native_ldouble, H5T_conv_ulong_ldouble, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_ULONG_LDOUBLE */
+#endif /* H5T_CONV_INTERNAL_ULONG_LDOUBLE */
/* From long long to floats */
status |= H5T_register(H5T_PERS_HARD, "llong_flt", native_llong, native_float, H5T_conv_llong_float, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "llong_dbl", native_llong, native_double, H5T_conv_llong_double, H5AC_dxpl_id);
-#if H5T_CONV_INTERIM_INTEGER_LDOUBLE
+#if H5T_CONV_INTERNAL_INTEGER_LDOUBLE
status |= H5T_register(H5T_PERS_HARD, "llong_ldbl", native_llong, native_ldouble, H5T_conv_llong_ldouble, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_INTEGER_LDOUBLE */
+#endif /* H5T_CONV_INTERNAL_INTEGER_LDOUBLE */
/* From unsigned long long to floats */
-#if H5T_CONV_INTERIM_ULLONG_FP
+#if H5T_CONV_INTERNAL_ULLONG_FP
status |= H5T_register(H5T_PERS_HARD, "ullong_flt", native_ullong, native_float, H5T_conv_ullong_float, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "ullong_dbl", native_ullong, native_double, H5T_conv_ullong_double, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_ULLONG_FP */
-#if H5T_CONV_INTERIM_ULLONG_LDOUBLE
+#endif /* H5T_CONV_INTERNAL_ULLONG_FP */
+#if H5T_CONV_INTERNAL_ULLONG_LDOUBLE
status |= H5T_register(H5T_PERS_HARD, "ullong_ldbl", native_ullong, native_ldouble, H5T_conv_ullong_ldouble, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_ULLONG_LDOUBLE */
+#endif /* H5T_CONV_INTERNAL_ULLONG_LDOUBLE */
/* From floats to char */
status |= H5T_register(H5T_PERS_HARD, "flt_schar", native_float, native_schar, H5T_conv_float_schar, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "dbl_schar", native_double, native_schar, H5T_conv_double_schar, H5AC_dxpl_id);
-#if H5T_CONV_INTERIM_LDOUBLE_INTEGER
+#if H5T_CONV_INTERNAL_LDOUBLE_INTEGER
status |= H5T_register(H5T_PERS_HARD, "ldbl_schar", native_ldouble, native_schar, H5T_conv_ldouble_schar, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_LDOUBLE_INTEGER */
+#endif /* H5T_CONV_INTERNAL_LDOUBLE_INTEGER */
/* From floats to unsigned char */
status |= H5T_register(H5T_PERS_HARD, "flt_uchar", native_float, native_uchar, H5T_conv_float_uchar, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "dbl_uchar", native_double, native_uchar, H5T_conv_double_uchar, H5AC_dxpl_id);
-#if H5T_CONV_INTERIM_LDOUBLE_INTEGER
+#if H5T_CONV_INTERNAL_LDOUBLE_INTEGER
status |= H5T_register(H5T_PERS_HARD, "ldbl_uchar", native_ldouble, native_uchar, H5T_conv_ldouble_uchar, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_LDOUBLE_INTEGER */
+#endif /* H5T_CONV_INTERNAL_LDOUBLE_INTEGER */
/* From floats to short */
status |= H5T_register(H5T_PERS_HARD, "flt_short", native_float, native_short, H5T_conv_float_short, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "dbl_short", native_double, native_short, H5T_conv_double_short, H5AC_dxpl_id);
-#if H5T_CONV_INTERIM_LDOUBLE_INTEGER
+#if H5T_CONV_INTERNAL_LDOUBLE_INTEGER
status |= H5T_register(H5T_PERS_HARD, "ldbl_short", native_ldouble, native_short, H5T_conv_ldouble_short, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_LDOUBLE_INTEGER */
+#endif /* H5T_CONV_INTERNAL_LDOUBLE_INTEGER */
/* From floats to unsigned short */
status |= H5T_register(H5T_PERS_HARD, "flt_ushort", native_float, native_ushort, H5T_conv_float_ushort, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "dbl_ushort", native_double, native_ushort, H5T_conv_double_ushort, H5AC_dxpl_id);
-#if H5T_CONV_INTERIM_LDOUBLE_INTEGER
+#if H5T_CONV_INTERNAL_LDOUBLE_INTEGER
status |= H5T_register(H5T_PERS_HARD, "ldbl_ushort", native_ldouble, native_ushort, H5T_conv_ldouble_ushort, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_LDOUBLE_INTEGER */
+#endif /* H5T_CONV_INTERNAL_LDOUBLE_INTEGER */
/* From floats to int */
status |= H5T_register(H5T_PERS_HARD, "flt_int", native_float, native_int, H5T_conv_float_int, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "dbl_int", native_double, native_int, H5T_conv_double_int, H5AC_dxpl_id);
-#if H5T_CONV_INTERIM_LDOUBLE_INTEGER
+#if H5T_CONV_INTERNAL_LDOUBLE_INTEGER
status |= H5T_register(H5T_PERS_HARD, "ldbl_int", native_ldouble, native_int, H5T_conv_ldouble_int, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_LDOUBLE_INTEGER */
+#endif /* H5T_CONV_INTERNAL_LDOUBLE_INTEGER */
/* From floats to unsigned int */
status |= H5T_register(H5T_PERS_HARD, "flt_uint", native_float, native_uint, H5T_conv_float_uint, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "dbl_uint", native_double, native_uint, H5T_conv_double_uint, H5AC_dxpl_id);
-#if H5T_CONV_INTERIM_LDOUBLE_UINT
+#if H5T_CONV_INTERNAL_LDOUBLE_UINT
status |= H5T_register(H5T_PERS_HARD, "ldbl_uint", native_ldouble, native_uint, H5T_conv_ldouble_uint, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_LDOUBLE_UINT */
+#endif /* H5T_CONV_INTERNAL_LDOUBLE_UINT */
status |= H5T_register(H5T_PERS_HARD, "flt_long", native_float, native_long, H5T_conv_float_long, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "dbl_long", native_double, native_long, H5T_conv_double_long, H5AC_dxpl_id);
-#if H5T_CONV_INTERIM_LDOUBLE_INTEGER
+#if H5T_CONV_INTERNAL_LDOUBLE_INTEGER
status |= H5T_register(H5T_PERS_HARD, "ldbl_long", native_ldouble, native_long, H5T_conv_ldouble_long, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_LDOUBLE_INTEGER */
+#endif /* H5T_CONV_INTERNAL_LDOUBLE_INTEGER */
/* From floats to unsigned long */
status |= H5T_register(H5T_PERS_HARD, "flt_ulong", native_float, native_ulong, H5T_conv_float_ulong, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "dbl_ulong", native_double, native_ulong, H5T_conv_double_ulong, H5AC_dxpl_id);
-#if H5T_CONV_INTERIM_LDOUBLE_INTEGER
+#if H5T_CONV_INTERNAL_LDOUBLE_INTEGER
status |= H5T_register(H5T_PERS_HARD, "ldbl_ulong", native_ldouble, native_ulong, H5T_conv_ldouble_ulong, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_LDOUBLE_INTEGER */
+#endif /* H5T_CONV_INTERNAL_LDOUBLE_INTEGER */
/* From floats to long long */
-#if H5T_CONV_INTERIM_FP_LLONG
+#if H5T_CONV_INTERNAL_FP_LLONG
status |= H5T_register(H5T_PERS_HARD, "flt_llong", native_float, native_llong, H5T_conv_float_llong, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "dbl_llong", native_double, native_llong, H5T_conv_double_llong, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_FP_LLONG */
-#if H5T_CONV_INTERIM_LDOUBLE_LLONG
+#endif /* H5T_CONV_INTERNAL_FP_LLONG */
+#if H5T_CONV_INTERNAL_LDOUBLE_LLONG
status |= H5T_register(H5T_PERS_HARD, "ldbl_llong", native_ldouble, native_llong, H5T_conv_ldouble_llong, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_LDOUBLE_LLONG */
+#endif /* H5T_CONV_INTERNAL_LDOUBLE_LLONG */
/* From floats to unsigned long long */
-#if H5T_CONV_INTERIM_FP_ULLONG
+#if H5T_CONV_INTERNAL_FP_ULLONG
status |= H5T_register(H5T_PERS_HARD, "flt_ullong", native_float, native_ullong, H5T_conv_float_ullong, H5AC_dxpl_id);
status |= H5T_register(H5T_PERS_HARD, "dbl_ullong", native_double, native_ullong, H5T_conv_double_ullong, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_FP_ULLONG */
-#if H5T_CONV_INTERIM_LDOUBLE_ULLONG
+#endif /* H5T_CONV_INTERNAL_FP_ULLONG */
+#if H5T_CONV_INTERNAL_LDOUBLE_ULLONG
status |= H5T_register(H5T_PERS_HARD, "ldbl_ullong", native_ldouble, native_ullong, H5T_conv_ldouble_ullong, H5AC_dxpl_id);
-#endif /* H5T_CONV_INTERIM_LDOUBLE_ULLONG */
+#endif /* H5T_CONV_INTERNAL_LDOUBLE_ULLONG */
/*
* The special no-op conversion is the fastest, so we list it last. The
diff --git a/src/H5Tconv.c b/src/H5Tconv.c
index abd9872..8745892 100644
--- a/src/H5Tconv.c
+++ b/src/H5Tconv.c
@@ -7107,7 +7107,7 @@ done:
* destination values are packed.
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_FP_FP
+#if H5T_CONV_INTERNAL_FP_FP
herr_t
H5T_conv_float_double (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -7123,7 +7123,7 @@ H5T_conv_float_double (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /* H5T_CONV_INTERIM_FP_FP */
+#endif /* H5T_CONV_INTERNAL_FP_FP */
/*-------------------------------------------------------------------------
@@ -7141,7 +7141,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_FP_LDOUBLE
+#if H5T_CONV_INTERNAL_FP_LDOUBLE
herr_t
H5T_conv_float_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -7157,7 +7157,7 @@ H5T_conv_float_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /*H5T_CONV_INTERIM_FP_LDOUBLE*/
+#endif /*H5T_CONV_INTERNAL_FP_LDOUBLE*/
/*-------------------------------------------------------------------------
@@ -7182,7 +7182,7 @@ done:
* destination values are packed.
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_FP_FP
+#if H5T_CONV_INTERNAL_FP_FP
herr_t
H5T_conv_double_float (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -7198,7 +7198,7 @@ H5T_conv_double_float (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /*H5T_CONV_INTERIM_FP_FP*/
+#endif /*H5T_CONV_INTERNAL_FP_FP*/
/*-------------------------------------------------------------------------
@@ -7216,7 +7216,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_FP_LDOUBLE
+#if H5T_CONV_INTERNAL_FP_LDOUBLE
herr_t
H5T_conv_double_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -7233,7 +7233,7 @@ H5T_conv_double_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /*H5T_CONV_INTERIM_FP_LDOUBLE*/
+#endif /*H5T_CONV_INTERNAL_FP_LDOUBLE*/
/*-------------------------------------------------------------------------
@@ -7251,7 +7251,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_FP_LDOUBLE
+#if H5T_CONV_INTERNAL_FP_LDOUBLE
herr_t
H5T_conv_ldouble_float (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -7267,7 +7267,7 @@ H5T_conv_ldouble_float (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /* H5T_CONV_INTERIM_FP_LDOUBLE */
+#endif /* H5T_CONV_INTERNAL_FP_LDOUBLE */
/*-------------------------------------------------------------------------
@@ -7285,7 +7285,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_FP_LDOUBLE
+#if H5T_CONV_INTERNAL_FP_LDOUBLE
herr_t
H5T_conv_ldouble_double (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -7301,7 +7301,7 @@ H5T_conv_ldouble_double (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /*H5T_CONV_INTERIM_FP_LDOUBLE*/
+#endif /*H5T_CONV_INTERNAL_FP_LDOUBLE*/
/*-------------------------------------------------------------------------
@@ -7383,7 +7383,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_INTEGER_LDOUBLE
+#if H5T_CONV_INTERNAL_INTEGER_LDOUBLE
herr_t
H5T_conv_schar_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -7399,7 +7399,7 @@ H5T_conv_schar_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /* H5T_CONV_INTERIM_INTEGER_LDOUBLE */
+#endif /* H5T_CONV_INTERNAL_INTEGER_LDOUBLE */
/*-------------------------------------------------------------------------
@@ -7481,7 +7481,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_INTEGER_LDOUBLE
+#if H5T_CONV_INTERNAL_INTEGER_LDOUBLE
herr_t
H5T_conv_uchar_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -7497,7 +7497,7 @@ H5T_conv_uchar_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /* H5T_CONV_INTERIM_INTEGER_LDOUBLE */
+#endif /* H5T_CONV_INTERNAL_INTEGER_LDOUBLE */
/*-------------------------------------------------------------------------
@@ -7579,7 +7579,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_INTEGER_LDOUBLE
+#if H5T_CONV_INTERNAL_INTEGER_LDOUBLE
herr_t
H5T_conv_short_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -7595,7 +7595,7 @@ H5T_conv_short_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /* H5T_CONV_INTERIM_INTEGER_LDOUBLE */
+#endif /* H5T_CONV_INTERNAL_INTEGER_LDOUBLE */
/*-------------------------------------------------------------------------
@@ -7677,7 +7677,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_INTEGER_LDOUBLE
+#if H5T_CONV_INTERNAL_INTEGER_LDOUBLE
herr_t
H5T_conv_ushort_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -7693,7 +7693,7 @@ H5T_conv_ushort_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /* H5T_CONV_INTERIM_INTEGER_LDOUBLE */
+#endif /* H5T_CONV_INTERNAL_INTEGER_LDOUBLE */
/*-------------------------------------------------------------------------
@@ -7775,7 +7775,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_INTEGER_LDOUBLE
+#if H5T_CONV_INTERNAL_INTEGER_LDOUBLE
herr_t
H5T_conv_int_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -7791,7 +7791,7 @@ H5T_conv_int_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /* H5T_CONV_INTERIM_INTEGER_LDOUBLE */
+#endif /* H5T_CONV_INTERNAL_INTEGER_LDOUBLE */
/*-------------------------------------------------------------------------
@@ -7873,7 +7873,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_INTEGER_LDOUBLE
+#if H5T_CONV_INTERNAL_INTEGER_LDOUBLE
herr_t
H5T_conv_uint_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -7889,7 +7889,7 @@ H5T_conv_uint_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /* H5T_CONV_INTERIM_INTEGER_LDOUBLE */
+#endif /* H5T_CONV_INTERNAL_INTEGER_LDOUBLE */
/*-------------------------------------------------------------------------
@@ -7971,7 +7971,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_INTEGER_LDOUBLE
+#if H5T_CONV_INTERNAL_INTEGER_LDOUBLE
herr_t
H5T_conv_long_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -7987,7 +7987,7 @@ H5T_conv_long_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /* H5T_CONV_INTERIM_INTEGER_LDOUBLE */
+#endif /* H5T_CONV_INTERNAL_INTEGER_LDOUBLE */
/*-------------------------------------------------------------------------
@@ -8005,7 +8005,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_ULONG_FP
+#if H5T_CONV_INTERNAL_ULONG_FP
herr_t
H5T_conv_ulong_float (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -8021,7 +8021,7 @@ H5T_conv_ulong_float (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /* H5T_CONV_INTERIM_ULONG_FP */
+#endif /* H5T_CONV_INTERNAL_ULONG_FP */
/*-------------------------------------------------------------------------
@@ -8039,7 +8039,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_ULONG_FP
+#if H5T_CONV_INTERNAL_ULONG_FP
herr_t
H5T_conv_ulong_double (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -8055,7 +8055,7 @@ H5T_conv_ulong_double (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /* H5T_CONV_INTERIM_ULONG_FP */
+#endif /* H5T_CONV_INTERNAL_ULONG_FP */
/*-------------------------------------------------------------------------
@@ -8073,7 +8073,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_ULONG_LDOUBLE
+#if H5T_CONV_INTERNAL_ULONG_LDOUBLE
herr_t
H5T_conv_ulong_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -8089,7 +8089,7 @@ H5T_conv_ulong_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /* H5T_CONV_INTERIM_ULONG_LDOUBLE */
+#endif /* H5T_CONV_INTERNAL_ULONG_LDOUBLE */
/*-------------------------------------------------------------------------
@@ -8171,7 +8171,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_INTEGER_LDOUBLE
+#if H5T_CONV_INTERNAL_INTEGER_LDOUBLE
herr_t
H5T_conv_llong_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -8187,7 +8187,7 @@ H5T_conv_llong_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /* H5T_CONV_INTERIM_INTEGER_LDOUBLE */
+#endif /* H5T_CONV_INTERNAL_INTEGER_LDOUBLE */
/*-------------------------------------------------------------------------
@@ -8205,7 +8205,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_ULLONG_FP
+#if H5T_CONV_INTERNAL_ULLONG_FP
herr_t
H5T_conv_ullong_float (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -8221,7 +8221,7 @@ H5T_conv_ullong_float (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /*H5T_CONV_INTERIM_ULLONG_FP*/
+#endif /*H5T_CONV_INTERNAL_ULLONG_FP*/
/*-------------------------------------------------------------------------
@@ -8239,7 +8239,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_ULLONG_FP
+#if H5T_CONV_INTERNAL_ULLONG_FP
herr_t
H5T_conv_ullong_double (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -8255,7 +8255,7 @@ H5T_conv_ullong_double (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /*H5T_CONV_INTERIM_ULLONG_FP*/
+#endif /*H5T_CONV_INTERNAL_ULLONG_FP*/
/*-------------------------------------------------------------------------
@@ -8273,7 +8273,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_ULLONG_LDOUBLE
+#if H5T_CONV_INTERNAL_ULLONG_LDOUBLE
herr_t
H5T_conv_ullong_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -8289,7 +8289,7 @@ H5T_conv_ullong_ldouble (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /*H5T_CONV_INTERIM_ULLONG_LDOUBLE*/
+#endif /*H5T_CONV_INTERNAL_ULLONG_LDOUBLE*/
/*-------------------------------------------------------------------------
@@ -8435,7 +8435,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_LDOUBLE_INTEGER
+#if H5T_CONV_INTERNAL_LDOUBLE_INTEGER
herr_t
H5T_conv_ldouble_schar (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -8451,7 +8451,7 @@ H5T_conv_ldouble_schar (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /* H5T_CONV_INTERIM_LDOUBLE_INTEGER */
+#endif /* H5T_CONV_INTERNAL_LDOUBLE_INTEGER */
/*-------------------------------------------------------------------------
@@ -8469,7 +8469,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_LDOUBLE_INTEGER
+#if H5T_CONV_INTERNAL_LDOUBLE_INTEGER
herr_t
H5T_conv_ldouble_uchar (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -8485,7 +8485,7 @@ H5T_conv_ldouble_uchar (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /* H5T_CONV_INTERIM_LDOUBLE_INTEGER */
+#endif /* H5T_CONV_INTERNAL_LDOUBLE_INTEGER */
/*-------------------------------------------------------------------------
@@ -8631,7 +8631,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_LDOUBLE_INTEGER
+#if H5T_CONV_INTERNAL_LDOUBLE_INTEGER
herr_t
H5T_conv_ldouble_short (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -8647,7 +8647,7 @@ H5T_conv_ldouble_short (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /* LDOUBLE_INTEGER */
+#endif /*H5T_CONV_INTERNAL_LDOUBLE_INTEGER*/
/*-------------------------------------------------------------------------
@@ -8665,7 +8665,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_LDOUBLE_INTEGER
+#if H5T_CONV_INTERNAL_LDOUBLE_INTEGER
herr_t
H5T_conv_ldouble_ushort (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -8681,7 +8681,7 @@ H5T_conv_ldouble_ushort (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /* H5T_CONV_INTERIM_LDOUBLE_INTEGER */
+#endif /* H5T_CONV_INTERNAL_LDOUBLE_INTEGER */
/*-------------------------------------------------------------------------
@@ -8827,7 +8827,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_LDOUBLE_INTEGER
+#if H5T_CONV_INTERNAL_LDOUBLE_INTEGER
herr_t
H5T_conv_ldouble_int (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -8843,7 +8843,7 @@ H5T_conv_ldouble_int (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /* H5T_CONV_INTERIM_LDOUBLE_INTEGER */
+#endif /* H5T_CONV_INTERNAL_LDOUBLE_INTEGER */
/*-------------------------------------------------------------------------
@@ -8861,7 +8861,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_LDOUBLE_UINT
+#if H5T_CONV_INTERNAL_LDOUBLE_UINT
herr_t
H5T_conv_ldouble_uint (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -8877,7 +8877,7 @@ H5T_conv_ldouble_uint (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /* H5T_CONV_INTERIM_LDOUBLE_UINT */
+#endif /* H5T_CONV_INTERNAL_LDOUBLE_UINT */
/*-------------------------------------------------------------------------
@@ -9023,7 +9023,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_LDOUBLE_INTEGER
+#if H5T_CONV_INTERNAL_LDOUBLE_INTEGER
herr_t
H5T_conv_ldouble_long (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -9039,7 +9039,7 @@ H5T_conv_ldouble_long (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /*H5T_CONV_INTERIM_LDOUBLE_INTEGER*/
+#endif /*H5T_CONV_INTERNAL_LDOUBLE_INTEGER*/
/*-------------------------------------------------------------------------
@@ -9057,7 +9057,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_LDOUBLE_INTEGER
+#if H5T_CONV_INTERNAL_LDOUBLE_INTEGER
herr_t
H5T_conv_ldouble_ulong (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -9073,7 +9073,7 @@ H5T_conv_ldouble_ulong (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /* H5T_CONV_INTERIM_LDOUBLE_INTEGER */
+#endif /* H5T_CONV_INTERNAL_LDOUBLE_INTEGER */
/*-------------------------------------------------------------------------
@@ -9091,7 +9091,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_FP_LLONG
+#if H5T_CONV_INTERNAL_FP_LLONG
herr_t
H5T_conv_float_llong (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -9107,7 +9107,7 @@ H5T_conv_float_llong (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /* H5T_CONV_INTERIM_FP_LLONG */
+#endif /* H5T_CONV_INTERNAL_FP_LLONG */
/*-------------------------------------------------------------------------
@@ -9125,7 +9125,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_FP_ULLONG
+#if H5T_CONV_INTERNAL_FP_ULLONG
herr_t
H5T_conv_float_ullong (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -9141,7 +9141,7 @@ H5T_conv_float_ullong (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /*H5T_CONV_INTERIM_FP_ULLONG*/
+#endif /*H5T_CONV_INTERNAL_FP_ULLONG*/
/*-------------------------------------------------------------------------
@@ -9159,7 +9159,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_FP_LLONG
+#if H5T_CONV_INTERNAL_FP_LLONG
herr_t
H5T_conv_double_llong (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -9175,7 +9175,7 @@ H5T_conv_double_llong (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /*H5T_CONV_INTERIM_FP_LLONG*/
+#endif /*H5T_CONV_INTERNAL_FP_LLONG*/
/*-------------------------------------------------------------------------
@@ -9193,7 +9193,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_FP_ULLONG
+#if H5T_CONV_INTERNAL_FP_ULLONG
herr_t
H5T_conv_double_ullong (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -9209,7 +9209,7 @@ H5T_conv_double_ullong (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /*H5T_CONV_INTERIM_FP_ULLONG*/
+#endif /*H5T_CONV_INTERNAL_FP_ULLONG*/
/*-------------------------------------------------------------------------
@@ -9227,7 +9227,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_LDOUBLE_LLONG
+#if H5T_CONV_INTERNAL_LDOUBLE_LLONG
herr_t
H5T_conv_ldouble_llong (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -9243,7 +9243,7 @@ H5T_conv_ldouble_llong (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /*H5T_CONV_INTERIM_LDOUBLE_LLONG*/
+#endif /*H5T_CONV_INTERNAL_LDOUBLE_LLONG*/
/*-------------------------------------------------------------------------
@@ -9261,7 +9261,7 @@ done:
*
*-------------------------------------------------------------------------
*/
-#if H5T_CONV_INTERIM_LDOUBLE_ULLONG
+#if H5T_CONV_INTERNAL_LDOUBLE_ULLONG
herr_t
H5T_conv_ldouble_ullong (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
size_t nelmts, size_t buf_stride,
@@ -9277,7 +9277,7 @@ H5T_conv_ldouble_ullong (hid_t src_id, hid_t dst_id, H5T_cdata_t *cdata,
done:
FUNC_LEAVE_NOAPI(ret_value);
}
-#endif /*H5T_CONV_INTERIM_LDOUBLE_ULLONG*/
+#endif /*H5T_CONV_INTERNAL_LDOUBLE_ULLONG*/
/*-------------------------------------------------------------------------
diff --git a/src/H5Tpkg.h b/src/H5Tpkg.h
index e98d5b0..76d5e13 100644
--- a/src/H5Tpkg.h
+++ b/src/H5Tpkg.h
@@ -65,99 +65,99 @@
#define H5T_IS_ATOMIC(dt) (!(H5T_IS_COMPLEX((dt)->type) || (dt)->type==H5T_OPAQUE))
-/* Define an interim macro for converting between floating number(float and double) and floating number.
+/* Define an internal macro for converting between floating number(float and double) and floating number.
* All Cray compilers don't support denormalized floating values generating exception(?). */
#if H5_CONVERT_DENORMAL_FLOAT
-#define H5T_CONV_INTERIM_FP_FP 1
+#define H5T_CONV_INTERNAL_FP_FP 1
#endif /*H5_CONVERT_DENORMAL_FLOAT*/
-/* Define an interim macro for converting between floating number(float and double) and long double.
+/* Define an internal macro for converting between floating number(float and double) and long double.
* All Cray compilers don't support denormalized floating values generating exception(?). NEC doesn't
* support long double. */
#if H5_SIZEOF_LONG_DOUBLE && H5_CONVERT_DENORMAL_FLOAT
-#define H5T_CONV_INTERIM_FP_LDOUBLE 1
+#define H5T_CONV_INTERNAL_FP_LDOUBLE 1
#endif /*H5_SIZEOF_LONG_DOUBLE && H5_CONVERT_DENORMAL_FLOAT*/
-/* Define an interim macro for converting all integers to long double. SGI compilers give some
+/* Define an internal macro for converting all integers to long double. SGI compilers give some
* incorrect conversions. */
#if (H5_WANT_DATA_ACCURACY && H5_INTEGER_TO_LDOUBLE_ACCURATE) || (!H5_WANT_DATA_ACCURACY)
-#define H5T_CONV_INTERIM_INTEGER_LDOUBLE 1
+#define H5T_CONV_INTERNAL_INTEGER_LDOUBLE 1
#endif
-/* Define an interim macro for converting unsigned (long) long to floating numbers.
+/* Define an internal macro for converting unsigned (long) long to floating numbers.
* 64-bit Solaris does different rounding. */
#if (H5_WANT_DATA_ACCURACY && H5_ULONG_TO_FP_BOTTOM_BIT_ACCURATE) || (!H5_WANT_DATA_ACCURACY)
-#define H5T_CONV_INTERIM_ULONG_FP 1
+#define H5T_CONV_INTERNAL_ULONG_FP 1
#endif
-/* Define an interim macro for converting unsigned long to long double. SGI compilers give some
+/* Define an internal macro for converting unsigned long to long double. SGI compilers give some
* incorrect conversions. 64-bit Solaris does different rounding. */
#if (H5_WANT_DATA_ACCURACY && H5_INTEGER_TO_LDOUBLE_ACCURATE && H5_ULONG_TO_FP_BOTTOM_BIT_ACCURATE) || \
(!H5_WANT_DATA_ACCURACY)
-#define H5T_CONV_INTERIM_ULONG_LDOUBLE 1
+#define H5T_CONV_INTERNAL_ULONG_LDOUBLE 1
#endif
-/* Define an interim macro for converting unsigned long long to floating numbers. SGI compilers give
+/* Define an internal macro for converting unsigned long long to floating numbers. SGI compilers give
* some incorect conversion. 64-bit Solaris does different rounding. Windows Visual Studio 6 does
* not support unsigned long long. */
#if (H5_WANT_DATA_ACCURACY && H5_ULLONG_TO_FP_CAST_WORKS && H5_ULONG_TO_FP_BOTTOM_BIT_ACCURATE) || \
(!H5_WANT_DATA_ACCURACY && H5_ULLONG_TO_FP_CAST_WORKS)
-#define H5T_CONV_INTERIM_ULLONG_FP 1
+#define H5T_CONV_INTERNAL_ULLONG_FP 1
#endif
-/* Define an interim macro for converting unsigned long long to long double. SGI compilers give
+/* Define an internal macro for converting unsigned long long to long double. SGI compilers give
* some incorect conversion. 64-bit Solaris does different rounding. Windows Visual Studio 6 does
* not support unsigned long long. For FreeBSD(sleipnir), the last 2 bytes of mantissa are lost when
* compiler tries to do the conversion. For Cygwin, compiler doesn't do rounding correctly. */
#if (H5_WANT_DATA_ACCURACY && H5_ULLONG_TO_FP_CAST_WORKS && H5_ULONG_TO_FP_BOTTOM_BIT_ACCURATE && \
H5_ULLONG_TO_LDOUBLE_PRECISION) || (!H5_WANT_DATA_ACCURACY && H5_ULLONG_TO_FP_CAST_WORKS)
-#define H5T_CONV_INTERIM_ULLONG_LDOUBLE 1
+#define H5T_CONV_INTERNAL_ULLONG_LDOUBLE 1
#endif
-/* Define an interim macro for converting long double to all integers. SGI compilers give some incorrect
+/* Define an internal macro for converting long double to all integers. SGI compilers give some incorrect
* conversions. HP-UX 11.00 compiler generates floating exception. */
#if (H5_WANT_DATA_ACCURACY && H5_LDOUBLE_TO_INTEGER_ACCURATE && H5_LDOUBLE_TO_INTEGER_WORKS) || \
(!H5_WANT_DATA_ACCURACY && H5_LDOUBLE_TO_INTEGER_WORKS)
-#define H5T_CONV_INTERIM_LDOUBLE_INTEGER 1
+#define H5T_CONV_INTERNAL_LDOUBLE_INTEGER 1
#endif
-/* Define an interim macro for converting long double to unsigned int. SGI compilers give some incorrect
+/* Define an internal macro for converting long double to unsigned int. SGI compilers give some incorrect
* conversions. HP-UX 11.00 compiler generates floating exception. Some Intel compilers on some Linux
* give incorrect values. */
#if (H5_WANT_DATA_ACCURACY && H5_LDOUBLE_TO_INTEGER_ACCURATE && H5_LDOUBLE_TO_UINT_ACCURATE && \
H5_LDOUBLE_TO_INTEGER_WORKS) || (!H5_WANT_DATA_ACCURACY && H5_LDOUBLE_TO_INTEGER_WORKS)
-#define H5T_CONV_INTERIM_LDOUBLE_UINT 1
+#define H5T_CONV_INTERNAL_LDOUBLE_UINT 1
#endif
-/* Define an interim macro for converting floating numbers to long long. The hard conversion on Windows
+/* Define an internal macro for converting floating numbers to long long. The hard conversion on Windows
* .NET 2003 has a bug and gives wrong exception value. */
#if (H5_WANT_DATA_ACCURACY && !H5_HW_FP_TO_LLONG_NOT_WORKS) || (!H5_WANT_DATA_ACCURACY)
-#define H5T_CONV_INTERIM_FP_LLONG 1
+#define H5T_CONV_INTERNAL_FP_LLONG 1
#endif
-/* Define an interim macro for converting long double to long long. SGI compilers give some incorrect
+/* Define an internal macro for converting long double to long long. SGI compilers give some incorrect
* conversions. HP-UX 11.00 compiler generates floating exception. The hard conversion on Windows
* .NET 2003 has a bug and gives wrong exception value. */
#if (H5_WANT_DATA_ACCURACY && !H5_HW_FP_TO_LLONG_NOT_WORKS && H5_LDOUBLE_TO_INTEGER_ACCURATE && \
H5_LDOUBLE_TO_INTEGER_WORKS) || \
(!H5_WANT_DATA_ACCURACY && !H5_HW_FP_TO_LLONG_NOT_WORKS && H5_LDOUBLE_TO_INTEGER_WORKS)
-#define H5T_CONV_INTERIM_LDOUBLE_LLONG 1
+#define H5T_CONV_INTERNAL_LDOUBLE_LLONG 1
#endif
-/* Define an interim macro for converting floating numbers to unsigned long long. PGI compiler does
+/* Define an internal macro for converting floating numbers to unsigned long long. PGI compiler does
* roundup when the source fraction part is greater than 0.5. HP-UX compilers set the maximal number
* for unsigned long long as 0x7fffffffffffffff during conversion. */
#if (H5_WANT_DATA_ACCURACY && H5_FP_TO_ULLONG_ACCURATE && H5_FP_TO_ULLONG_RIGHT_MAXIMUM) || \
(!H5_WANT_DATA_ACCURACY)
-#define H5T_CONV_INTERIM_FP_ULLONG 1
+#define H5T_CONV_INTERNAL_FP_ULLONG 1
#endif
-/* Define an interim macro for converting long double to all integers. SGI compilers give some incorrect
+/* Define an internal macro for converting long double to all integers. SGI compilers give some incorrect
* conversions. HP-UX 11.00 compiler generates floating exception. */
#if (H5_WANT_DATA_ACCURACY && H5_LDOUBLE_TO_INTEGER_ACCURATE && H5_LDOUBLE_TO_INTEGER_WORKS && \
H5_FP_TO_ULLONG_ACCURATE && H5_FP_TO_ULLONG_RIGHT_MAXIMUM) || \
(!H5_WANT_DATA_ACCURACY && H5_LDOUBLE_TO_INTEGER_WORKS)
-#define H5T_CONV_INTERIM_LDOUBLE_ULLONG 1
+#define H5T_CONV_INTERNAL_LDOUBLE_ULLONG 1
#endif
/* Statistics about a conversion function */
generated by cgit v0.12 at 2024-09-29 10:30:04 (GMT)
1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 
/*
 * Copyright (C) 1998 NCSA
 *                    All rights reserved.
 *
 * Programmer:  Quincey Koziol <koziol@ncsa.uiuc.edu>
 *              Thursday, June 18, 1998
 *
 * Purpose:	Hyperslab selection data space I/O functions.
 */
#include <H5private.h>
#include <H5Eprivate.h>
#include <H5Sprivate.h>
#include <H5Vprivate.h>
#include <H5MMprivate.h>
#include <H5TBprivate.h>
#include <H5Dprivate.h>

/* Interface initialization */
#define PABLO_MASK      H5Shyper_mask
#define INTERFACE_INIT  NULL
static intn             interface_initialize_g = 0;

/* Local datatypes */
/* Parameter block for H5S_hyper_fread & H5S_hyper_fwrite */
typedef struct {
    H5F_t *f;
    const struct H5O_layout_t *layout;
    const struct H5O_pline_t *pline;
    const struct H5O_fill_t *fill;
    const struct H5O_efl_t *efl;
    size_t elmt_size;
    const H5S_t *space;
    H5S_sel_iter_t *iter;
	size_t nelmts;
    const H5D_xfer_t *xfer_parms;
    const void *src;
    void *dst;
    H5S_hyper_bound_t **lo_bounds;
    H5S_hyper_bound_t **hi_bounds;
} H5S_hyper_fhyper_info_t;

/* Static function prototypes */
static intn H5S_hyper_bsearch(hssize_t size, H5S_hyper_bound_t *barr,
			      size_t count);
static hid_t
H5S_hyper_get_regions (size_t *num_regions, intn dim, size_t bound_count,
		       H5S_hyper_bound_t **lo_bounds,
		       H5S_hyper_bound_t **hi_bounds, hssize_t *pos,
		       hssize_t *offset);
static size_t H5S_hyper_fread (intn dim, H5S_hyper_fhyper_info_t *fhyper_info);
static size_t H5S_hyper_fwrite (intn dim,
				H5S_hyper_fhyper_info_t *fhyper_info);
static herr_t H5S_hyper_init (const struct H5O_layout_t *layout,
			      const H5S_t *space, H5S_sel_iter_t *iter);
static size_t H5S_hyper_favail (const H5S_t *space, const H5S_sel_iter_t *iter,
				size_t max);
static size_t H5S_hyper_fgath (H5F_t *f, const struct H5O_layout_t *layout,
			       const struct H5O_pline_t *pline,
			       const struct H5O_fill_t *fill,
			       const struct H5O_efl_t *efl, size_t elmt_size,
			       const H5S_t *file_space,
			       H5S_sel_iter_t *file_iter, size_t nelmts,
			       const H5D_xfer_t *xfer_parms, void *buf/*out*/);
static herr_t H5S_hyper_fscat (H5F_t *f, const struct H5O_layout_t *layout,
			       const struct H5O_pline_t *pline,
			       const struct H5O_fill_t *fill,
			       const struct H5O_efl_t *efl, size_t elmt_size,
			       const H5S_t *file_space,
			       H5S_sel_iter_t *file_iter, size_t nelmts,
			       const H5D_xfer_t *xfer_parms, const void *buf);
static size_t H5S_hyper_mgath (const void *_buf, size_t elmt_size,
			       const H5S_t *mem_space,
			       H5S_sel_iter_t *mem_iter, size_t nelmts,
			       void *_tconv_buf/*out*/);
static herr_t H5S_hyper_mscat (const void *_tconv_buf, size_t elmt_size,
			       const H5S_t *mem_space,
			       H5S_sel_iter_t *mem_iter, size_t nelmts,
			       void *_buf/*out*/);

const H5S_fconv_t	H5S_HYPER_FCONV[1] = {{
    "hslab",	 				/*name			*/
    H5S_SEL_HYPERSLABS,				/*selection type	*/
    H5S_hyper_init,				/*initialize		*/
    H5S_hyper_favail,				/*available		*/
    H5S_hyper_fgath,				/*gather		*/
    H5S_hyper_fscat,				/*scatter		*/
}};

const H5S_mconv_t	H5S_HYPER_MCONV[1] = {{
    "hslab",					/*name			*/
    H5S_SEL_HYPERSLABS,				/*selection type	*/
    H5S_hyper_init, 				/*initialize		*/
    H5S_hyper_mgath,				/*gather		*/
    H5S_hyper_mscat,				/*scatter		*/
}};

/* Array for use with I/O algorithms which frequently need array of zeros */
static const hssize_t	zero[H5O_LAYOUT_NDIMS]={0};		/* Array of zeros */


/*-------------------------------------------------------------------------
 * Function:	H5S_hyper_init
 *
 * Purpose:	Initializes iteration information for hyperslab selection.
 *
 * Return:	non-negative on success, negative on failure.
 *
 * Programmer:	Quincey Koziol
 *              Tuesday, June 16, 1998
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static herr_t
H5S_hyper_init (const struct H5O_layout_t UNUSED *layout,
	       const H5S_t *space, H5S_sel_iter_t *sel_iter)
{
    FUNC_ENTER (H5S_hyper_init, FAIL);

    /* Check args */
    assert (layout);
    assert (space && H5S_SEL_HYPERSLABS==space->select.type);
    assert (sel_iter);

    /* Initialize the number of points to iterate over */
    sel_iter->hyp.elmt_left=space->select.num_elem;

    /* Allocate the position & initialize to invalid location */
    sel_iter->hyp.pos = H5MM_malloc(space->extent.u.simple.rank * sizeof(hssize_t));
    sel_iter->hyp.pos[0]=(-1);
    H5V_array_fill(sel_iter->hyp.pos, sel_iter->hyp.pos, sizeof(hssize_t),
		   space->extent.u.simple.rank);
    
    FUNC_LEAVE (SUCCEED);
}   /* H5S_hyper_init() */

/*-------------------------------------------------------------------------
 * Function:	H5S_hyper_favail
 *
 * Purpose:	Figure out the optimal number of elements to transfer to/from the file
 *
 * Return:	non-negative number of elements on success, negative on failure
 *
 * Programmer:	Quincey Koziol
 *              Tuesday, June 16, 1998
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static size_t
H5S_hyper_favail (const H5S_t UNUSED *space,
		  const H5S_sel_iter_t *sel_iter, size_t max)
{
    FUNC_ENTER (H5S_hyper_favail, FAIL);

    /* Check args */
    assert (space && H5S_SEL_HYPERSLABS==space->select.type);
    assert (sel_iter);

#ifdef QAK
    printf("%s: max=%d\n",FUNC,(int)max);
#endif /* QAK */
    FUNC_LEAVE (MIN(sel_iter->hyp.elmt_left,max));
}   /* H5S_hyper_favail() */

/*-------------------------------------------------------------------------
 * Function:	H5S_hyper_compare_regions
 *
 * Purpose:	Compares two regions for equality (regions must not overlap!)
 *
 * Return:	an integer less than, equal to, or greater than zero if the
 *		first region is considered to be respectively less than,
 *		equal to, or greater than the second
 *
 * Programmer:	Quincey Koziol
 *              Friday, July 17, 1998
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
int
H5S_hyper_compare_regions (const void *r1, const void *r2)
{
    if (((const H5S_hyper_region_t *)r1)->start < ((const H5S_hyper_region_t *)r2)->start)
        return(-1);
    else if (((const H5S_hyper_region_t *)r1)->start > ((const H5S_hyper_region_t *)r2)->start)
        return(1);
    else
        return(0);
}   /* end H5S_hyper_compare_regions */

/*-------------------------------------------------------------------------
 * Function:	H5S_hyper_get_regions
 *
 * Purpose:	Builds a sorted array of the overlaps in a dimension
 *
 * Return:	Success:	Pointer to valid array (num_regions parameter
 *				set to array size)
 *
 *		Failure:	0
 *
 * Programmer:	Quincey Koziol
 *              Monday, June 29, 1998
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static hid_t
H5S_hyper_get_regions (size_t *num_regions, intn dim, size_t bound_count,
   H5S_hyper_bound_t **lo_bounds, H5S_hyper_bound_t **hi_bounds, hssize_t *pos,
   hssize_t *offset)
{
    hid_t ret_value=FAIL;	            /* Id of temporary buffer to return */
    H5S_hyper_region_t *reg=NULL;	    /* Pointer to array of regions */
    H5S_hyper_node_t *node;             /* Region node for a given boundary */
    size_t num_reg=0;                   /* Number of regions in array */
    size_t curr_reg=0;                  /* The current region we are working with */
    size_t uniq_reg;                    /* The number of unique regions */
    intn next_dim;                      /* Next fastest dimension */
    intn temp_dim;                      /* Temporary dim. holder */
    size_t i;                           /* Counters */

    FUNC_ENTER (H5S_hyper_get_regions, FAIL);
    
    assert(num_regions);
    assert(lo_bounds);
    assert(hi_bounds);
    assert(pos);

#ifdef QAK
    printf("%s: check 1.0, dim=%d\n",FUNC,dim);
    for(i=0; i<2; i++)
	printf("%s: %d - pos=%d\n",FUNC,i,(int)pos[i]);
#endif /* QAK */

    /* Check if we need to generate a list of regions for the 0th dim. */
    if(dim<0) {
#ifdef QAK
	printf("%s: check 1.1, bound_count=%d\n",FUNC,bound_count);
#endif /* QAK */
        for(i=0; i<bound_count; i++) {
            /* Skip past already iterated regions */
            if(pos[0]==(-1) || ((pos[0]+offset[0])>=lo_bounds[0][i].bound && (pos[0]+offset[0]) <= hi_bounds[0][i].bound)) {
                /* Check if we've allocated the array yet */
                if(num_reg==0) {
                    /* Allocate temporary buffer */
                    ret_value=H5TB_get_buf(sizeof(H5S_hyper_region_t),0,(void **)&reg);

                    /* Initialize with first region */
                    reg[0].start=MAX(lo_bounds[0][i].bound,pos[0])+offset[0];
                    reg[0].end=hi_bounds[0][i].bound+offset[0];
                    reg[0].node=hi_bounds[0][i].node;

                    /* Increment the number of regions */
                    num_reg++;
                } else {
                    /*
                     * Check if we should merge this region into the current
                     * region.
                     */
                    if(lo_bounds[0][i].bound<reg[curr_reg].end) {
                        reg[curr_reg].end=MAX(hi_bounds[0][i].bound,
						    reg[curr_reg].end)+(offset!=NULL ? offset[0] : 0 );
                    } else { /* no overlap with previous region, add new region */
                        /* Check if this is actually a different region */
                        if(lo_bounds[0][i].bound!=reg[curr_reg].start &&
                            hi_bounds[0][i].bound!=reg[curr_reg].end) {

                            /* Enlarge array */
                            H5TB_resize_buf(ret_value,(sizeof(H5S_hyper_region_t)*(num_reg+1)));
                            reg=H5TB_buf_ptr(ret_value);

                            /* Initialize with new region */
                            reg[num_reg].start=lo_bounds[0][i].bound+offset[0];
                            reg[num_reg].end=hi_bounds[0][i].bound+offset[0];
                            reg[num_reg].node=hi_bounds[0][i].node;

                            /*
                             * Increment the number of regions & the current
                             * region.
                             */
                            num_reg++;
                            curr_reg++;
                        } /* end if */
                    } /* end else */
                } /* end else */
            } /* end if */
        } /* end for */
    } else {
	/* Generate list of regions based on the current position */
#ifdef QAK
	printf("%s: check 2.0, bound_count=%d\n",FUNC,bound_count);
	printf("%s: check 2.0, pos[%d]=%d, offset[%d]=%d, hi_bounds[%d][%d].bound=%d\n",FUNC,(int)dim,(int)pos[dim],(int)dim,(int)offset[dim],
        (int)dim,(int)0,(int)hi_bounds[dim][0].bound);
#endif /* QAK */
        next_dim=dim+1;
        /* Skip past bounds which don't overlap */
        i=0;
        while(pos[dim]>(hi_bounds[dim][i].bound+offset[dim]) && i<bound_count)
            i++;
#ifdef QAK
	printf("%s: check 2.0.5, lo_bounds[%d][%d].bound=%d\n",FUNC,
        (int)dim,(int)i,(int)lo_bounds[dim][i].bound);
#endif /* QAK */

        for (/*void*/;
             i<bound_count && pos[dim]>=lo_bounds[dim][i].bound+offset[dim];
	     i++) {
#ifdef QAK
	    printf("%s: check 2.1, i=%d, num_reg=%d, pos[%d]=%d\n",
		   FUNC,i,(int)num_reg,dim,(int)pos[dim]);
	    {
		intn j;
		node=lo_bounds[dim][i].node;
		for(j=next_dim; j>=0; j--)
		    printf("%s: lo_bound[%d]=%d, hi_bound[%d]=%d\n",
			   FUNC,j,(int)node->start[j],j,(int)node->end[j]);
	    }
#endif /* QAK */
            /* Check if each boundary overlaps in the higher dimensions */
            node=lo_bounds[dim][i].node;
            temp_dim=dim;
            while(temp_dim>=0 && pos[temp_dim]>=(node->start[temp_dim]+offset[temp_dim]) && pos[temp_dim]<=(node->end[temp_dim]+offset[temp_dim]))
                temp_dim--;

            /* Yes, all previous positions match, this is a valid region */
            if(temp_dim<0) {
#ifdef QAK
		printf("%s: check 3.0\n",FUNC);
#endif /* QAK */
                /* Check if we've allocated the array yet */
                if(num_reg==0) {
#ifdef QAK
		    printf("%s: check 3.1\n", FUNC);
#endif /* QAK */
                    /* Allocate temporary buffer */
                    ret_value=H5TB_get_buf(sizeof(H5S_hyper_region_t),0,(void **)&reg);

                    /* Initialize with first region */
                    reg[0].start=MAX(node->start[next_dim],pos[next_dim])+offset[next_dim];
                    reg[0].end=node->end[next_dim]+offset[next_dim];
                    reg[0].node=node;
#ifdef QAK
		    printf("%s: check 3.2, lo_bounds=%d, start=%d, "
			   "hi_bounds=%d, end=%d\n",
			   FUNC, (int)node->start[next_dim],
			   (int)reg[curr_reg].start,
			   (int)node->end[next_dim],
			   (int)reg[curr_reg].end);
#endif /* QAK */

                    /* Increment the number of regions */
                    num_reg++;
                } else {
#ifdef QAK
		    printf("%s: check 4.0, lo_bounds=%d, start=%d, "
			   "hi_bounds=%d, end=%d\n",
			   FUNC, (int)node->start[next_dim],
			   (int)reg[curr_reg].start,
			   (int)node->end[next_dim],
			   (int)reg[curr_reg].end);
#endif /* QAK */
                    /* Enlarge array */
                    H5TB_resize_buf(ret_value,(sizeof(H5S_hyper_region_t)*(num_reg+1)));
                    reg=H5TB_buf_ptr(ret_value);

                    /* Initialize with new region */
                    reg[num_reg].start=node->start[next_dim]+offset[next_dim];
                    reg[num_reg].end=node->end[next_dim]+offset[next_dim];
                    reg[num_reg].node=node;

                    /* Increment the number of regions & the current region */
                    num_reg++;
                    curr_reg++;
                } /* end else */
            } /* end if */
        } /* end for */

        /* Sort region list and eliminate duplicates if necessary */
        if(num_reg>1) {
            HDqsort(reg,num_reg,sizeof(H5S_hyper_region_t),H5S_hyper_compare_regions);
            for(i=1,curr_reg=0,uniq_reg=1; i<num_reg; i++) {
                if(reg[curr_reg].start!=reg[i].start &&
                        reg[curr_reg].end!=reg[i].end) {
                    uniq_reg++;
                    curr_reg++;
                    reg[curr_reg].start=reg[i].start;
                    reg[curr_reg].end=reg[i].end;
                    reg[curr_reg].node=reg[i].node;
                } /* end if */
            } /* end for */
            num_reg=uniq_reg;
        } /* end if */
    } /* end else */

    /* Save the number of regions we generated */
    *num_regions=num_reg;

#ifdef QAK
    printf("%s: check 10.0, reg=%p, num_reg=%d\n",
	   FUNC,reg,num_reg);
    for(i=0; i<num_reg; i++)
        printf("%s: start[%d]=%d, end[%d]=%d\n",
	       FUNC,i,(int)reg[i].start,i,(int)reg[i].end);
#endif /* QAK */

    FUNC_LEAVE (ret_value);
} /* end H5S_hyper_get_regions() */

/*-------------------------------------------------------------------------
 * Function:	H5S_hyper_block_cache
 *
 * Purpose:	Cache a hyperslab block for reading or writing.
 *
 * Return:	Non-negative on success/Negative on failure
 *
 * Programmer:	Quincey Koziol
 *              Monday, September 21, 1998
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static herr_t
H5S_hyper_block_cache (H5S_hyper_node_t *node,
		       H5S_hyper_fhyper_info_t *fhyper_info, uintn block_read)
{
    hssize_t	file_offset[H5O_LAYOUT_NDIMS];	/*offset of slab in file*/
    hsize_t	hsize[H5O_LAYOUT_NDIMS];	/*size of hyperslab	*/
    intn i;                   /* Counters */

    FUNC_ENTER (H5S_hyper_block_cache, SUCCEED);

    assert(node);
    assert(fhyper_info);

    /* Allocate temporary buffer of proper size */
    if((node->cinfo.block_id=H5TB_get_buf(node->cinfo.size*fhyper_info->elmt_size,1,(void **)&(node->cinfo.block)))<0)
        HRETURN_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
            "can't allocate hyperslab cache block");

    /* Read in block, if we are read caching */
    if(block_read) {
        /* Copy the location of the region in the file */
        HDmemcpy(file_offset,node->start,(fhyper_info->space->extent.u.simple.rank * sizeof(hssize_t)));
        file_offset[fhyper_info->space->extent.u.simple.rank]=0;

        /* Set the hyperslab size to read */
        for(i=0; i<fhyper_info->space->extent.u.simple.rank; i++)
            hsize[i]=(node->end[i]-node->start[i])+1;
        hsize[fhyper_info->space->extent.u.simple.rank]=fhyper_info->elmt_size;

        if (H5F_arr_read (fhyper_info->f, fhyper_info->xfer_parms,
			  fhyper_info->layout, fhyper_info->pline,
			  fhyper_info->fill, fhyper_info->efl, hsize, hsize,
			  zero, file_offset, node->cinfo.block/*out*/)<0)
            HRETURN_ERROR (H5E_DATASPACE, H5E_READERROR, FAIL, "read error");
    } /* end if */
    else {
/* keep information for writing block later? */
    } /* end else */
    
    /* Set up parameters for accessing block */
    node->cinfo.left=node->cinfo.size;
    node->cinfo.pos=node->cinfo.block;

    /* Set cached flag */
    node->cinfo.cached=1;

    FUNC_LEAVE (SUCCEED);
}   /* H5S_hyper_block_cache() */

/*-------------------------------------------------------------------------
 * Function:	H5S_hyper_block_read
 *
 * Purpose:	Read in data from a cached hyperslab block
 *
 * Return:	Non-negative on success/Negative on failure
 *
 * Programmer:	Quincey Koziol
 *              Monday, September 21, 1998
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static herr_t
H5S_hyper_block_read (H5S_hyper_node_t *node, H5S_hyper_fhyper_info_t *fhyper_info, hsize_t region_size)
{
    FUNC_ENTER (H5S_hyper_block_read, SUCCEED);

    assert(node && node->cinfo.cached);
    assert(fhyper_info);

    /* Copy the elements into the user's buffer */
    /*
        !! NOTE !! This will need to be changed for different dimension
            permutations from the standard 'C' ordering!
    */
    HDmemcpy(fhyper_info->dst,
	     node->cinfo.pos,
	     (size_t)(region_size*fhyper_info->elmt_size));

    /*
     * Decrement the number of elements left in block to read & move the
     * offset
     */
    node->cinfo.pos+=region_size*fhyper_info->elmt_size;
    node->cinfo.left-=region_size;

    /* If we've read in all the elements from the block, throw it away */
    if(node->cinfo.left==0) {
        /* Release the temporary buffer */
        H5TB_release_buf(node->cinfo.block_id);

        /* Reset the caching flag for next time */
        node->cinfo.cached=0;
    } /* end if */

    FUNC_LEAVE (SUCCEED);
}   /* H5S_hyper_block_read() */

/*-------------------------------------------------------------------------
 * Function:	H5S_hyper_block_write
 *
 * Purpose:	Write out data to a cached hyperslab block
 *
 * Return:	Non-negative on success/Negative on failure
 *
 * Programmer:	Quincey Koziol
 *              Monday, September 21, 1998
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static herr_t
H5S_hyper_block_write (H5S_hyper_node_t *node,
		       H5S_hyper_fhyper_info_t *fhyper_info,
		       hsize_t region_size)
{
    hssize_t	file_offset[H5O_LAYOUT_NDIMS];	/*offset of slab in file*/
    hsize_t	hsize[H5O_LAYOUT_NDIMS];	/*size of hyperslab	*/
    intn i;                   /* Counters */

    FUNC_ENTER (H5S_hyper_block_write, SUCCEED);

    assert(node && node->cinfo.cached);
    assert(fhyper_info);

    /* Copy the elements into the user's buffer */
    /*
        !! NOTE !! This will need to be changed for different dimension
            permutations from the standard 'C' ordering!
    */
    HDmemcpy(node->cinfo.pos,
	     fhyper_info->src,
	     (size_t)(region_size*fhyper_info->elmt_size));

    /*
     * Decrement the number of elements left in block to read & move the
     * offset
     */
    node->cinfo.pos+=region_size*fhyper_info->elmt_size;
    node->cinfo.left-=region_size;

    /* If we've read in all the elements from the block, throw it away */
    if(node->cinfo.left==0) {
        /* Copy the location of the region in the file */
        HDmemcpy(file_offset,
		 node->start,
		 (fhyper_info->space->extent.u.simple.rank *
		  sizeof(hssize_t)));
        file_offset[fhyper_info->space->extent.u.simple.rank]=0;

        /* Set the hyperslab size to write */
        for(i=0; i<fhyper_info->space->extent.u.simple.rank; i++)
            hsize[i]=(node->end[i]-node->start[i])+1;
        hsize[fhyper_info->space->extent.u.simple.rank]=fhyper_info->elmt_size;

        if (H5F_arr_write (fhyper_info->f, fhyper_info->xfer_parms,
			   fhyper_info->layout, fhyper_info->pline,
			   fhyper_info->fill, fhyper_info->efl, hsize, hsize,
			   zero, file_offset, node->cinfo.block/*out*/)<0)
            HRETURN_ERROR (H5E_DATASPACE, H5E_WRITEERROR, FAIL, "write error");

        /* Release the temporary buffer */
        H5TB_release_buf(node->cinfo.block_id);

        /* Reset the caching flag for next time */
        node->cinfo.cached=0;
    } /* end if */

    FUNC_LEAVE (SUCCEED);
}   /* H5S_hyper_block_write() */

/*-------------------------------------------------------------------------
 * Function:	H5S_hyper_fread
 *
 * Purpose:	Recursively gathers data points from a file using the
 *		parameters passed to H5S_hyper_fgath.
 *
 * Return:	Success:	Number of elements copied.
 *
 *		Failure:	0
 *
 * Programmer:	Quincey Koziol
 *              Tuesday, June 16, 1998
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static size_t
H5S_hyper_fread (intn dim, H5S_hyper_fhyper_info_t *fhyper_info)
{
    hssize_t	file_offset[H5O_LAYOUT_NDIMS];	/*offset of slab in file*/
    hsize_t	hsize[H5O_LAYOUT_NDIMS];	/*size of hyperslab	*/
    hsize_t region_size;                /* Size of lowest region */
    uintn parm_init=0;          /* Whether one-shot parameters set up */
    hid_t reg_id;               /* ID of temporary region buffer */
    H5S_hyper_region_t *regions;  /* Pointer to array of hyperslab nodes overlapped */
    size_t num_regions;         /* number of regions overlapped */
    size_t i;                   /* Counters */
    intn j;
    size_t num_read=0;          /* Number of elements read */

    FUNC_ENTER (H5S_hyper_fread, 0);

    assert(fhyper_info);

#ifdef QAK
    printf("%s: check 1.0, dim=%d\n",FUNC,dim);
#endif /* QAK */

    /* Get a sorted list (in the next dimension down) of the regions which */
    /*  overlap the current index in this dim */
    if((reg_id=H5S_hyper_get_regions(&num_regions,dim,
            fhyper_info->space->select.sel_info.hslab.hyper_lst->count,
            fhyper_info->lo_bounds, fhyper_info->hi_bounds,
            fhyper_info->iter->hyp.pos,fhyper_info->space->select.offset))>=0) {

        /* Get the pointer to the actual regions array */
        regions=H5TB_buf_ptr(reg_id);

        /*
	 * Check if this is the second to last dimension in dataset (Which
	 * means that we've got a list of the regions in the fastest changing
	 * dimension and should input those regions).
	 */
#ifdef QAK
	printf("%s: check 2.0, rank=%d\n",
	       FUNC,(int)fhyper_info->space->extent.u.simple.rank);
	for(i=0; i<num_regions; i++)
	    printf("%s: check 2.1, region #%d: start=%d, end=%d\n",
		   FUNC,i,(int)regions[i].start,(int)regions[i].end);
#endif /* QAK */
        if((dim+2)==fhyper_info->space->extent.u.simple.rank) {
            /* perform I/O on data from regions */
            for(i=0; i<num_regions && fhyper_info->nelmts>0; i++) {
                /* Compute the size of the region to read */
                region_size=MIN(fhyper_info->nelmts,
				(regions[i].end-regions[i].start)+1);

                /* Check if this hyperslab block is cached or could be cached */
                if(!regions[i].node->cinfo.cached &&
		   (fhyper_info->xfer_parms->cache_hyper &&
		    (fhyper_info->xfer_parms->block_limit==0 ||
		     fhyper_info->xfer_parms->block_limit>=(regions[i].node->cinfo.size*fhyper_info->elmt_size)))) {
                    /* if we aren't cached, attempt to cache the block */
                    H5S_hyper_block_cache(regions[i].node,fhyper_info,1);
                } /* end if */

                /* Read information from the cached block */
                if(regions[i].node->cinfo.cached) {
                    if(H5S_hyper_block_read(regions[i].node,fhyper_info,region_size)<0)
                        HRETURN_ERROR (H5E_DATASPACE, H5E_READERROR, 0, "read error");
                }
                else {
                    /* Set up hyperslab I/O parameters which apply to all regions */
                    if(!parm_init) {
                        /* Copy the location of the region in the file */
                        HDmemcpy(file_offset,fhyper_info->iter->hyp.pos,(fhyper_info->space->extent.u.simple.rank * sizeof(hssize_t)));
                        file_offset[fhyper_info->space->extent.u.simple.rank]=0;

                        /* Set the hyperslab size to copy */
                        hsize[0]=1;
                        H5V_array_fill(hsize,hsize,sizeof(hsize[0]),fhyper_info->space->extent.u.simple.rank);
                        hsize[fhyper_info->space->extent.u.simple.rank]=fhyper_info->elmt_size;
                        
                        /* Set flag */
                        parm_init=1;
                    } /* end if */

#ifdef QAK
            printf("%s: check 2.2, i=%d\n",FUNC,(int)i);
#endif /* QAK */
                    /* Fill in the region specific parts of the I/O request */
                    hsize[fhyper_info->space->extent.u.simple.rank-1]=region_size;
                    file_offset[fhyper_info->space->extent.u.simple.rank-1]=regions[i].start;

                    /*
                     * Gather from file.
                     */
                    if (H5F_arr_read (fhyper_info->f, fhyper_info->xfer_parms,
				      fhyper_info->layout, fhyper_info->pline,
				      fhyper_info->fill, fhyper_info->efl,
				      hsize, hsize, zero, file_offset,
				      fhyper_info->dst/*out*/)<0) {
                        HRETURN_ERROR (H5E_DATASPACE, H5E_READERROR, 0,
				       "read error");
                    }
#ifdef QAK
		    printf("%s: check 2.3, region #%d\n",FUNC,(int)i);
		    for(j=0; j<fhyper_info->space->extent.u.simple.rank; j++)
			printf("%s: %d - pos=%d\n",
			       FUNC,j,(int)fhyper_info->iter->hyp.pos[j]);
#endif /* QAK */
                } /* end else */

                /* Advance the pointer in the buffer */
                fhyper_info->dst = ((uint8_t *)fhyper_info->dst) +
				   region_size*fhyper_info->elmt_size;

                /* Increment the number of elements read */
                num_read+=region_size;

                /* Decrement the buffer left */
                fhyper_info->nelmts-=region_size;

                /* Set the next position to start at */
                if(region_size==(hsize_t)((regions[i].end-regions[i].start)+1))
                    fhyper_info->iter->hyp.pos[dim+1]=(-1);
                else
                    fhyper_info->iter->hyp.pos[dim+1] = regions[i].start + region_size;

                /* Decrement the iterator count */
                fhyper_info->iter->hyp.elmt_left-=region_size;
            } /* end for */
        } else { /* recurse on each region to next dimension down */
#ifdef QAK
	    printf("%s: check 3.0, num_regions=%d\n",FUNC,(int)num_regions);
#endif /* QAK */

            /* Increment the dimension we are working with */
            dim++;

            /* Step through each region in this dimension */
            for(i=0; i<num_regions && fhyper_info->nelmts>0; i++) {
                /* Step through each location in each region */
                for(j=regions[i].start; j<=regions[i].end && fhyper_info->nelmts>0; j++) {
#ifdef QAK
		    printf("%s: check 4.0, dim=%d, location=%d\n",FUNC,dim,j);
#endif /* QAK */

                    /*
		     * If we are moving to a new position in this dim, reset
		     * the next lower dim. location.
		     */
                    if(fhyper_info->iter->hyp.pos[dim]!=j)
                        fhyper_info->iter->hyp.pos[dim+1]=(-1);

                    /* Set the correct position we are working on */
                    fhyper_info->iter->hyp.pos[dim]=j;

                    /* Go get the regions in the next lower dimension */
                    num_read+=H5S_hyper_fread(dim, fhyper_info);
                } /* end for */
            } /* end for */
        } /* end else */

        /* Release the temporary buffer */
        H5TB_release_buf(reg_id);
    } /* end if */

    FUNC_LEAVE (num_read);
}   /* H5S_hyper_fread() */

/*-------------------------------------------------------------------------
 * Function:	H5S_hyper_fgath
 *
 * Purpose:	Gathers data points from file F and accumulates them in the
 *		type conversion buffer BUF.  The LAYOUT argument describes
 *		how the data is stored on disk and EFL describes how the data
 *		is organized in external files.  ELMT_SIZE is the size in
 *		bytes of a datum which this function treats as opaque.
 *		FILE_SPACE describes the data space of the dataset on disk
 *		and the elements that have been selected for reading (via
 *		hyperslab, etc).  This function will copy at most NELMTS elements.
 *
 * Return:	Success:	Number of elements copied.
 *
 *		Failure:	0
 *
 * Programmer:	Quincey Koziol
 *              Tuesday, June 16, 1998
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static size_t
H5S_hyper_fgath (H5F_t *f, const struct H5O_layout_t *layout,
		 const struct H5O_pline_t *pline,
		 const struct H5O_fill_t *fill,
		 const struct H5O_efl_t *efl, size_t elmt_size,
		 const H5S_t *file_space, H5S_sel_iter_t *file_iter,
		 size_t nelmts, const H5D_xfer_t *xfer_parms,
		 void *_buf/*out*/)
{
    H5S_hyper_bound_t **lo_bounds;    /* Lower (closest to the origin) bound array for each dimension */
    H5S_hyper_bound_t **hi_bounds;    /* Upper (farthest from the origin) bound array for each dimension */
    H5S_hyper_fhyper_info_t fhyper_info;  /* Block of parameters to pass into recursive calls */
    intn	i;				/*counters		*/
    size_t  num_read;       /* number of elements read into buffer */

    FUNC_ENTER (H5S_hyper_fgath, 0);

    /* Check args */
    assert (f);
    assert (layout);
    assert (elmt_size>0);
    assert (file_space);
    assert (file_iter);
    assert (nelmts>0);
    assert (_buf);

#ifdef QAK
    printf("%s: check 1.0\n", FUNC);
#endif /* QAK */
    /* Allocate space for the low & high bound arrays */
    lo_bounds = H5MM_malloc(file_space->extent.u.simple.rank *
			    sizeof(H5S_hyper_bound_t *));
    hi_bounds = H5MM_malloc(file_space->extent.u.simple.rank *
			    sizeof(H5S_hyper_bound_t *));

    /* Initialize to correct order to walk through arrays.
        (When another iteration order besides the default 'C' order is chosen,
        this is the correct place to change the order of the array iterations)
    */
    for(i=0; i<file_space->extent.u.simple.rank; i++) {
        lo_bounds[i]=file_space->select.sel_info.hslab.hyper_lst->lo_bounds[i];
        hi_bounds[i]=file_space->select.sel_info.hslab.hyper_lst->hi_bounds[i];
    } /* end for */

    /* Initialize parameter block for recursive calls */
    fhyper_info.f=f;
    fhyper_info.layout=layout;
    fhyper_info.pline=pline;
    fhyper_info.fill=fill;
    fhyper_info.efl=efl;
    fhyper_info.elmt_size=elmt_size;
    fhyper_info.space=file_space;
    fhyper_info.iter=file_iter;
    fhyper_info.nelmts=nelmts;
    fhyper_info.xfer_parms=xfer_parms;
    fhyper_info.src=NULL;
    fhyper_info.dst=_buf;
    fhyper_info.lo_bounds=lo_bounds;
    fhyper_info.hi_bounds=hi_bounds;

    /* Recursively input the hyperslabs currently defined */
    /* starting with the slowest changing dimension */
#ifdef QAK
    printf("%s: check 4.0\n",FUNC);
#endif /* QAK */
    num_read=H5S_hyper_fread(-1,&fhyper_info);
#ifdef QAK
    printf("%s: check 5.0, num_read=%d\n",FUNC,(int)num_read);
#endif /* QAK */

    /* Release the memory we allocated */
    H5MM_xfree(lo_bounds);
    H5MM_xfree(hi_bounds);
    
    FUNC_LEAVE (num_read);
} /* H5S_hyper_fgath() */

/*-------------------------------------------------------------------------
 * Function:	H5S_hyper_fwrite
 *
 * Purpose:	Recursively scatters data points to a file using the parameters
 *      passed to H5S_hyper_fscat.
 *
 * Return:	Success:	Number of elements copied.
 *
 *		Failure:	0
 *
 * Programmer:	Quincey Koziol
 *              Tuesday, June 16, 1998
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static size_t
H5S_hyper_fwrite (intn dim, H5S_hyper_fhyper_info_t *fhyper_info)
{
    hssize_t	file_offset[H5O_LAYOUT_NDIMS];	/*offset of slab in file*/
    hsize_t	hsize[H5O_LAYOUT_NDIMS];	/*size of hyperslab	*/
    hsize_t region_size;                /* Size of lowest region */
    uintn parm_init=0;          /* Whether one-shot parameters set up */
    hid_t reg_id;               /* ID of temporary region buffer */
    H5S_hyper_region_t *regions;  /* Pointer to array of hyperslab nodes overlapped */
    size_t num_regions;         /* number of regions overlapped */
    size_t i;                   /* Counters */
    intn j;
    size_t num_written=0;          /* Number of elements read */

    FUNC_ENTER (H5S_hyper_fwrite, 0);

    assert(fhyper_info);

#ifdef QAK
    printf("%s: check 1.0\n", FUNC);
#endif /* QAK */
    /* Get a sorted list (in the next dimension down) of the regions which */
    /*  overlap the current index in this dim */
    if((reg_id=H5S_hyper_get_regions(&num_regions,dim,
            fhyper_info->space->select.sel_info.hslab.hyper_lst->count,
            fhyper_info->lo_bounds, fhyper_info->hi_bounds,
            fhyper_info->iter->hyp.pos,fhyper_info->space->select.offset))>=0) {

        /* Get the pointer to the actual regions array */
        regions=H5TB_buf_ptr(reg_id);
#ifdef QAK
    printf("%s: check 1.1, regions=%p\n", FUNC,regions);
#endif /* QAK */

        /* Check if this is the second to last dimension in dataset */
        /*  (Which means that we've got a list of the regions in the fastest */
        /*   changing dimension and should input those regions) */
        if((dim+2)==fhyper_info->space->extent.u.simple.rank) {

            /* perform I/O on data from regions */
            for(i=0; i<num_regions && fhyper_info->nelmts>0; i++) {
                /* Compute the size of the region to read */
                region_size=MIN(fhyper_info->nelmts, (regions[i].end-regions[i].start)+1);

                /* Check if this hyperslab block is cached or could be cached */
                if(!regions[i].node->cinfo.cached && (fhyper_info->xfer_parms->cache_hyper && (fhyper_info->xfer_parms->block_limit==0 || fhyper_info->xfer_parms->block_limit>=(regions[i].node->cinfo.size*fhyper_info->elmt_size)))) {
                    /* if we aren't cached, attempt to cache the block */
                    H5S_hyper_block_cache(regions[i].node,fhyper_info,0);
                } /* end if */

                /* Read information from the cached block */
                if(regions[i].node->cinfo.cached) {
                    if(H5S_hyper_block_write(regions[i].node,fhyper_info,region_size)<0)
                        HRETURN_ERROR (H5E_DATASPACE, H5E_WRITEERROR, 0, "write error");
                }
                else {
                    /* Set up hyperslab I/O parameters which apply to all regions */
                    if(!parm_init) {

                        /* Copy the location of the region in the file */
                        HDmemcpy(file_offset, fhyper_info->iter->hyp.pos,
                         (fhyper_info->space->extent.u.simple.rank *
                          sizeof(hssize_t)));
                        file_offset[fhyper_info->space->extent.u.simple.rank]=0;

                        /* Set the hyperslab size to copy */
                        hsize[0]=1;
                        H5V_array_fill(hsize, hsize, sizeof(hsize[0]),
                           fhyper_info->space->extent.u.simple.rank);
                        hsize[fhyper_info->space->extent.u.simple.rank]=fhyper_info->elmt_size;

                        /* Set flag */
                        parm_init=1;
                    } /* end if */

                    hsize[fhyper_info->space->extent.u.simple.rank-1]=region_size;
                    file_offset[fhyper_info->space->extent.u.simple.rank-1]=regions[i].start;

                    /*
                     * Scatter to file.
                     */
                    if (H5F_arr_write (fhyper_info->f, fhyper_info->xfer_parms,
				       fhyper_info->layout, fhyper_info->pline,
				       fhyper_info->fill, fhyper_info->efl,
				       hsize, hsize, zero, file_offset,
				       fhyper_info->src)<0) {
                        HRETURN_ERROR (H5E_DATASPACE, H5E_WRITEERROR, 0,
				       "write error");
                    }
                } /* end else */

                /* Advance the pointer in the buffer */
                fhyper_info->src = ((const uint8_t *)fhyper_info->src) +
				   region_size*fhyper_info->elmt_size;

                /* Increment the number of elements read */
                num_written+=region_size;

                /* Decrement the buffer left */
                fhyper_info->nelmts-=region_size;

                /* Set the next position to start at */
                if(region_size==(hsize_t)((regions[i].end-regions[i].start)+1))
                    fhyper_info->iter->hyp.pos[dim+1]=(-1);
                else
                    fhyper_info->iter->hyp.pos[dim+1] = regions[i].start +
							region_size;

                /* Decrement the iterator count */
                fhyper_info->iter->hyp.elmt_left-=region_size;
            } /* end for */
        } else { /* recurse on each region to next dimension down */

            /* Increment the dimension we are working with */
            dim++;

            /* Step through each region in this dimension */
            for(i=0; i<num_regions && fhyper_info->nelmts>0; i++) {
                /* Step through each location in each region */
                for(j=regions[i].start;
		    j<=regions[i].end && fhyper_info->nelmts>0;
		    j++) {

                    /*
		     * If we are moving to a new position in this dim, reset
		     * the next lower dim. location.
		     */
                    if(fhyper_info->iter->hyp.pos[dim]!=j)
                        fhyper_info->iter->hyp.pos[dim+1]=(-1);

                    /* Set the correct position we are working on */
                    fhyper_info->iter->hyp.pos[dim]=j;

                    /* Go get the regions in the next lower dimension */
                    num_written+=H5S_hyper_fwrite(dim, fhyper_info);
                } /* end for */
            } /* end for */
        } /* end else */

        /* Release the temporary buffer */
        H5TB_release_buf(reg_id);
    } /* end if */

#ifdef QAK
    printf("%s: check 2.0\n", FUNC);
#endif /* QAK */
    FUNC_LEAVE (num_written);
}   /* H5S_hyper_fwrite() */

/*-------------------------------------------------------------------------
 * Function:	H5S_hyper_fscat
 *
 * Purpose:	Scatters dataset elements from the type conversion buffer BUF
 *		to the file F where the data points are arranged according to
 *		the file data space FILE_SPACE and stored according to
 *		LAYOUT and EFL. Each element is ELMT_SIZE bytes.
 *		The caller is requesting that NELMTS elements are copied.
 *
 * Return:	Non-negative on success/Negative on failure
 *
 * Programmer:	Quincey Koziol
 *              Tuesday, June 16, 1998
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static herr_t
H5S_hyper_fscat (H5F_t *f, const struct H5O_layout_t *layout,
		 const struct H5O_pline_t *pline,
		 const struct H5O_fill_t *fill,
		 const struct H5O_efl_t *efl, size_t elmt_size,
		 const H5S_t *file_space, H5S_sel_iter_t *file_iter,
		 size_t nelmts, const H5D_xfer_t *xfer_parms,
		 const void *_buf)
{
    H5S_hyper_bound_t **lo_bounds;    /* Lower (closest to the origin) bound array for each dimension */
    H5S_hyper_bound_t **hi_bounds;    /* Upper (farthest from the origin) bound array for each dimension */
    H5S_hyper_fhyper_info_t fhyper_info;  /* Block of parameters to pass into recursive calls */
    intn	i;				/*counters		*/
    size_t  num_written;       /* number of elements read into buffer */

    FUNC_ENTER (H5S_hyper_fscat, 0);

    /* Check args */
    assert (f);
    assert (layout);
    assert (elmt_size>0);
    assert (file_space);
    assert (file_iter);
    assert (nelmts>0);
    assert (_buf);

#ifdef QAK
    printf("%s: check 1.0\n", FUNC);
#endif /* QAK */
    /* Allocate space for the low & high bound arrays */
    lo_bounds = H5MM_malloc(file_space->extent.u.simple.rank *
			    sizeof(H5S_hyper_bound_t *));
    hi_bounds = H5MM_malloc(file_space->extent.u.simple.rank *
			    sizeof(H5S_hyper_bound_t *));

    /*
     * Initialize to correct order to walk through arrays.  (When another
     * iteration order besides the default 'C' order is chosen, this is the
     * correct place to change the order of the array iterations)
     */
    for(i=0; i<file_space->extent.u.simple.rank; i++) {
        lo_bounds[i]=file_space->select.sel_info.hslab.hyper_lst->lo_bounds[i];
        hi_bounds[i]=file_space->select.sel_info.hslab.hyper_lst->hi_bounds[i];
    } /* end for */

    /* Initialize parameter block for recursive calls */
    fhyper_info.f=f;
    fhyper_info.layout=layout;
    fhyper_info.pline=pline;
    fhyper_info.fill=fill;
    fhyper_info.efl=efl;
    fhyper_info.elmt_size=elmt_size;
    fhyper_info.space=file_space;
    fhyper_info.iter=file_iter;
    fhyper_info.nelmts=nelmts;
    fhyper_info.xfer_parms=xfer_parms;
    fhyper_info.src=_buf;
    fhyper_info.dst=NULL;
    fhyper_info.lo_bounds=lo_bounds;
    fhyper_info.hi_bounds=hi_bounds;

    /* Recursively input the hyperslabs currently defined */
    /* starting with the slowest changing dimension */
    num_written=H5S_hyper_fwrite(-1,&fhyper_info);

    /* Release the memory we allocated */
    H5MM_xfree(lo_bounds);
    H5MM_xfree(hi_bounds);
    
#ifdef QAK
    printf("%s: check 2.0\n", FUNC);
#endif /* QAK */
    FUNC_LEAVE (num_written >0 ? SUCCEED : FAIL);
} /* H5S_hyper_fscat() */

/*-------------------------------------------------------------------------
 * Function:	H5S_hyper_mread
 *
 * Purpose:	Recursively gathers data points from memory using the
 *		parameters passed to H5S_hyper_mgath.
 *
 * Return:	Success:	Number of elements copied.
 *
 *		Failure:	0
 *
 * Programmer:	Quincey Koziol
 *              Tuesday, June 16, 1998
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static size_t
H5S_hyper_mread (intn dim, H5S_hyper_fhyper_info_t *fhyper_info)
{
    hsize_t	mem_size[H5O_LAYOUT_NDIMS];	/*size of memory buffer*/
    hssize_t	mem_offset[H5O_LAYOUT_NDIMS];	/*offset of slab in memory*/
    hsize_t	hsize[H5O_LAYOUT_NDIMS];	/*size of hyperslab	*/
    hsize_t region_size;                /* Size of lowest region */
    hid_t reg_id;               /* ID of temporary region buffer */
    H5S_hyper_region_t *regions;  /* Pointer to array of hyperslab nodes overlapped */
    size_t num_regions;         /* number of regions overlapped */
    size_t i;                   /* Counters */
    intn j;
    size_t num_read=0;          /* Number of elements read */

    FUNC_ENTER (H5S_hyper_mread, 0);

    assert(fhyper_info);

#ifdef QAK
    printf("%s: check 1.0, dim=%d\n",FUNC,dim);
#endif /* QAK */

    /* Get a sorted list (in the next dimension down) of the regions which */
    /*  overlap the current index in this dim */
    if((reg_id=H5S_hyper_get_regions(&num_regions,dim,
            fhyper_info->space->select.sel_info.hslab.hyper_lst->count,
            fhyper_info->lo_bounds, fhyper_info->hi_bounds,
            fhyper_info->iter->hyp.pos,fhyper_info->space->select.offset))>=0) {

        /* Get the pointer to the actual regions array */
        regions=H5TB_buf_ptr(reg_id);

        /* Check if this is the second to last dimension in dataset */
        /*  (Which means that we've got a list of the regions in the fastest */
        /*   changing dimension and should input those regions) */
#ifdef QAK
	printf("%s: check 2.0, rank=%d, num_regions=%d\n",
	       FUNC, (int)fhyper_info->space->extent.u.simple.rank,
	       (int)num_regions);
	for(i=0; i<num_regions; i++)
	    printf("%s: check 2.1, region #%d: start=%d, end=%d\n",
		   FUNC,i,(int)regions[i].start,(int)regions[i].end);
#endif /* QAK */

        if((dim+2)==fhyper_info->space->extent.u.simple.rank) {

            /* Set up hyperslab I/O parameters which apply to all regions */

            /* Set up the size of the memory space */
            HDmemcpy(mem_size, fhyper_info->space->extent.u.simple.size,
		     fhyper_info->space->extent.u.simple.rank*sizeof(hsize_t));
            mem_size[fhyper_info->space->extent.u.simple.rank]=fhyper_info->elmt_size;

            /* Copy the location of the region in the file */
            HDmemcpy(mem_offset, fhyper_info->iter->hyp.pos,
		     (fhyper_info->space->extent.u.simple.rank *
		      sizeof(hssize_t)));
            mem_offset[fhyper_info->space->extent.u.simple.rank]=0;

            /* Set the hyperslab size to copy */
            hsize[0]=1;
            H5V_array_fill(hsize, hsize, sizeof(hsize[0]),
			   fhyper_info->space->extent.u.simple.rank);
            hsize[fhyper_info->space->extent.u.simple.rank]=fhyper_info->elmt_size;

            /* perform I/O on data from regions */
            for(i=0; i<num_regions && fhyper_info->nelmts>0; i++) {
                region_size=MIN(fhyper_info->nelmts,
				(regions[i].end-regions[i].start)+1);
                hsize[fhyper_info->space->extent.u.simple.rank-1]=region_size;
                mem_offset[fhyper_info->space->extent.u.simple.rank-1]=regions[i].start;
#ifdef QAK
		printf("%s: check 2.1, i=%d, region_size=%d\n",
		       FUNC,(int)i,(int)region_size);
#endif /* QAK */

                /*
                 * Gather from memory.
                 */
                if (H5V_hyper_copy (fhyper_info->space->extent.u.simple.rank+1,
                        hsize, hsize, zero, fhyper_info->dst,
                        mem_size, mem_offset, fhyper_info->src)<0) {
                    HRETURN_ERROR (H5E_DATASPACE, H5E_READERROR, 0,
				   "unable to gather data from memory");
                }

                /* Advance the pointer in the buffer */
                fhyper_info->dst = ((uint8_t *)fhyper_info->dst) +
				   region_size*fhyper_info->elmt_size;

                /* Increment the number of elements read */
                num_read+=region_size;

                /* Decrement the buffer left */
                fhyper_info->nelmts-=region_size;

                /* Set the next position to start at */
                if(region_size==(hsize_t)((regions[i].end-regions[i].start)+1))
                    fhyper_info->iter->hyp.pos[dim+1]=(-1);
                else
                    fhyper_info->iter->hyp.pos[dim+1] =regions[i].start +
						       region_size;

                /* Decrement the iterator count */
                fhyper_info->iter->hyp.elmt_left-=region_size;
            } /* end for */
        } else { /* recurse on each region to next dimension down */
#ifdef QAK
	    printf("%s: check 3.0, num_regions=%d\n",FUNC,(int)num_regions);
#endif /* QAK */

            /* Increment the dimension we are working with */
            dim++;

            /* Step through each region in this dimension */
            for(i=0; i<num_regions && fhyper_info->nelmts>0; i++) {
                /* Step through each location in each region */
                for(j=regions[i].start;
		    j<=regions[i].end && fhyper_info->nelmts>0;
		    j++) {
#ifdef QAK
		    printf("%s: check 4.0, dim=%d, location=%d\n",FUNC,dim,j);
#endif /* QAK */

                    /*
		     * If we are moving to a new position in this dim, reset
		     * the next lower dim. location.
		     */
                    if(fhyper_info->iter->hyp.pos[dim]!=j)
                        fhyper_info->iter->hyp.pos[dim+1]=(-1);

                    /* Set the correct position we are working on */
                    fhyper_info->iter->hyp.pos[dim]=j;

                    /* Go get the regions in the next lower dimension */
                    num_read+=H5S_hyper_mread(dim, fhyper_info);
                } /* end for */
            } /* end for */
        } /* end else */

        /* Release the temporary buffer */
        H5TB_release_buf(reg_id);
    } /* end if */

    FUNC_LEAVE (num_read);
}   /* H5S_hyper_mread() */

/*-------------------------------------------------------------------------
 * Function:	H5S_hyper_mgath
 *
 * Purpose:	Gathers dataset elements from application memory BUF and
 *		copies them into the data type conversion buffer TCONV_BUF.
 *		Each element is ELMT_SIZE bytes and arranged in application
 *		memory according to MEM_SPACE.  
 *		The caller is requesting that at most NELMTS be gathered.
 *
 * Return:	Success:	Number of elements copied.
 *
 *		Failure:	0
 *
 * Programmer:	Quincey Koziol
 *              Tuesday, June 16, 1998
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static size_t
H5S_hyper_mgath (const void *_buf, size_t elmt_size,
		 const H5S_t *mem_space, H5S_sel_iter_t *mem_iter,
		 size_t nelmts, void *_tconv_buf/*out*/)
{
    H5S_hyper_bound_t **lo_bounds;    /* Lower (closest to the origin) bound array for each dimension */
    H5S_hyper_bound_t **hi_bounds;    /* Upper (farthest from the origin) bound array for each dimension */
    H5S_hyper_fhyper_info_t fhyper_info;  /* Block of parameters to pass into recursive calls */
    intn	i;
#ifdef QAK
    intn    j;            /* Counters		*/
#endif /* QAK */
    size_t  num_read;       /* number of elements read into buffer */

    FUNC_ENTER (H5S_hyper_mgath, 0);

#ifdef QAK
    printf("%s: check 1.0, elmt_size=%d, mem_space=%p\n",
	   FUNC,(int)elmt_size,mem_space);
    printf("%s: check 1.0, mem_iter=%p, nelmts=%d\n",FUNC,mem_iter,nelmts);
    printf("%s: check 1.0, _buf=%p, _tconv_buf=%p\n",FUNC,_buf,_tconv_buf);
#endif /* QAK */

    /* Check args */
    assert (elmt_size>0);
    assert (mem_space);
    assert (mem_iter);
    assert (nelmts>0);
    assert (_buf);
    assert (_tconv_buf);

#ifdef QAK
    printf("%s: check 2.0, mem_space->extent.u.simple.rank=%d\n",
	   FUNC, (int)mem_space->extent.u.simple.rank);
#endif /* QAK */

    /* Allocate space for the low & high bound arrays */
    lo_bounds = H5MM_malloc(mem_space->extent.u.simple.rank *
			    sizeof(H5S_hyper_bound_t *));
    hi_bounds = H5MM_malloc(mem_space->extent.u.simple.rank *
			    sizeof(H5S_hyper_bound_t *));

    /*
     * Initialize to correct order to walk through arrays.  (When another
     * iteration order besides the default 'C' order is chosen, this is the
     * correct place to change the order of the array iterations)
     */
#ifdef QAK
    printf("%s: check 3.0\n",FUNC);
#endif /* QAK */
    for(i=0; i<mem_space->extent.u.simple.rank; i++) {
        lo_bounds[i]=mem_space->select.sel_info.hslab.hyper_lst->lo_bounds[i];
        hi_bounds[i]=mem_space->select.sel_info.hslab.hyper_lst->hi_bounds[i];
#ifdef QAK
	printf("%s: check 3.1, lo[%d]=%p, hi[%d]=%p\n",
	       FUNC,i,lo_bounds[i],i,hi_bounds[i]);
        for(j=0; j<(int)mem_space->select.sel_info.hslab.hyper_lst->count; j++)
	    printf("%s: check 3.2, lo[%d][%d]=%d, hi[%d][%d]=%d\n",
		   FUNC, i, j, (int)lo_bounds[i][j].bound, i, j,
		   (int)hi_bounds[i][j].bound);
#endif /* QAK */
    } /* end for */

    /* Initialize parameter block for recursive calls */
    fhyper_info.elmt_size=elmt_size;
    fhyper_info.space=mem_space;
    fhyper_info.iter=mem_iter;
    fhyper_info.nelmts=nelmts;
    fhyper_info.src=_buf;
    fhyper_info.dst=_tconv_buf;
    fhyper_info.lo_bounds=lo_bounds;
    fhyper_info.hi_bounds=hi_bounds;

    /* Recursively input the hyperslabs currently defined */
    /* starting with the slowest changing dimension */
#ifdef QAK
    printf("%s: check 4.0\n",FUNC);
#endif /* QAK */
    num_read=H5S_hyper_mread(-1,&fhyper_info);
#ifdef QAK
    printf("%s: check 5.0, num_read=%d\n",FUNC,(int)num_read);
#endif /* QAK */

    /* Release the memory we allocated */
    H5MM_xfree(lo_bounds);
    H5MM_xfree(hi_bounds);

    FUNC_LEAVE (num_read);
}   /* H5S_hyper_mgath() */

/*-------------------------------------------------------------------------
 * Function:	H5S_hyper_mwrite
 *
 * Purpose:	Recursively scatters data points from memory using the parameters
 *      passed to H5S_hyper_mscat.
 *
 * Return:	Success:	Number of elements copied.
 *
 *		Failure:	0
 *
 * Programmer:	Quincey Koziol
 *              Tuesday, June 16, 1998
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static size_t
H5S_hyper_mwrite (intn dim, H5S_hyper_fhyper_info_t *fhyper_info)
{
    hsize_t	mem_size[H5O_LAYOUT_NDIMS];	/*size of memory buffer*/
    hssize_t	mem_offset[H5O_LAYOUT_NDIMS];	/*offset of slab in file*/
    hsize_t	hsize[H5O_LAYOUT_NDIMS];	/*size of hyperslab	*/
    hsize_t region_size;                /* Size of lowest region */
    hid_t reg_id;               /* ID of temporary region buffer */
    H5S_hyper_region_t *regions;  /* Pointer to array of hyperslab nodes overlapped */
    size_t num_regions;         /* number of regions overlapped */
    size_t i;                   /* Counters */
    intn j;
    size_t num_read=0;          /* Number of elements read */

    FUNC_ENTER (H5S_hyper_mwrite, 0);

    assert(fhyper_info);
#ifdef QAK
    printf("%s: check 1.0\n",FUNC);
#endif /* QAK */

    /* Get a sorted list (in the next dimension down) of the regions which */
    /*  overlap the current index in this dim */
    if((reg_id=H5S_hyper_get_regions(&num_regions,dim,
            fhyper_info->space->select.sel_info.hslab.hyper_lst->count,
            fhyper_info->lo_bounds, fhyper_info->hi_bounds,
            fhyper_info->iter->hyp.pos,fhyper_info->space->select.offset))>=0) {

        /* Get the pointer to the actual regions array */
        regions=H5TB_buf_ptr(reg_id);

#ifdef QAK
	printf("%s: check 2.0, rank=%d\n",
	       FUNC,(int)fhyper_info->space->extent.u.simple.rank);
	for(i=0; i<num_regions; i++)
	    printf("%s: check 2.1, region #%d: start=%d, end=%d\n",
		   FUNC,i,(int)regions[i].start,(int)regions[i].end);
#endif /* QAK */
        /* Check if this is the second to last dimension in dataset */
        /*  (Which means that we've got a list of the regions in the fastest */
        /*   changing dimension and should input those regions) */
        if((dim+2)==fhyper_info->space->extent.u.simple.rank) {

            /* Set up hyperslab I/O parameters which apply to all regions */

            /* Set up the size of the memory space */
            HDmemcpy(mem_size, fhyper_info->space->extent.u.simple.size,
		     fhyper_info->space->extent.u.simple.rank*sizeof(hsize_t));
            mem_size[fhyper_info->space->extent.u.simple.rank]=fhyper_info->elmt_size;

            /* Copy the location of the region in the file */
            HDmemcpy(mem_offset, fhyper_info->iter->hyp.pos,
		     (fhyper_info->space->extent.u.simple.rank*
		      sizeof(hssize_t)));
            mem_offset[fhyper_info->space->extent.u.simple.rank]=0;

            /* Set the hyperslab size to copy */
            hsize[0]=1;
            H5V_array_fill(hsize, hsize, sizeof(hsize[0]),
			   fhyper_info->space->extent.u.simple.rank);
            hsize[fhyper_info->space->extent.u.simple.rank]=fhyper_info->elmt_size;

#ifdef QAK
	    printf("%s: check 3.0\n",FUNC);
#endif /* QAK */
            /* perform I/O on data from regions */
            for(i=0; i<num_regions && fhyper_info->nelmts>0; i++) {
                region_size=MIN(fhyper_info->nelmts,
				(regions[i].end-regions[i].start)+1);
                hsize[fhyper_info->space->extent.u.simple.rank-1]=region_size;
                mem_offset[fhyper_info->space->extent.u.simple.rank-1]=regions[i].start;

                /*
                 * Gather from memory.
                 */
                if (H5V_hyper_copy (fhyper_info->space->extent.u.simple.rank+1,
				    hsize, mem_size, mem_offset,
				    fhyper_info->dst, hsize, zero,
				    fhyper_info->src)<0) {
                    HRETURN_ERROR (H5E_DATASPACE, H5E_READERROR, 0,
				   "unable to gather data from memory");
                }

                /* Advance the pointer in the buffer */
                fhyper_info->src = ((const uint8_t *)fhyper_info->src) +
				   region_size*fhyper_info->elmt_size;

                /* Increment the number of elements read */
                num_read+=region_size;

                /* Decrement the buffer left */
                fhyper_info->nelmts-=region_size;

                /* Set the next position to start at */
                if(region_size==(hsize_t)((regions[i].end-regions[i].start)+1))
                    fhyper_info->iter->hyp.pos[dim+1]=(-1);
                else
                    fhyper_info->iter->hyp.pos[dim+1] = regions[i].start +
							region_size;

                /* Decrement the iterator count */
                fhyper_info->iter->hyp.elmt_left-=region_size;
            } /* end for */
        } else { /* recurse on each region to next dimension down */

            /* Increment the dimension we are working with */
            dim++;

#ifdef QAK
	    printf("%s: check 6.0, num_regions=%d\n",FUNC,(int)num_regions);
#endif /* QAK */
            /* Step through each region in this dimension */
            for(i=0; i<num_regions && fhyper_info->nelmts>0; i++) {
                /* Step through each location in each region */
#ifdef QAK
		printf("%s: check 7.0, start[%d]=%d, end[%d]=%d, nelmts=%d\n",
		       FUNC, i, (int)regions[i].start, i,
		       (int)regions[i].end, (int)fhyper_info->nelmts);
#endif /* QAK */
                for(j=regions[i].start;
		    j<=regions[i].end && fhyper_info->nelmts>0;
		    j++) {

                    /*
		     * If we are moving to a new position in this dim, reset
		     * the next lower dim. location.
		     */
                    if(fhyper_info->iter->hyp.pos[dim]!=j)
                        fhyper_info->iter->hyp.pos[dim+1]=(-1);

                    /* Set the correct position we are working on */
                    fhyper_info->iter->hyp.pos[dim]=j;

                    /* Go get the regions in the next lower dimension */
                    num_read+=H5S_hyper_mwrite(dim, fhyper_info);
                } /* end for */
            } /* end for */
        } /* end else */

        /* Release the temporary buffer */
        H5TB_release_buf(reg_id);
    } /* end if */

    FUNC_LEAVE (num_read);
}   /* H5S_hyper_mwrite() */

/*-------------------------------------------------------------------------
 * Function:	H5S_hyper_mscat
 *
 * Purpose:	Scatters NELMTS data points from the type conversion buffer
 *		TCONV_BUF to the application buffer BUF.  Each element is
 *		ELMT_SIZE bytes and they are organized in application memory
 *		according to MEM_SPACE.
 *
 * Return:	Non-negative on success/Negative on failure
 *
 * Programmer:	Quincey Koziol
 *              Wednesday, June 17, 1998
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
static herr_t
H5S_hyper_mscat (const void *_tconv_buf, size_t elmt_size,
		 const H5S_t *mem_space, H5S_sel_iter_t *mem_iter,
		 size_t nelmts, void *_buf/*out*/)
{
    H5S_hyper_bound_t **lo_bounds;    /* Lower (closest to the origin) bound array for each dimension */
    H5S_hyper_bound_t **hi_bounds;    /* Upper (farthest from the origin) bound array for each dimension */
    H5S_hyper_fhyper_info_t fhyper_info;  /* Block of parameters to pass into recursive calls */
    intn	i;				/*counters		*/
    size_t  num_read;       /* number of elements read into buffer */

    FUNC_ENTER (H5S_hyper_mscat, 0);

    /* Check args */
    assert (elmt_size>0);
    assert (mem_space);
    assert (mem_iter);
    assert (nelmts>0);
    assert (_buf);
    assert (_tconv_buf);

    /* Allocate space for the low & high bound arrays */
    lo_bounds = H5MM_malloc(mem_space->extent.u.simple.rank *
			    sizeof(H5S_hyper_bound_t *));
    hi_bounds = H5MM_malloc(mem_space->extent.u.simple.rank *
			    sizeof(H5S_hyper_bound_t *));

    /*
     * Initialize to correct order to walk through arrays.  (When another
     * iteration order besides the default 'C' order is chosen, this is the
     * correct place to change the order of the array iterations)
     */
    for(i=0; i<mem_space->extent.u.simple.rank; i++) {
        lo_bounds[i]=mem_space->select.sel_info.hslab.hyper_lst->lo_bounds[i];
        hi_bounds[i]=mem_space->select.sel_info.hslab.hyper_lst->hi_bounds[i];
    } /* end for */

    /* Initialize parameter block for recursive calls */
    fhyper_info.elmt_size=elmt_size;
    fhyper_info.space=mem_space;
    fhyper_info.iter=mem_iter;
    fhyper_info.nelmts=nelmts;
    fhyper_info.src=_tconv_buf;
    fhyper_info.dst=_buf;
    fhyper_info.lo_bounds=lo_bounds;
    fhyper_info.hi_bounds=hi_bounds;

    /* Recursively input the hyperslabs currently defined */
    /* starting with the slowest changing dimension */
#ifdef QAK
    printf("%s: check 1.0\n",FUNC);
#endif /* QAK */
    num_read=H5S_hyper_mwrite(-1,&fhyper_info);
#ifdef QAK
    printf("%s: check 2.0\n",FUNC);
#endif /* QAK */

    /* Release the memory we allocated */
    H5MM_xfree(lo_bounds);
    H5MM_xfree(hi_bounds);

    FUNC_LEAVE (num_read>0 ? SUCCEED : FAIL);
}   /* H5S_hyper_mscat() */

/*--------------------------------------------------------------------------
 NAME
    H5S_hyper_bsearch
 PURPOSE
    Search for a boundary
 USAGE
    herr_t H5S_hyper_bsearch(key,barr,count)
        hssize_t size;              IN: Key we are searching for
        H5S_hyper_bount_t *barr;    IN: Pointer to the array of bounds
        size_t count;               IN: Number of elements in the bound array
 RETURNS
    The element number to insert in front of on success (the value in the 'count'
    parameter if the new bound should be added to end) or negative on failure.
 DESCRIPTION
    Finds the proper place to insert a boundary in a sorted boundary array.
    Uses a binary search algorithm for the actual searching.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
static intn
H5S_hyper_bsearch(hssize_t size, H5S_hyper_bound_t *barr, size_t count)
{
    size_t lo, mid, hi;       /* Indices for the search */
    intn ret_value=-1;      /* Return value index */

    FUNC_ENTER (H5S_hyper_bsearch, FAIL);

    assert(barr);
    assert(count>0);

    /* Check bounds first */
    if(size<barr[0].bound)
        ret_value=0;
    else if(size>barr[count-1].bound)
        ret_value=(intn)count;
    else {      /* must be in the middle somewhere, go get it */
        lo=0;
        hi=count-1;
        do {
            /* Calc. the mid-point */
            mid=(hi+lo)/2;

            /* check for bounds only seperated by one element */
            if((hi-lo)<=1) {
                ret_value=(intn)hi;
                break;
            } else {    /* Divide and conquer! */
                if(size>barr[mid].bound)
                    lo=mid;
                else
                    hi=mid;
            } /* end else */
        } while(lo!=hi);
    } /* end else */
    FUNC_LEAVE (ret_value);
}   /* H5S_hyper_bsearch() */

/*--------------------------------------------------------------------------
 NAME
    H5S_hyper_node_add
 PURPOSE
    Add a new node to a list of hyperslab nodes
 USAGE
    herr_t H5S_hyper_node_add(head, start, size)
        H5S_hyper_node_t *head;   IN: Pointer to head of hyperslab list
        intn endflag;             IN: "size" array actually contains "end" array
        intn rank;                IN: # of dimensions of the node
        const hssize_t *start;    IN: Offset of block
        const hsize_t *size;      IN: Size of block
 RETURNS
    Non-negative on success/Negative on failure
 DESCRIPTION
    Adds a new hyperslab node to a list of them.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
herr_t
H5S_hyper_node_add (H5S_hyper_node_t **head, intn endflag, intn rank, const hssize_t *start, const hsize_t *size)
{
    H5S_hyper_node_t *slab;     /* New hyperslab node to add */
    intn i;     /* Counters */
    herr_t ret_value=SUCCEED;

    FUNC_ENTER (H5S_hyper_node_add, FAIL);

    /* Check args */
    assert (head);
    assert (start);
    assert (size);

    /* Create new hyperslab node to insert */
    if((slab = H5MM_malloc(sizeof(H5S_hyper_node_t)))==NULL)
        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab node");
    if((slab->start = H5MM_malloc(sizeof(hsize_t)* rank))==NULL)
        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab start boundary");
    if((slab->end = H5MM_malloc(sizeof(hsize_t)* rank))==NULL)
        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab end boundary");

    /* Set boundary on new node */
    for(i=0; i<rank; i++) {
        slab->start[i]=start[i];
        if(endflag)
            slab->end[i]=size[i];
        else
            slab->end[i]=start[i]+size[i]-1;
    } /* end for */

    /* Prepend on list of hyperslabs for this selection */
    slab->next=*head;
    *head=slab;

done:
    FUNC_LEAVE (ret_value);
}   /* H5S_hyper_node_add() */

/*--------------------------------------------------------------------------
 NAME
    H5S_hyper_node_prepend
 PURPOSE
    Prepend an existing node to an existing list of hyperslab nodes
 USAGE
    herr_t H5S_hyper_node_prepend(head, node)
        H5S_hyper_node_t **head;  IN: Pointer to pointer to head of hyperslab list
        H5S_hyper_node_t *node;   IN: Pointer to node to prepend
 RETURNS
    Non-negative on success/Negative on failure
 DESCRIPTION
    Prepends an existing hyperslab node to a list of them.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
static herr_t
H5S_hyper_node_prepend (H5S_hyper_node_t **head, H5S_hyper_node_t *node)
{
    herr_t ret_value=SUCCEED;

    FUNC_ENTER (H5S_hyper_node_prepend, FAIL);

    /* Check args */
    assert (head);
    assert (node);

    /* Prepend on list of hyperslabs for this selection */
    node->next=*head;
    *head=node;

    FUNC_LEAVE (ret_value);
}   /* H5S_hyper_node_prepend() */

/*--------------------------------------------------------------------------
 NAME
    H5S_hyper_node_release
 PURPOSE
    Free the memory for a hyperslab node
 USAGE
    herr_t H5S_hyper_node_release(node)
        H5S_hyper_node_t *node;   IN: Pointer to node to free
 RETURNS
    Non-negative on success/Negative on failure
 DESCRIPTION
    Frees a hyperslab node.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
static herr_t
H5S_hyper_node_release (H5S_hyper_node_t *node)
{
    herr_t ret_value=SUCCEED;

    FUNC_ENTER (H5S_hyper_node_release, FAIL);

    /* Check args */
    assert (node);

    /* Free the hyperslab node */
    node->start = H5MM_xfree(node->start);
    node->end = H5MM_xfree(node->end);
    H5MM_xfree(node);

    FUNC_LEAVE (ret_value);
}   /* H5S_hyper_node_release() */

/*--------------------------------------------------------------------------
 NAME
    H5S_hyper_add
 PURPOSE
    Add a block to hyperslab selection
 USAGE
    herr_t H5S_hyper_add(space, start, size)
        H5S_t *space;       	  IN: Pointer to dataspace
        const hssize_t *start;    IN: Offset of block
        const hsize_t *end;       IN: Offset of end of block
 RETURNS
    Non-negative on success/Negative on failure
 DESCRIPTION
    Adds a block to an existing hyperslab selection.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
herr_t
H5S_hyper_add (H5S_t *space, const hssize_t *start, const hsize_t *end)
{
    H5S_hyper_node_t *slab;     /* New hyperslab node to insert */
    H5S_hyper_bound_t *tmp;     /* Temporary pointer to an hyperslab bound array */
    intn bound_loc;             /* Boundary location to insert hyperslab */
    size_t elem_count;          /* Number of elements in hyperslab selection */
    intn i;     /* Counters */
    herr_t ret_value=SUCCEED;
#ifdef QAK
    extern int qak_debug;
#endif /* QAK */

    FUNC_ENTER (H5S_hyper_add, FAIL);

    /* Check args */
    assert (space);
    assert (start);
    assert (end);

#ifdef QAK
    qak_debug=1;
#endif /* QAK */

#ifdef QAK
    printf("%s: check 1.0\n",FUNC);
#endif /* QAK */
    /* Create new hyperslab node to insert */
    if((slab = H5MM_malloc(sizeof(H5S_hyper_node_t)))==NULL)
        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab node");
    if((slab->start = H5MM_malloc(sizeof(hsize_t)*space->extent.u.simple.rank))==NULL)
        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab start boundary");
    if((slab->end = H5MM_malloc(sizeof(hsize_t)*space->extent.u.simple.rank))==NULL)
        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab end boundary");

#ifdef QAK
    printf("%s: check 2.0\n",FUNC);
#endif /* QAK */
    /* Set boundary on new node */
    for(i=0,elem_count=1; i<space->extent.u.simple.rank; i++) {
#ifdef QAK
	printf("%s: check 2.1, %d: start=%d, end=%d, elem_count=%d\n",
	       FUNC,(int)i,(int)start[i],(int)end[i],(int)elem_count);
#endif /* QAK */
        slab->start[i]=start[i];
        slab->end[i]=end[i];
        elem_count*=(end[i]-start[i])+1;
    } /* end for */

    /* Initialize caching parameters */
    slab->cinfo.cached=0;
    slab->cinfo.size=elem_count;
    slab->cinfo.left=0;
    slab->cinfo.block_id=(-1);
    slab->cinfo.block=slab->cinfo.pos=NULL;

#ifdef QAK
    printf("%s: check 3.0, lo_bounds=%p, hi_bounds=%p\n",
	   FUNC, space->select.sel_info.hslab.hyper_lst->lo_bounds,
	   space->select.sel_info.hslab.hyper_lst->hi_bounds);
#endif /* QAK */
    /* Increase size of boundary arrays for dataspace's selection */
    for(i=0; i<space->extent.u.simple.rank; i++) {
        tmp=space->select.sel_info.hslab.hyper_lst->lo_bounds[i];
#ifdef QAK
	printf("%s: check 3.1, i=%d, space->sel_info.count=%d, tmp=%p\n",FUNC,(int)i, space->select.sel_info.hslab.hyper_lst->count,tmp);
#endif /* QAK */
        if((space->select.sel_info.hslab.hyper_lst->lo_bounds[i]=H5MM_realloc(tmp,sizeof(H5S_hyper_bound_t)*(space->select.sel_info.hslab.hyper_lst->count+1)))==NULL) {
            space->select.sel_info.hslab.hyper_lst->lo_bounds[i]=tmp;
            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
                "can't allocate hyperslab lo boundary array");
        } /* end if */
#ifdef QAK
	printf("%s: check 3.2, i=%d\n",FUNC,(int)i);
#endif /* QAK */
        tmp=space->select.sel_info.hslab.hyper_lst->hi_bounds[i];
        if((space->select.sel_info.hslab.hyper_lst->hi_bounds[i]=H5MM_realloc(tmp,sizeof(H5S_hyper_bound_t)*(space->select.sel_info.hslab.hyper_lst->count+1)))==NULL) {
            space->select.sel_info.hslab.hyper_lst->hi_bounds[i]=tmp;
            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
                "can't allocate hyperslab hi boundary array");
        } /* end if */
    } /* end for */

#ifdef QAK
    printf("%s: check 4.0\n",FUNC);
    {
        intn j;
        
        for(i=0; i<space->extent.u.simple.rank; i++) {
            for(j=0; j<(int)space->select.sel_info.hslab.hyper_lst->count; j++) {
		printf("%s: lo_bound[%d][%d]=%d(%p), "
		       "hi_bound[%d][%d]=%d(%p)\n",FUNC,
        i,j,(int)space->select.sel_info.hslab.hyper_lst->lo_bounds[i][j].bound,
            space->select.sel_info.hslab.hyper_lst->lo_bounds[i][j].node,
        i,j,(int)space->select.sel_info.hslab.hyper_lst->hi_bounds[i][j].bound,
            space->select.sel_info.hslab.hyper_lst->hi_bounds[i][j].node);
            }
        }
    }
#endif /* QAK */
    /* Insert each boundary of the hyperslab into the sorted lists of bounds */
    for(i=0; i<space->extent.u.simple.rank; i++) {
        /* Check if this is the first hyperslab inserted */
        if(space->select.sel_info.hslab.hyper_lst->count==0) {
#ifdef QAK
	    printf("%s: check 4.1, start[%d]=%d, end[%d]=%d\n",
		   FUNC, i, (int)slab->start[i],i,(int)slab->end[i]);
	    printf("%s: check 4.1,.hslab.hyper_lst->count=%d\n",
		   FUNC,(int)space->select.sel_info.hslab.hyper_lst->count);
#endif /* QAK */
            space->select.sel_info.hslab.hyper_lst->lo_bounds[i][0].bound=slab->start[i];
            space->select.sel_info.hslab.hyper_lst->lo_bounds[i][0].node=slab;
            space->select.sel_info.hslab.hyper_lst->hi_bounds[i][0].bound=slab->end[i];
            space->select.sel_info.hslab.hyper_lst->hi_bounds[i][0].node=slab;
        } /* end if */
        else {
#ifdef QAK
	    printf("%s: check 4.3, start[%d]=%d, end[%d]=%d\n",
		   FUNC,i,(int)slab->start[i],i,(int)slab->end[i]);
	    printf("%s: check 4.3,.hslab.hyper_lst->count=%d\n",
		   FUNC,(int)space->select.sel_info.hslab.hyper_lst->count);
#endif /* QAK */
            /* Take care of the low boundary first */
            /* Find the location to insert in front of */
            if((bound_loc=H5S_hyper_bsearch(slab->start[i],space->select.sel_info.hslab.hyper_lst->lo_bounds[i],
                    space->select.sel_info.hslab.hyper_lst->count))<0)
                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
                    "can't find location to insert hyperslab boundary");

#ifdef QAK
	    printf("%s: check 4.5, bound_loc=%d\n",FUNC,(int)bound_loc);
#endif /* QAK */
            /* Check if we need to move boundary elements */
            if(bound_loc!=(intn)space->select.sel_info.hslab.hyper_lst->count) {
                HDmemmove(&space->select.sel_info.hslab.hyper_lst->lo_bounds[i][bound_loc+1],
                    &space->select.sel_info.hslab.hyper_lst->lo_bounds[i][bound_loc],
                    sizeof(H5S_hyper_bound_t)*(space->select.sel_info.hslab.hyper_lst->count-bound_loc));
            } /* end if */
            space->select.sel_info.hslab.hyper_lst->lo_bounds[i][bound_loc].bound=slab->start[i];
            space->select.sel_info.hslab.hyper_lst->lo_bounds[i][bound_loc].node=slab;

            /* Take care of the high boundary next */
            /* Find the location to insert in front of */
            if((bound_loc=H5S_hyper_bsearch(slab->end[i],space->select.sel_info.hslab.hyper_lst->hi_bounds[i],
                    space->select.sel_info.hslab.hyper_lst->count))<0)
                HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
                    "can't find location to insert hyperslab boundary");

            /* Check if we need to move boundary elements */
            if(bound_loc!=(intn)space->select.sel_info.hslab.hyper_lst->count) {
                HDmemmove(&space->select.sel_info.hslab.hyper_lst->hi_bounds[i][bound_loc+1],
                    &space->select.sel_info.hslab.hyper_lst->hi_bounds[i][bound_loc],
                    sizeof(H5S_hyper_bound_t)*(space->select.sel_info.hslab.hyper_lst->count-bound_loc));
            } /* end if */
            space->select.sel_info.hslab.hyper_lst->hi_bounds[i][bound_loc].bound=slab->end[i];
            space->select.sel_info.hslab.hyper_lst->hi_bounds[i][bound_loc].node=slab;
        } /* end else */
    } /* end for */

    /* Increment the number of bounds in the array */
    space->select.sel_info.hslab.hyper_lst->count++;
#ifdef QAK
    printf("%s: check 5.0, count=%d\n",FUNC,(int)space->select.sel_info.hslab.hyper_lst->count);
#endif /* QAK */
    
    /* Prepend on list of hyperslabs for this selection */
    slab->next=space->select.sel_info.hslab.hyper_lst->head;
    space->select.sel_info.hslab.hyper_lst->head=slab;

    /* Increment the number of elements in the hyperslab selection */
    space->select.num_elem+=elem_count;
#ifdef QAK
    printf("%s: check 6.0, elem_count=%d\n",FUNC,(int)elem_count);
    {
        intn j;
        
        for(i=0; i<space->extent.u.simple.rank; i++) {
            for(j=0; j<(int)space->select.sel_info.hslab.hyper_lst->count; j++) {
                printf("%s: lo_bound[%d][%d]=%d, hi_bound[%d][%d]=%d\n", FUNC,
                    i,j,(int)space->select.sel_info.hslab.hyper_lst->lo_bounds[i][j].bound,
                    i,j,(int)space->select.sel_info.hslab.hyper_lst->hi_bounds[i][j].bound);
            }
        }
    }
#endif /* QAK */

done:
    FUNC_LEAVE (ret_value);
}   /* H5S_hyper_add() */

/*--------------------------------------------------------------------------
 NAME
    H5S_hyper_clip
 PURPOSE
    Clip a list of nodes against the current selection
 USAGE
    herr_t H5S_hyper_clip(space, nodes, uniq, overlap)
        H5S_t *space;       	  IN: Pointer to dataspace
        H5S_hyper_node_t *nodes;  IN: Pointer to list of nodes
        H5S_hyper_node_t **uniq;  IN: Handle to list of non-overlapping nodes
        H5S_hyper_node_t **overlap;  IN: Handle to list of overlapping nodes
 RETURNS
    Non-negative on success/Negative on failure
 DESCRIPTION
    Clips a list of hyperslab nodes against the current hyperslab selection.
    The list of non-overlapping and overlapping nodes which are generated from
    this operation are returned in the 'uniq' and 'overlap' pointers.  If
    either of those lists are not needed, they may be set to NULL and the
    list will be released.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
    Clipping a multi-dimensional space against another multi-dimensional
    space generates at most 1 overlapping region and 2*<rank> non-overlapping
    regions, falling into the following categories in each dimension:
        Case 1 - A overlaps B on both sides:
            node            <----AAAAAAAA--->
                clipped against:
            existing        <-----BBBBB----->
                generates:
            overlapping     <-----CCCCC----->
            non-overlapping <----D---------->
            non-overlapping <----------EE--->

        Case 2 - A overlaps B on one side: (need to check both sides!)
            Case 2a:
                node            <------AAAAAA--->
                    clipped against:
                existing        <-----BBBBB----->
                    generates:
                overlapping     <------CCCC----->
                non-overlapping <----------EE--->
            Case 2b:
                node            <---AAAAA------->
                    clipped against:
                existing        <-----BBBBB----->
                    generates:
                overlapping     <-----CCC------->
                non-overlapping <---EE---------->

        Case 3 - A is entirely within B:
            node            <------AA------->
                clipped against:
            existing        <-----BBBBB----->
                generates:
            overlapping     <------CC------->

        Case 4 - A is entirely outside B: (doesn't matter which side)
            node            <-----------AAA->
                clipped against:
            existing        <-----BBBBB----->
                generates:
            non-overlapping <-----------AAA->

    This algorithm could be sped up by keeping track of the last (existing)
    region the new node was compared against when it was split and resume
    comparing against the region following that one when it's returned to
    later (for non-overlapping blocks).

    Another optimization is to build a n-tree (not certain about how many
    times each dimension should be cut, but at least once) for the dataspace
    and build a list of existing blocks which overlap each "n"-tant and only
    compare the new nodes against existing node in the region of the n-tree
    which the are located in.

 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
herr_t
H5S_hyper_clip (H5S_t *space, H5S_hyper_node_t *nodes, H5S_hyper_node_t **uniq,
        H5S_hyper_node_t **overlap)
{
    H5S_hyper_node_t *region,   /* Temp. hyperslab selection region pointer */
        *node,                  /* Temp. hyperslab node pointer */
        *next_node;             /* Pointer to next node in node list */
    hssize_t *start;            /* Temporary arrays of start & sizes (for splitting nodes) */
    hsize_t *end=NULL;          /* Temporary arrays of start & sizes (for splitting nodes) */
    intn rank;                  /* Cached copy of the rank of the dataspace */
    intn overlapped;            /* Flag for overlapping nodes */
    intn non_intersect;         /* Flag for non-intersecting nodes */
    intn i;     /* Counters */
    enum               /* Cases for edge overlaps */
        {OVERLAP_BOTH,OVERLAP_LOWER,OVERLAP_UPPER,WITHIN,NO_OVERLAP} clip_case;
    herr_t ret_value=SUCCEED;

    FUNC_ENTER (H5S_hyper_clip, FAIL);

    /* Check args */
    assert (space);
    assert (nodes);
    assert (uniq || overlap);

    /* Allocate space for the temporary starts & sizes */
    if((start = H5MM_malloc(sizeof(hssize_t)*space->extent.u.simple.rank))==NULL)
        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab start array");
    if((end = H5MM_malloc(sizeof(hsize_t)*space->extent.u.simple.rank))==NULL)
        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab size array");

    /* Set up local variables */
    rank=space->extent.u.simple.rank;

    /*
     * Cycle through all the hyperslab nodes, clipping them against the 
     * existing hyperslab selection.
     */
    node=nodes;
    while(node!=NULL) {
        /* Remove current node from head of list to evaulate it */
        next_node=node->next;   /* retain next node in list */
        if(nodes==node)
            nodes=nodes->next;  /* Move head of list */
        node->next=NULL;    /* just to be safe */

        overlapped=0;       /* Reset overlapped flag */
        region=space->select.sel_info.hslab.hyper_lst->head;
        while(region!=NULL && overlapped==0) {
            /* Check for intersection */
            for(i=0, non_intersect=0; i<rank && non_intersect==0; i++) {
                if(node->end[i]<region->start[i] || node->start[i]>region->end[i])
                    non_intersect=1;
            } /* end for */

            /* Only compare node with regions that actually intersect */
            if(non_intersect==0) {
                /* Compare the boundaries of the two objects in each dimension */
                for(i=0; i<rank && overlapped==0; i++) {
                    /* Find overlap case we are in */

                    /* True if case 1, 4 or 2b */
                    if(node->start[i]<region->start[i]) {
                        /* Test for case 4 */
                        /* NO_OVERLAP cases could be taken out, but are left in for clarity */
                        if(node->end[i]<region->start[i]) {
                            clip_case=NO_OVERLAP;
                            assert("invalid clipping case" && 0);
                        } /* end if */
                        else {
                            /* Test for case 2b */
                            if(node->end[i]<=region->end[i]) {
                                clip_case=OVERLAP_LOWER;
                            } /* end if */
                            /* Must be case 1 */
                            else {
                                clip_case=OVERLAP_BOTH;
                            } /* end else */
                        } /* end else */
                    } /* end if */
                    /* Case 2a, 3 or 4 (on the other side)*/
                    else {
                        /* Test for case 4 */
                        if(node->start[i]>region->end[i]) {
                            clip_case=NO_OVERLAP;
                            assert("invalid clipping case" && 0);
                        } /* end if */
                        /* Case 2a or 3 */
                        else {
                            /* Test for case 2a */
                            if(node->end[i]>region->end[i]) {
                                clip_case=OVERLAP_UPPER;
                            } /* end if */
                            /* Must be case 3 */
                            else {
                                clip_case=WITHIN;
                            } /* end else */
                        } /* end else */
                    } /* end else */
                    
                    if(clip_case!=WITHIN) {
                        /* Copy all the dimensions start & end points */
                        HDmemcpy(start,node->start,rank*sizeof(hssize_t));
                        HDmemcpy(end,node->end,rank*sizeof(hssize_t));
                    } /* end if */

                    /* Work on upper overlapping block */
                    if(clip_case==OVERLAP_BOTH || clip_case==OVERLAP_LOWER) {
                        /* Modify the end point in the current dimension of the overlap */
                        end[i]=region->start[i]-1;
                        /* Clip the existing non-overlapped portion off the current node */
                        node->start[i]=region->start[i];
                        /* Add the non-overlapping portion to the list of new nodes */
                        if(H5S_hyper_node_add(&nodes,1,rank,(const hssize_t *)start,(const hsize_t *)end)<0)
                            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslab");
                    } /* end if */

                    /* Work on lower overlapping block */
                    if(clip_case==OVERLAP_BOTH || clip_case==OVERLAP_UPPER) {
                        /* Modify the start & end point in the current dimension of the overlap */
                        start[i]=region->end[i]+1;
                        end[i]=node->end[i];
                        /* Clip the existing non-overlapped portion off the current node */
                        node->end[i]=region->end[i];
                        /* Add the non-overlapping portion to the list of new nodes */
                        if(H5S_hyper_node_add(&nodes,1,rank,(const hssize_t *)start,(const hsize_t *)end)<0)
                            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslab");
                    } /* end if */

                    /* Check if this is the last dimension */
                    /* Add the block to the "overlapped" list, if so */
                    /* Allow the algorithm to proceed to the next dimension otherwise */
                    if(i==(rank-1)) {   
                        if(overlap!=NULL) {
                            if(H5S_hyper_node_prepend(overlap,node)<0)
                                HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslab");
                        }
                        else {  /* Free the node if we aren't going to keep it */
                            H5S_hyper_node_release(node);
                        } /* end else */
                        overlapped=1;   /* stop the algorithm for this block */
                    } /* end if */
                } /* end for */
            } /* end if */

            /* Advance to next hyperslab region */
            region=region->next;
        } /* end while */

        /* Check whether we should add the node to the non-overlapping list */
        if(!overlapped) {
            if(uniq!=NULL) {
                if(H5S_hyper_node_prepend(uniq,node)<0)
                    HGOTO_ERROR(H5E_DATASPACE, H5E_CANTINSERT, FAIL, "can't insert hyperslab");
            }
            else {  /* Free the node if we aren't going to keep it */
                H5S_hyper_node_release(node);
            } /* end else */
        } /* end if */

        /* Advance to next hyperslab node */
        node=next_node;

        /* Check if we've added more nodes from splitting to the list */
        if(node==NULL && nodes!=NULL)
            node=nodes;
    } /* end while */

done:
    if(start!=NULL)
        H5MM_xfree(start);
    if(end!=NULL)
        H5MM_xfree(end);

    FUNC_LEAVE (ret_value);
}   /* H5S_hyper_clip() */

/*--------------------------------------------------------------------------
 NAME
    H5S_hyper_release
 PURPOSE
    Release hyperslab selection information for a dataspace
 USAGE
    herr_t H5S_hyper_release(space)
        H5S_t *space;       IN: Pointer to dataspace
 RETURNS
    Non-negative on success/Negative on failure
 DESCRIPTION
    Releases all hyperslab selection information for a dataspace
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
 EXAMPLES
 REVISION LOG
 * 	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 data space causes a core dump
 *	when closing some other data space.
--------------------------------------------------------------------------*/
herr_t
H5S_hyper_release (H5S_t *space)
{
    H5S_hyper_node_t *curr,*next;   /* Pointer to hyperslab nodes */
    intn i;     /* Counters */

    FUNC_ENTER (H5S_hyper_release, FAIL);

    /* Check args */
    assert (space && H5S_SEL_HYPERSLABS==space->select.type);
#ifdef QAK
    printf("%s: check 1.0\n",FUNC);
#endif /* QAK */

    /* Reset the number of points selected */
    space->select.num_elem=0;

    /* Release the per-dimension selection info */
    if(space->select.sel_info.hslab.diminfo!=NULL)
        H5MM_xfree(space->select.sel_info.hslab.diminfo);
    space->select.sel_info.hslab.diminfo = NULL;

    /* Release hi and lo boundary information */
    for(i=0; i<space->extent.u.simple.rank; i++) {
        H5MM_xfree(space->select.sel_info.hslab.hyper_lst->lo_bounds[i]);
        space->select.sel_info.hslab.hyper_lst->lo_bounds[i] = NULL;
        H5MM_xfree(space->select.sel_info.hslab.hyper_lst->hi_bounds[i]);
        space->select.sel_info.hslab.hyper_lst->hi_bounds[i] = NULL;
    } /* end for */
    H5MM_xfree(space->select.sel_info.hslab.hyper_lst->lo_bounds);
    space->select.sel_info.hslab.hyper_lst->lo_bounds = NULL;
    H5MM_xfree(space->select.sel_info.hslab.hyper_lst->hi_bounds);
    space->select.sel_info.hslab.hyper_lst->hi_bounds = NULL;

    /* Release list of selected regions */
    curr=space->select.sel_info.hslab.hyper_lst->head;
    while(curr!=NULL) {
        next=curr->next;
        H5S_hyper_node_release(curr);
        curr=next;
    } /* end while */

    /* Release hyperslab selection node itself */
    H5MM_xfree(space->select.sel_info.hslab.hyper_lst);
    space->select.sel_info.hslab.hyper_lst=NULL;

#ifdef QAK
    printf("%s: check 2.0\n",FUNC);
#endif /* QAK */

    FUNC_LEAVE (SUCCEED);
}   /* H5S_hyper_release() */

/*--------------------------------------------------------------------------
 NAME
    H5S_hyper_npoints
 PURPOSE
    Compute number of elements in current selection
 USAGE
    hsize_t H5S_hyper_npoints(space)
        H5S_t *space;       IN: Pointer to dataspace
 RETURNS
    The number of elements in selection on success, 0 on failure
 DESCRIPTION
    Compute number of elements in current selection.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
hsize_t
H5S_hyper_npoints (const H5S_t *space)
{
    FUNC_ENTER (H5S_hyper_npoints, 0);

    /* Check args */
    assert (space);

    FUNC_LEAVE (space->select.num_elem);
}   /* H5S_hyper_npoints() */

/*--------------------------------------------------------------------------
 NAME
    H5S_hyper_sel_iter_release
 PURPOSE
    Release hyperslab selection iterator information for a dataspace
 USAGE
    herr_t H5S_hyper_sel_iter_release(sel_iter)
        H5S_t *space;                   IN: Pointer to dataspace iterator is for
        H5S_sel_iter_t *sel_iter;       IN: Pointer to selection iterator
 RETURNS
    Non-negative on success/Negative on failure
 DESCRIPTION
    Releases all information for a dataspace hyperslab selection iterator
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
herr_t
H5S_hyper_sel_iter_release (H5S_sel_iter_t *sel_iter)
{
    FUNC_ENTER (H5S_hyper_sel_iter_release, FAIL);

    /* Check args */
    assert (sel_iter);

    if(sel_iter->hyp.pos!=NULL)
        H5MM_xfree(sel_iter->hyp.pos);

    FUNC_LEAVE (SUCCEED);
}   /* H5S_hyper_sel_iter_release() */

/*-------------------------------------------------------------------------
 * Function:	H5S_hyper_compare_bounds
 *
 * Purpose:	Compares two bounds for equality
 *
 * Return:	an integer less than, equal to, or greater than zero if the first
 *          region is considered to be respectively less than, equal to, or
 *          greater than the second
 *
 * Programmer:	Quincey Koziol
 *              Friday, July 17, 1998
 *
 * Modifications:
 *
 *-------------------------------------------------------------------------
 */
int
H5S_hyper_compare_bounds (const void *r1, const void *r2)
{
    if(((const H5S_hyper_bound_t *)r1)->bound<((const H5S_hyper_bound_t *)r2)->bound)
        return(-1);
    else
        if(((const H5S_hyper_bound_t *)r1)->bound>((const H5S_hyper_bound_t *)r2)->bound)
            return(1);
        else
            return(0);
}   /* end H5S_hyper_compare_bounds */

/*--------------------------------------------------------------------------
 NAME
    H5S_hyper_copy
 PURPOSE
    Copy a selection from one dataspace to another
 USAGE
    herr_t H5S_hyper_copy(dst, src)
        H5S_t *dst;  OUT: Pointer to the destination dataspace
        H5S_t *src;  IN: Pointer to the source dataspace
 RETURNS
    Non-negative on success/Negative on failure
 DESCRIPTION
    Copies all the hyperslab selection information from the source
    dataspace to the destination dataspace.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
herr_t
H5S_hyper_copy (H5S_t *dst, const H5S_t *src)
{
    H5S_hyper_list_t *new_hyper;    /* New hyperslab selection */
    H5S_hyper_node_t *curr, *new, *new_head;    /* Hyperslab information nodes */
    H5S_hyper_dim_t *new_diminfo=NULL;	/* New per-dimension info array[rank] */
    intn i;                     /* Counters */
    size_t u;                   /* Counters */
    herr_t ret_value=SUCCEED;   /* return value */

    FUNC_ENTER (H5S_hyper_copy, FAIL);

    assert(src);
    assert(dst);

#ifdef QAK
    printf("%s: check 3.0\n", FUNC);
#endif /* QAK */
    if(src->select.sel_info.hslab.diminfo!=NULL) {
        /* Create the per-dimension selection info */
        if((new_diminfo = H5MM_malloc(sizeof(H5S_hyper_dim_t)*src->extent.u.simple.rank))==NULL)
            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate per-dimension array");

        /* Copy the per-dimension selection info */
        for(i=0; i<src->extent.u.simple.rank; i++) {
            new_diminfo[i].start = src->select.sel_info.hslab.diminfo[i].start;
            new_diminfo[i].stride = src->select.sel_info.hslab.diminfo[i].stride;
            new_diminfo[i].count = src->select.sel_info.hslab.diminfo[i].count;
            new_diminfo[i].block = src->select.sel_info.hslab.diminfo[i].block;
        } /* end for */
    } /* end if */
    dst->select.sel_info.hslab.diminfo = new_diminfo;

    /* Create the new hyperslab information node */
    if((new_hyper = H5MM_malloc(sizeof(H5S_hyper_list_t)))==NULL)
        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
            "can't allocate point node");

    /* Copy the basic hyperslab selection information */
    *new_hyper=*(src->select.sel_info.hslab.hyper_lst);

    /* Attach the hyperslab information to the destination dataspace */
    dst->select.sel_info.hslab.hyper_lst=new_hyper;
    
#ifdef QAK
    printf("%s: check 4.0\n", FUNC);
#endif /* QAK */
    /* Allocate space for the low & high bound arrays */
    if((new_hyper->lo_bounds = H5MM_malloc(sizeof(H5S_hyper_bound_t *)*src->extent.u.simple.rank))==NULL)
        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
            "can't allocate point node");
    if((new_hyper->hi_bounds = H5MM_malloc(sizeof(H5S_hyper_bound_t *)*src->extent.u.simple.rank))==NULL)
        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
            "can't allocate point node");
    for(i=0; i<src->extent.u.simple.rank; i++) {
        if((new_hyper->lo_bounds[i] = H5MM_malloc(sizeof(H5S_hyper_bound_t)*src->select.sel_info.hslab.hyper_lst->count))==NULL)
            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
                "can't allocate point node");
        if((new_hyper->hi_bounds[i] = H5MM_malloc(sizeof(H5S_hyper_bound_t)*src->select.sel_info.hslab.hyper_lst->count))==NULL)
            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
                "can't allocate point node");
    } /* end for */

#ifdef QAK
    printf("%s: check 5.0\n", FUNC);
#endif /* QAK */
    /* Copy the hyperslab selection nodes, adding them to the lo & hi bound arrays also */
    curr=src->select.sel_info.hslab.hyper_lst->head;
    new_head=NULL;
    u=0;
    while(curr!=NULL) {
#ifdef QAK
    printf("%s: check 5.1\n", FUNC);
#endif /* QAK */
        /* Create each point */
        if((new = H5MM_malloc(sizeof(H5S_hyper_node_t)))==NULL)
            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
                "can't allocate point node");
        HDmemcpy(new,curr,sizeof(H5S_hyper_node_t));    /* copy caching information */
        if((new->start = H5MM_malloc(src->extent.u.simple.rank*sizeof(hssize_t)))==NULL)
            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
                "can't allocate coordinate information");
        if((new->end = H5MM_malloc(src->extent.u.simple.rank*sizeof(hssize_t)))==NULL)
            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL,
                "can't allocate coordinate information");
        HDmemcpy(new->start,curr->start,(src->extent.u.simple.rank*sizeof(hssize_t)));
        HDmemcpy(new->end,curr->end,(src->extent.u.simple.rank*sizeof(hssize_t)));
        new->next=NULL;

        /* Insert into low & high bound arrays */
        for(i=0; i<src->extent.u.simple.rank; i++) {
            new_hyper->lo_bounds[i][u].bound=new->start[i];
            new_hyper->lo_bounds[i][u].node=new;
            new_hyper->hi_bounds[i][u].bound=new->end[i];
            new_hyper->hi_bounds[i][u].node=new;
        } /* end for */
        u++;    /* Increment the location of the next node in the boundary arrays */

        /* Keep the order the same when copying */
        if(new_head==NULL)
            new_head=new_hyper->head=new;
        else {
            new_head->next=new;
            new_head=new;
        } /* end else */

        curr=curr->next;
    } /* end while */
#ifdef QAK
    printf("%s: check 6.0\n", FUNC);
#endif /* QAK */

    /* Sort the boundary arrays */
    for(i=0; i<src->extent.u.simple.rank; i++) {
        HDqsort(new_hyper->lo_bounds[i], new_hyper->count,
		sizeof(H5S_hyper_bound_t), H5S_hyper_compare_bounds);
        HDqsort(new_hyper->hi_bounds[i], new_hyper->count,
		sizeof(H5S_hyper_bound_t), H5S_hyper_compare_bounds);
    } /* end for */
#ifdef QAK
    printf("%s: check 7.0\n", FUNC);
#endif /* QAK */

done:
    FUNC_LEAVE (ret_value);
} /* end H5S_hyper_copy() */

/*--------------------------------------------------------------------------
 NAME
    H5S_hyper_select_valid
 PURPOSE
    Check whether the selection fits within the extent, with the current
    offset defined.
 USAGE
    htri_t H5S_hyper_select_valid(space);
        H5S_t *space;             IN: Dataspace pointer to query
 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
--------------------------------------------------------------------------*/
htri_t
H5S_hyper_select_valid (const H5S_t *space)
{
    H5S_hyper_node_t *curr;     /* Hyperslab information nodes */
    intn i;                     /* Counter */
    htri_t ret_value=TRUE;     /* return value */

    FUNC_ENTER (H5S_hyper_select_valid, FAIL);

    assert(space);

    /* Check each point to determine whether selection+offset is within extent */
    curr=space->select.sel_info.hslab.hyper_lst->head;
    while(curr!=NULL && ret_value==TRUE) {
        /* Check each dimension */
        for(i=0; i<space->extent.u.simple.rank; i++) {
            /* Check if an offset has been defined */
            /* Bounds check the selected point + offset against the extent */
            if(((curr->start[i]+space->select.offset[i])>(hssize_t)space->extent.u.simple.size[i])
                    || ((curr->start[i]+space->select.offset[i])<0)
                || ((curr->end[i]+space->select.offset[i])>(hssize_t)space->extent.u.simple.size[i])
                    || ((curr->end[i]+space->select.offset[i])<0)) {
                ret_value=FALSE;
                break;
            } /* end if */
        } /* end for */

        curr=curr->next;
    } /* end while */

    FUNC_LEAVE (ret_value);
} /* end H5S_hyper_select_valid() */

/*--------------------------------------------------------------------------
 NAME
    H5S_hyper_select_serial_size
 PURPOSE
    Determine the number of bytes needed to store the serialized hyperslab
        selection information.
 USAGE
    hssize_t H5S_hyper_select_serial_size(space)
        H5S_t *space;             IN: Dataspace pointer to query
 RETURNS
    The number of bytes required on success, negative on an error.
 DESCRIPTION
    Determines the number of bytes required to serialize the current hyperslab
    selection information for storage on disk.
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
hssize_t
H5S_hyper_select_serial_size (const H5S_t *space)
{
    H5S_hyper_node_t *curr;     /* Hyperslab information nodes */
    hssize_t ret_value=FAIL;    /* return value */

    FUNC_ENTER (H5S_hyper_select_serial_size, FAIL);

    assert(space);

    /* Basic number of bytes required to serialize point selection:
     *  <type (4 bytes)> + <version (4 bytes)> + <padding (4 bytes)> + 
     *      <length (4 bytes)> + <rank (4 bytes)> + <# of blocks (4 bytes)> = 24 bytes
     */
    ret_value=24;

    /* Spin through hyperslabs to total the space needed to store them */
    curr=space->select.sel_info.hslab.hyper_lst->head;
    while(curr!=NULL) {
        /* Add 8 bytes times the rank for each element selected */
        ret_value+=8*space->extent.u.simple.rank;
        curr=curr->next;
    } /* end while */

    FUNC_LEAVE (ret_value);
} /* end H5S_hyper_select_serial_size() */

/*--------------------------------------------------------------------------
 NAME
    H5S_hyper_select_serialize
 PURPOSE
    Serialize the current selection into a user-provided buffer.
 USAGE
    herr_t H5S_hyper_select_serialize(space, buf)
        H5S_t *space;           IN: Dataspace pointer of selection to serialize
        uint8 *buf;             OUT: Buffer to put serialized selection into
 RETURNS
    Non-negative on success/Negative on failure
 DESCRIPTION
    Serializes the current element selection into a buffer.  (Primarily for
    storing on disk).
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
herr_t
H5S_hyper_select_serialize (const H5S_t *space, uint8_t *buf)
{
    H5S_hyper_node_t *curr;     /* Hyperslab information nodes */
    uint8_t *lenp;          /* pointer to length location for later storage */
    uint32_t len=0;         /* number of bytes used */
    intn i;                 /* local counting variable */
    herr_t ret_value=FAIL;  /* return value */

    FUNC_ENTER (H5S_point_select_serialize, FAIL);

    assert(space);

    /* Store the preamble information */
    UINT32ENCODE(buf, (uint32_t)space->select.type);  /* Store the type of selection */
    UINT32ENCODE(buf, (uint32_t)1);  /* Store the version number */
    UINT32ENCODE(buf, (uint32_t)0);  /* Store the un-used padding */
    lenp=buf;           /* keep the pointer to the length location for later */
    buf+=4;             /* skip over space for length */

    /* Encode number of dimensions */
    UINT32ENCODE(buf, (uint32_t)space->extent.u.simple.rank);
    len+=4;

    /* Encode number of elements */
    UINT32ENCODE(buf, (uint32_t)space->select.sel_info.hslab.hyper_lst->count);
    len+=4;

    /* Encode each point in selection */
    curr=space->select.sel_info.hslab.hyper_lst->head;
    while(curr!=NULL) {
        /* Add 8 bytes times the rank for each element selected */
        len+=8*space->extent.u.simple.rank;

        /* Encode starting point */
        for(i=0; i<space->extent.u.simple.rank; i++)
            UINT32ENCODE(buf, (uint32_t)curr->start[i]);

        /* Encode ending point */
        for(i=0; i<space->extent.u.simple.rank; i++)
            UINT32ENCODE(buf, (uint32_t)curr->end[i]);

        curr=curr->next;
    } /* end while */

    /* Encode length */
    UINT32ENCODE(lenp, (uint32_t)len);  /* Store the length of the extra information */
    
    /* Set success */
    ret_value=SUCCEED;

    FUNC_LEAVE (ret_value);
}   /* H5S_hyper_select_serialize() */

/*--------------------------------------------------------------------------
 NAME
    H5S_hyper_select_deserialize
 PURPOSE
    Deserialize the current selection from a user-provided buffer.
 USAGE
    herr_t H5S_hyper_select_deserialize(space, buf)
        H5S_t *space;           IN/OUT: Dataspace pointer to place selection into
        uint8 *buf;             IN: Buffer to retrieve serialized selection from
 RETURNS
    Non-negative on success/Negative on failure
 DESCRIPTION
    Deserializes the current selection into a buffer.  (Primarily for retrieving
    from disk).
 GLOBAL VARIABLES
 COMMENTS, BUGS, ASSUMPTIONS
 EXAMPLES
 REVISION LOG
--------------------------------------------------------------------------*/
herr_t
H5S_hyper_select_deserialize (H5S_t *space, const uint8_t *buf)
{
    int32_t rank;           	/* rank of points */
    size_t num_elem=0;      	/* number of elements in selection */
    hssize_t *start=NULL;	/* hyperslab start information */
    hsize_t *count=NULL;    	/* hyperslab count information */
    hssize_t *tstart=NULL;	/* temporary hyperslab pointers */
    hsize_t *tcount=NULL;	/* temporary hyperslab pointers */
    uintn i,j;              	/* local counting variables */
    herr_t ret_value=FAIL;  	/* return value */

    FUNC_ENTER (H5S_hyper_select_deserialize, FAIL);

    /* Check args */
    assert(space);
    assert(buf);

    /* Deserialize slabs to select */
    buf+=16;    /* Skip over selection header */
    INT32DECODE(buf,rank);  /* decode the rank of the point selection */
    if(rank!=space->extent.u.simple.rank)
        HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "rank of pointer does not match dataspace");
    UINT32DECODE(buf,num_elem);  /* decode the number of points */

    /* Allocate space for the coordinates */
    if((start = H5MM_malloc(rank*sizeof(hssize_t)))==NULL)
        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab information");
    if((count = H5MM_malloc(rank*sizeof(hssize_t)))==NULL)
        HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "can't allocate hyperslab information");
    
    /* Retrieve the coordinates from the buffer */
    for(i=0; i<num_elem; i++) {
        /* Decode the starting points */
        for(tstart=start,j=0; j<(unsigned)rank; j++,tstart++)
            UINT32DECODE(buf, *tstart);

        /* Decode the ending points */
        for(tcount=count,j=0; j<(unsigned)rank; j++,tcount++)
            UINT32DECODE(buf, *tcount);

        /* Change the ending points into counts */
        for(tcount=count,tstart=start,j=0; j<(unsigned)rank; j++,tcount++)
            *tcount=(*tcount-*tstart)+1;

        /* Select or add the hyperslab to the current selection */
        if((ret_value=H5S_select_hyperslab(space,(i==0 ? H5S_SELECT_SET : H5S_SELECT_OR),start,NULL,count,NULL))<0) {
            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't change selection");
        } /* end if */
    } /* end for */

done:
    FUNC_LEAVE (ret_value);
}   /* H5S_hyper_select_deserialize() */

/*--------------------------------------------------------------------------
 NAME
    H5S_hyper_bounds
 PURPOSE
    Gets the bounding box containing the selection.
 USAGE
    herr_t H5S_hyper_bounds(space, hsize_t *start, hsize_t *end)
        H5S_t *space;           IN: Dataspace pointer of selection to query
        hsize_t *start;         OUT: Starting coordinate of bounding box
        hsize_t *end;           OUT: Opposite coordinate of bounding box
 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
--------------------------------------------------------------------------*/
herr_t
H5S_hyper_bounds(H5S_t *space, hsize_t *start, hsize_t *end)
{
    H5S_hyper_node_t *node;     /* Hyperslab node */
    intn rank;                  /* Dataspace rank */
    intn i;                     /* index variable */
    herr_t ret_value=SUCCEED;   /* return value */

    FUNC_ENTER (H5S_hyper_bounds, FAIL);

    assert(space);
    assert(start);
    assert(end);

    /* Get the dataspace extent rank */
    rank=space->extent.u.simple.rank;

    /* Iterate through the node, copying each hyperslab's information */
    node=space->select.sel_info.hslab.hyper_lst->head;
    while(node!=NULL) {
        for(i=0; i<rank; i++) {
            if(start[i]>(hsize_t)(node->start[i]+space->select.offset[i]))
                start[i]=node->start[i]+space->select.offset[i];
            if(end[i]<(hsize_t)(node->end[i]+space->select.offset[i]))
                end[i]=node->end[i]+space->select.offset[i];
        } /* end for */
        node=node->next;
      } /* end while */

    FUNC_LEAVE (ret_value);
}   /* H5Sget_hyper_bounds() */
generated by cgit v0.12 at 2024-09-29 10:30:04 (GMT)