[svn-r303] Changes since 19980228

----------------------

./html/Dataspaces.html
./html/Errors.html
./html/Files.html
./html/H5.api.html
./html/review1.html
./src/H5private.h
./src/H5public.h
./test/dsets.c
./test/dtypes.c
	Removed all the types like `int32' and `intn' into private
	headers since they violate the naming scheme and pollute
	application name space.  Besides, our test files only use them
	in a handful of places and it's probably useless to export
	them to the app.  The app is always written in terms of
	standard numeric types or its own numeric types and probably
	never in terms of HDF5 numeric types.  If it were, then the
	user would have to copy from their type to hdf5 type for
	almost every hdf5 API function call!  Same goes for return
	values.  I also removed SUCCEED/FAIL from the API since apps
	should be checking against zero anyway.

	       if (FAIL==(space=H5Screate_simple(...))) /*wrong*/
	       if ((space=H5Fcreate_simple(...)<0))     /*right*/


./src/H5.c
	Changed arguments of H5version() from `uintn' to `unsigned'.

./src/H5Tpublic.h
./src/H5T.c
	Changed return type of H5Tget_nmembers() from `intn' to `int'


./src/H5A.c
./src/H5Aprivate.h
./src/H5Apublic.h
	Changed `H5Asearch_func_t' to `H5A_search_func_t' and moved
	its definition from the public to the private header file.


./html/H5.format.html
	Documented changes made to the external file list (H5O_EFL)
	message.

./src/H5D.c
./src/H5Dprivate.h
./src/H5E.c
./src/H5Epublic.h
./src/H5O.c
./src/H5Oefl.c
./src/H5Oprivate.h
./src/H5P.c
./src/H5Ppublic.h
	Added partial support for external raw data files.  HDF5 can
	now describe external raw data files by listing the file
	names, offsets, and size for a dataset. However, we will
	restrict a dataset to be stored "contiguously" when the
	external file list is viewed as a single address space. The
	current implementation is unable to read/write to external
	files--that will come later this week as will documentation.
	For now, take a look at ./test/external.c, particularly the
	calls to H5Pset_external().

./test/Makefile.in
./test/external.c		[NEW]
./MANIFEST
	Added tests for external storage.  Note: the read test is
	supposed to fail at this point since reading external datasets
	is not implemented yet.  There is no write test.

./src/H5S.c
./src/H5Sprivate.h
./src/H5Ssimp.c
	Added H5S_get_npoints_max() to return the maximum possible
	number of data points in a data space.

	Added an extra argument to H5S_get_dims() which returns the
	maximum dims.

./src/H5F.c
./src/H5Fprivate.h
./src/H5Fpublic.h
./src/H5M.c			[DEPRICATED]
./src/H5Mpublic.h		[DEPRICATED]
	Changed `template' to `property list' in lots of places.

./src/H5Osdspace.c
	Removed an extra `\n' from a print statement.

./src/H5S_public.h
	Changed H5S_UNLIMITED to the maximum size_t value.

./test/extend.c
	"Extendable" is spelled "extendible".

./src/H5Farray.c
./src/H5V.c
./src/H5Vprivate.h
./test/hyperslab.c
	Strides are now type ssize_t instead of int.  These have
	nothing to do with the sample granularity arguments for
	hyperslabs, which are also called "strides" in the code.

./test/tstab.c
	Changed assumptions about default address and length sizes.

1 files changed, 695 insertions, 674 deletions

diff --git a/test/hyperslab.c b/test/hyperslab.c
index 2cc7660..0f9f431 100644
--- a/test/hyperslab.c
+++ b/test/hyperslab.c
@@ -1,15 +1,15 @@
 /*
  * Copyright (C) 1997 NCSA
- *                    All rights reserved.
+ *		      All rights reserved.
  *
- * Programmer:  Robb Matzke <matzke@llnl.gov>
- *              Friday, October 10, 1997
+ * Programmer:	Robb Matzke <matzke@llnl.gov>
+ *		Friday, October 10, 1997
  *
- * Purpose:     Hyperslab operations are rather complex, so this file
- *              attempts to test them extensively so we can be relatively
- *              sure they really work.  We only test 1d, 2d, and 3d cases
- *              because testing general dimensionalities would require us to
- *              rewrite much of the hyperslab stuff.
+ * Purpose:	Hyperslab operations are rather complex, so this file
+ *		attempts to test them extensively so we can be relatively
+ *		sure they really work.	We only test 1d, 2d, and 3d cases
+ *		because testing general dimensionalities would require us to
+ *		rewrite much of the hyperslab stuff.
  */
 #include <H5private.h>
 #include <H5MMprivate.h>
@@ -19,24 +19,24 @@
 #undef __FUNCTION__
 #define __FUNCTION__ ""
 #endif
-#define AT() printf ("   at %s:%d in %s()\n",__FILE__,__LINE__,__FUNCTION__);
+#define AT() printf ("	 at %s:%d in %s()\n",__FILE__,__LINE__,__FUNCTION__);
 
-#define TEST_SMALL      0x0001
-#define TEST_MEDIUM     0x0002
+#define TEST_SMALL	0x0001
+#define TEST_MEDIUM	0x0002
 
-#define VARIABLE_SRC    0
-#define VARIABLE_DST    1
-#define VARIABLE_BOTH   2
+#define VARIABLE_SRC	0
+#define VARIABLE_DST	1
+#define VARIABLE_BOTH	2
 
 /*-------------------------------------------------------------------------
- * Function:    init_full
+ * Function:	init_full
  *
- * Purpose:     Initialize full array.
+ * Purpose:	Initialize full array.
  *
- * Return:      void
+ * Return:	void
  *
- * Programmer:  Robb Matzke
- *              Friday, October 10, 1997
+ * Programmer:	Robb Matzke
+ *		Friday, October 10, 1997
  *
  * Modifications:
  *
@@ -45,30 +45,30 @@
 static uintn
 init_full(uint8 *array, size_t nx, size_t ny, size_t nz)
 {
-    int                     i, j, k;
-    uint8                   acc = 128;
-    uintn                   total = 0;
+    int			    i, j, k;
+    uint8		    acc = 128;
+    uintn		    total = 0;
 
     for (i = 0; i < nx; i++) {
-        for (j = 0; j < ny; j++) {
-            for (k = 0; k < nz; k++) {
-                total += acc;
-                *array++ = acc++;
-            }
-        }
+	for (j = 0; j < ny; j++) {
+	    for (k = 0; k < nz; k++) {
+		total += acc;
+		*array++ = acc++;
+	    }
+	}
     }
     return total;
 }
 
 /*-------------------------------------------------------------------------
- * Function:    print_array
+ * Function:	print_array
  *
- * Purpose:     Prints the values in an array
+ * Purpose:	Prints the values in an array
  *
- * Return:      void
+ * Return:	void
  *
- * Programmer:  Robb Matzke
- *              Friday, October 10, 1997
+ * Programmer:	Robb Matzke
+ *		Friday, October 10, 1997
  *
  * Modifications:
  *
@@ -77,39 +77,39 @@ init_full(uint8 *array, size_t nx, size_t ny, size_t nz)
 static void
 print_array(uint8 *array, size_t nx, size_t ny, size_t nz)
 {
-    int                     i, j, k;
+    int			    i, j, k;
 
     for (i = 0; i < nx; i++) {
-        if (nz > 1) {
-            printf("i=%d:\n", i);
-        } else {
-            printf("%03d:", i);
-        }
-
-        for (j = 0; j < ny; j++) {
-            if (nz > 1)
-                printf("%03d:", j);
-            for (k = 0; k < nz; k++) {
-                printf(" %3d", *array++);
-            }
-            if (nz > 1)
-                printf("\n");
-        }
-        printf("\n");
+	if (nz > 1) {
+	    printf("i=%d:\n", i);
+	} else {
+	    printf("%03d:", i);
+	}
+
+	for (j = 0; j < ny; j++) {
+	    if (nz > 1)
+		printf("%03d:", j);
+	    for (k = 0; k < nz; k++) {
+		printf(" %3d", *array++);
+	    }
+	    if (nz > 1)
+		printf("\n");
+	}
+	printf("\n");
     }
 }
 
 /*-------------------------------------------------------------------------
- * Function:    print_ref
+ * Function:	print_ref
  *
- * Purpose:     Prints the reference value
+ * Purpose:	Prints the reference value
  *
- * Return:      Success:        0
+ * Return:	Success:	0
  *
- *              Failure:        
+ *		Failure:	
  *
- * Programmer:  Robb Matzke
- *              Friday, October 10, 1997
+ * Programmer:	Robb Matzke
+ *		Friday, October 10, 1997
  *
  * Modifications:
  *
@@ -118,7 +118,7 @@ print_array(uint8 *array, size_t nx, size_t ny, size_t nz)
 static void
 print_ref(size_t nx, size_t ny, size_t nz)
 {
-    uint8                  *array;
+    uint8		   *array;
 
     array = H5MM_xcalloc(nx * ny * nz, sizeof(uint8));
 
@@ -128,16 +128,16 @@ print_ref(size_t nx, size_t ny, size_t nz)
 }
 
 /*-------------------------------------------------------------------------
- * Function:    test_fill
+ * Function:	test_fill
  *
- * Purpose:     Tests the H5V_hyper_fill() function.
+ * Purpose:	Tests the H5V_hyper_fill() function.
  *
- * Return:      Success:        SUCCEED
+ * Return:	Success:	SUCCEED
  *
- *              Failure:        FAIL
+ *		Failure:	FAIL
  *
- * Programmer:  Robb Matzke
- *              Saturday, October 11, 1997
+ * Programmer:	Robb Matzke
+ *		Saturday, October 11, 1997
  *
  * Modifications:
  *
@@ -145,40 +145,40 @@ print_ref(size_t nx, size_t ny, size_t nz)
  */
 static herr_t
 test_fill(size_t nx, size_t ny, size_t nz,
-          size_t di, size_t dj, size_t dk,
-          size_t ddx, size_t ddy, size_t ddz)
+	  size_t di, size_t dj, size_t dk,
+	  size_t ddx, size_t ddy, size_t ddz)
 {
-    uint8               *dst = NULL;         /*destination array             */
-    size_t              hs_size[3];         /*hyperslab size                */
-    size_t              dst_size[3];        /*destination total size        */
-    size_t              dst_offset[3];      /*offset of hyperslab in dest   */
-    uintn               ref_value;  /*reference value               */
-    uintn               acc;        /*accumulator                   */
-    int                 i, j, k, dx, dy, dz;       /*counters              */
-    size_t		u, v, w;
-    int                 ndims;      /*hyperslab dimensionality      */
-    char                dim[64], s[256];    /*temp string                   */
-    uintn               fill_value;         /*fill value                    */
+    uint8	*dst = NULL;		/*destination array		*/
+    size_t	hs_size[3];	    	/*hyperslab size		*/
+    size_t	dst_size[3];	    	/*destination total size	*/
+    size_t	dst_offset[3];	    	/*offset of hyperslab in dest   */
+    uintn	ref_value;  		/*reference value		*/
+    uintn	acc;	    		/*accumulator		    	*/
+    int		i, j, k, dx, dy, dz;	/*counters		   	*/
+    size_t	u, v, w;
+    int		ndims;			/*hyperslab dimensionality	*/
+    char	dim[64], s[256];    	/*temp string		    	*/
+    uintn	fill_value;	    	/*fill value		    	*/
 
     /*
      * Dimensionality.
      */
     if (0 == nz) {
-        if (0 == ny) {
-            ndims = 1;
-            ny = nz = 1;
-            sprintf(dim, "%lu", (unsigned long) nx);
-        } else {
-            ndims = 2;
-            nz = 1;
-            sprintf(dim, "%lux%lu", (unsigned long) nx, (unsigned long) ny);
-        }
+	if (0 == ny) {
+	    ndims = 1;
+	    ny = nz = 1;
+	    sprintf(dim, "%lu", (unsigned long) nx);
+	} else {
+	    ndims = 2;
+	    nz = 1;
+	    sprintf(dim, "%lux%lu", (unsigned long) nx, (unsigned long) ny);
+	}
     } else {
-        ndims = 3;
-        sprintf(dim, "%lux%lux%lu",
-                (unsigned long) nx, (unsigned long) ny, (unsigned long) nz);
+	ndims = 3;
+	sprintf(dim, "%lux%lux%lu",
+		(unsigned long) nx, (unsigned long) ny, (unsigned long) nz);
     }
-    sprintf(s, "Testing hyperslab fill %-11s variable hyperslab  ", dim);
+    sprintf(s, "Testing hyperslab fill %-11s variable hyperslab", dim);
     printf("%-70s", s);
     fflush(stdout);
 
@@ -187,79 +187,87 @@ test_fill(size_t nx, size_t ny, size_t nz,
     init_full(dst, nx, ny, nz);
 
     for (i = 0; i < nx; i += di) {
-        for (j = 0; j < ny; j += dj) {
-            for (k = 0; k < nz; k += dk) {
-                for (dx = 1; dx <= nx - i; dx += ddx) {
-                    for (dy = 1; dy <= ny - j; dy += ddy) {
-                        for (dz = 1; dz <= nz - k; dz += ddz) {
-
-                            /* Describe the hyperslab */
-                            dst_size[0] = nx;
-                            dst_size[1] = ny;
-                            dst_size[2] = nz;
-                            dst_offset[0] = i;
-                            dst_offset[1] = j;
-                            dst_offset[2] = k;
-                            hs_size[0] = dx;
-                            hs_size[1] = dy;
-                            hs_size[2] = dz;
-
-                            for (fill_value = 0; fill_value < 256; fill_value += 64) {
-                                /*
-                                 * Initialize the full array, then subtract the
-                                 * original * fill values and add the new ones.
-                                 */
-                                ref_value = init_full(dst, nx, ny, nz);
-                                for (u = dst_offset[0]; u < dst_offset[0] + dx; u++) {
-                                    for (v = dst_offset[1]; v < dst_offset[1] + dy; v++) {
-                                        for (w = dst_offset[2]; w < dst_offset[2] + dz; w++) {
-                                            ref_value -= dst[u * ny * nz + v * nz + w];
-                                        }
-                                    }
-                                }
-                                ref_value += fill_value * dx * dy * dz;
-
-                                /* Fill the hyperslab with some value */
-                                H5V_hyper_fill(ndims, hs_size, dst_size, dst_offset,
-                                               dst, fill_value);
-
-                                /*
-                                 * Sum the array and compare it to the reference
-                                 * value.
-                                 */
-                                acc = 0;
-                                for (u = 0; u < nx; u++) {
-                                    for (v = 0; v < ny; v++) {
-                                        for (w = 0; w < nz; w++) {
-                                            acc += dst[u * ny * nz + v * nz + w];
-                                        }
-                                    }
-                                }
-
-                                if (acc != ref_value) {
-                                    puts("*FAILED*");
-                                    if (!isatty(1)) {
-                                        /*
-                                         * Print debugging info unless output is going
-                                         * directly to a terminal.
-                                         */
-                                        AT();
-                                        printf("   acc != ref_value\n");
-                                        printf("   i=%d, j=%d, k=%d, "
-                                           "dx=%d, dy=%d, dz=%d, fill=%d\n",
-                                           i, j, k, dx, dy, dz, fill_value);
-                                        print_ref(nx, ny, nz);
-                                        printf("\n   Result is:\n");
-                                        print_array(dst, nx, ny, nz);
-                                    }
-                                    goto error;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
+	for (j = 0; j < ny; j += dj) {
+	    for (k = 0; k < nz; k += dk) {
+		for (dx = 1; dx <= nx - i; dx += ddx) {
+		    for (dy = 1; dy <= ny - j; dy += ddy) {
+			for (dz = 1; dz <= nz - k; dz += ddz) {
+
+			    /* Describe the hyperslab */
+			    dst_size[0] = nx;
+			    dst_size[1] = ny;
+			    dst_size[2] = nz;
+			    dst_offset[0] = i;
+			    dst_offset[1] = j;
+			    dst_offset[2] = k;
+			    hs_size[0] = dx;
+			    hs_size[1] = dy;
+			    hs_size[2] = dz;
+
+			    for (fill_value=0;
+				 fill_value<256;
+				 fill_value+=64) {
+				/*
+				 * Initialize the full array, then subtract the
+				 * original * fill values and add the new ones.
+				 */
+				ref_value = init_full(dst, nx, ny, nz);
+				for (u=dst_offset[0];
+				     u<dst_offset[0]+dx;
+				     u++) {
+				    for (v = dst_offset[1];
+					 v < dst_offset[1] + dy;
+					 v++) {
+					for (w = dst_offset[2];
+					     w < dst_offset[2] + dz;
+					     w++) {
+					    ref_value -= dst[u*ny*nz+v*nz+w];
+					}
+				    }
+				}
+				ref_value += fill_value * dx * dy * dz;
+
+				/* Fill the hyperslab with some value */
+				H5V_hyper_fill(ndims, hs_size, dst_size,
+					       dst_offset, dst, fill_value);
+
+				/*
+				 * Sum the array and compare it to the
+				 * reference value.
+				 */
+				acc = 0;
+				for (u = 0; u < nx; u++) {
+				    for (v = 0; v < ny; v++) {
+					for (w = 0; w < nz; w++) {
+					    acc += dst[u*ny*nz + v*nz + w];
+					}
+				    }
+				}
+
+				if (acc != ref_value) {
+				    puts("*FAILED*");
+				    if (!isatty(1)) {
+					/*
+					 * Print debugging info unless output
+					 * is going directly to a terminal.
+					 */
+					AT();
+					printf("   acc != ref_value\n");
+					printf("   i=%d, j=%d, k=%d, "
+					   "dx=%d, dy=%d, dz=%d, fill=%d\n",
+					   i, j, k, dx, dy, dz, fill_value);
+					print_ref(nx, ny, nz);
+					printf("\n   Result is:\n");
+					print_array(dst, nx, ny, nz);
+				    }
+				    goto error;
+				}
+			    }
+			}
+		    }
+		}
+	    }
+	}
     }
     puts(" PASSED");
     H5MM_xfree(dst);
@@ -271,28 +279,28 @@ test_fill(size_t nx, size_t ny, size_t nz,
 }
 
 /*-------------------------------------------------------------------------
- * Function:    test_copy
+ * Function:	test_copy
  *
- * Purpose:     Tests H5V_hyper_copy().
+ * Purpose:	Tests H5V_hyper_copy().
  *
- *              The NX, NY, and NZ arguments are the size for the source and
- *              destination arrays.  You map pass zero for NZ or for NY and
- *              NZ to test the 2-d and 1-d cases respectively.
+ *		The NX, NY, and NZ arguments are the size for the source and
+ *		destination arrays.  You map pass zero for NZ or for NY and
+ *		NZ to test the 2-d and 1-d cases respectively.
  *
- *              A hyperslab is copied from/to (depending on MODE) various
- *              places in SRC and DST beginning at 0,0,0 and increasing
- *              location by DI,DJ,DK in the x, y, and z directions.
+ *		A hyperslab is copied from/to (depending on MODE) various
+ *		places in SRC and DST beginning at 0,0,0 and increasing
+ *		location by DI,DJ,DK in the x, y, and z directions.
  *
- *              For each hyperslab location, various sizes of hyperslabs are
- *              tried beginning with 1x1x1 and increasing the size in each
- *              dimension by DDX,DDY,DDZ.
+ *		For each hyperslab location, various sizes of hyperslabs are
+ *		tried beginning with 1x1x1 and increasing the size in each
+ *		dimension by DDX,DDY,DDZ.
  *
- * Return:      Success:        SUCCEED
+ * Return:	Success:	SUCCEED
  *
- *              Failure:        FAIL
+ *		Failure:	FAIL
  *
- * Programmer:  Robb Matzke
- *              Friday, October 10, 1997
+ * Programmer:	Robb Matzke
+ *		Friday, October 10, 1997
  *
  * Modifications:
  *
@@ -300,69 +308,69 @@ test_fill(size_t nx, size_t ny, size_t nz,
  */
 static herr_t
 test_copy(int mode,
-          size_t nx, size_t ny, size_t nz,
-          size_t di, size_t dj, size_t dk,
-          size_t ddx, size_t ddy, size_t ddz)
+	  size_t nx, size_t ny, size_t nz,
+	  size_t di, size_t dj, size_t dk,
+	  size_t ddx, size_t ddy, size_t ddz)
 {
-    uint8                  *src = NULL;         /*source array                  */
-    uint8                  *dst = NULL;         /*destination array             */
-    size_t                  hs_size[3];         /*hyperslab size                */
-    size_t                  dst_size[3];        /*destination total size        */
-    size_t                  src_size[3];        /*source total size             */
-    size_t                  dst_offset[3];      /*offset of hyperslab in dest   */
-    size_t                  src_offset[3];      /*offset of hyperslab in source */
-    uintn                   ref_value;  /*reference value               */
-    uintn                   acc;        /*accumulator                   */
-    int                     i, j, k, dx, dy, dz;       /*counters              */
+    uint8	*src = NULL;		/*source array			*/
+    uint8	*dst = NULL;		/*destination array		*/
+    size_t	hs_size[3];		/*hyperslab size		*/
+    size_t	dst_size[3];		/*destination total size	*/
+    size_t	src_size[3];		/*source total size		*/
+    size_t	dst_offset[3];		/*offset of hyperslab in dest	*/
+    size_t	src_offset[3];		/*offset of hyperslab in source */
+    uintn	ref_value;		/*reference value		*/
+    uintn	acc;			/*accumulator			*/
+    int		i, j, k, dx, dy, dz;	/*counters		     	*/
     size_t	u, v, w;
-    int                     ndims;      /*hyperslab dimensionality      */
-    char                    dim[64], s[256];    /*temp string                   */
-    const char             *sub;
+    int		ndims;			/*hyperslab dimensionality	*/
+    char	dim[64], s[256];	/*temp string			*/
+    const char	*sub;
 
     /*
      * Dimensionality.
      */
     if (0 == nz) {
-        if (0 == ny) {
-            ndims = 1;
-            ny = nz = 1;
-            sprintf(dim, "%lu", (unsigned long) nx);
-        } else {
-            ndims = 2;
-            nz = 1;
-            sprintf(dim, "%lux%lu", (unsigned long) nx, (unsigned long) ny);
-        }
+	if (0 == ny) {
+	    ndims = 1;
+	    ny = nz = 1;
+	    sprintf(dim, "%lu", (unsigned long) nx);
+	} else {
+	    ndims = 2;
+	    nz = 1;
+	    sprintf(dim, "%lux%lu", (unsigned long) nx, (unsigned long) ny);
+	}
     } else {
-        ndims = 3;
-        sprintf(dim, "%lux%lux%lu",
-                (unsigned long) nx, (unsigned long) ny, (unsigned long) nz);
+	ndims = 3;
+	sprintf(dim, "%lux%lux%lu",
+		(unsigned long) nx, (unsigned long) ny, (unsigned long) nz);
     }
 
     switch (mode) {
     case VARIABLE_SRC:
-        /*
-         * The hyperslab "travels" through the source array but the
-         * destination hyperslab is always at the origin of the destination
-         * array.
-         */
-        sub = "variable source";
-        break;
+	/*
+	 * The hyperslab "travels" through the source array but the
+	 * destination hyperslab is always at the origin of the destination
+	 * array.
+	 */
+	sub = "variable source";
+	break;
     case VARIABLE_DST:
-        /*
-         * We always read a hyperslab from the origin of the source and copy it
-         * to a hyperslab at various locations in the destination.
-         */
-        sub = "variable destination";
-        break;
+	/*
+	 * We always read a hyperslab from the origin of the source and copy it
+	 * to a hyperslab at various locations in the destination.
+	 */
+	sub = "variable destination";
+	break;
     case VARIABLE_BOTH:
-        /*
-         * We read the hyperslab from various locations in the source and copy
-         * it to the same location in the destination.
-         */
-        sub = "sync source & dest  ";
-        break;
+	/*
+	 * We read the hyperslab from various locations in the source and copy
+	 * it to the same location in the destination.
+	 */
+	sub = "sync source & dest  ";
+	break;
     default:
-        abort();
+	abort();
     }
 
     sprintf(s, "Testing hyperslab copy %-11s %s", dim, sub);
@@ -377,151 +385,159 @@ test_copy(int mode,
     init_full(src, nx, ny, nz);
 
     for (i = 0; i < nx; i += di) {
-        for (j = 0; j < ny; j += dj) {
-            for (k = 0; k < nz; k += dk) {
-                for (dx = 1; dx <= nx - i; dx += ddx) {
-                    for (dy = 1; dy <= ny - j; dy += ddy) {
-                        for (dz = 1; dz <= nz - k; dz += ddz) {
-
-                            /*
-                             * Describe the source and destination hyperslabs and the
-                             * arrays to which they belong.
-                             */
-                            hs_size[0] = dx;
-                            hs_size[1] = dy;
-                            hs_size[2] = dz;
-                            dst_size[0] = src_size[0] = nx;
-                            dst_size[1] = src_size[1] = ny;
-                            dst_size[2] = src_size[2] = nz;
-                            switch (mode) {
-                            case VARIABLE_SRC:
-                                dst_offset[0] = 0;
-                                dst_offset[1] = 0;
-                                dst_offset[2] = 0;
-                                src_offset[0] = i;
-                                src_offset[1] = j;
-                                src_offset[2] = k;
-                                break;
-                            case VARIABLE_DST:
-                                dst_offset[0] = i;
-                                dst_offset[1] = j;
-                                dst_offset[2] = k;
-                                src_offset[0] = 0;
-                                src_offset[1] = 0;
-                                src_offset[2] = 0;
-                                break;
-                            case VARIABLE_BOTH:
-                                dst_offset[0] = i;
-                                dst_offset[1] = j;
-                                dst_offset[2] = k;
-                                src_offset[0] = i;
-                                src_offset[1] = j;
-                                src_offset[2] = k;
-                                break;
-                            default:
-                                abort();
-                            }
-
-                            /*
-                             * Sum the main array directly to get a reference value
-                             * to compare against later.
-                             */
-                            ref_value = 0;
-                            for (u = src_offset[0]; u < src_offset[0] + dx; u++) {
-                                for (v = src_offset[1]; v < src_offset[1] + dy; v++) {
-                                    for (w = src_offset[2]; w < src_offset[2] + dz; w++) {
-                                        ref_value += src[u * ny * nz + v * nz + w];
-                                    }
-                                }
-                            }
-
-                            /*
-                             * Set all loc values to 1 so we can detect writing
-                             * outside the hyperslab.
-                             */
-                            for (u = 0; u < nx; u++) {
-                                for (v = 0; v < ny; v++) {
-                                    for (w = 0; w < nz; w++) {
-                                        dst[u * ny * nz + v * nz + w] = 1;
-                                    }
-                                }
-                            }
-
-                            /*
-                             * Copy a hyperslab from the global array to the local
-                             * array.
-                             */
-                            H5V_hyper_copy(ndims, hs_size,
-                                           dst_size, dst_offset, dst,
-                                           src_size, src_offset, src);
-
-                            /*
-                             * Sum the destination hyperslab.  It should be the same
-                             * as the reference value.
-                             */
-                            acc = 0;
-                            for (u = dst_offset[0]; u < dst_offset[0] + dx; u++) {
-                                for (v = dst_offset[1]; v < dst_offset[1] + dy; v++) {
-                                    for (w = dst_offset[2]; w < dst_offset[2] + dz; w++) {
-                                        acc += dst[u * ny * nz + v * nz + w];
-                                    }
-                                }
-                            }
-                            if (acc != ref_value) {
-                                puts("*FAILED*");
-                                if (!isatty(1)) {
-                                    /*
-                                     * Print debugging info unless output is going
-                                     * directly to a terminal.
-                                     */
-                                    AT();
-                                    printf("   acc != ref_value\n");
-                                    printf("   i=%d, j=%d, k=%d, "
-                                           "dx=%d, dy=%d, dz=%d\n",
-                                           i, j, k, dx, dy, dz);
-                                    print_ref(nx, ny, nz);
-                                    printf("\n   Destination array is:\n");
-                                    print_array(dst, nx, ny, nz);
-                                }
-                                goto error;
-                            }
-                            /*
-                             * Sum the entire array. It should be a fixed amount
-                             * larger than the reference value since we added the
-                             * border of 1's to the hyperslab.
-                             */
-                            acc = 0;
-                            for (u = 0; u < nx; u++) {
-                                for (v = 0; v < ny; v++) {
-                                    for (w = 0; w < nz; w++) {
-                                        acc += dst[u * ny * nz + v * nz + w];
-                                    }
-                                }
-                            }
-                            if (acc != ref_value + nx * ny * nz - dx * dy * dz) {
-                                puts("*FAILED*");
-                                if (!isatty(1)) {
-                                    /*
-                                     * Print debugging info unless output is going
-                                     * directly to a terminal.
-                                     */
-                                    AT();
-                                    printf("   acc != ref_value + nx*ny*nz - "
-                                           "dx*dy*dz\n");
-                                    printf("   i=%d, j=%d, k=%d, "
-                                           "dx=%d, dy=%d, dz=%d\n",
-                                           i, j, k, dx, dy, dz);
-                                    print_ref(nx, ny, nz);
-                                    printf("\n   Destination array is:\n");
-                                    print_array(dst, nx, ny, nz);
-                                }
-                                goto error;
-                            }
-                        }
-                    }
-                }
-            }
-        }
+	for (j = 0; j < ny; j += dj) {
+	    for (k = 0; k < nz; k += dk) {
+		for (dx = 1; dx <= nx - i; dx += ddx) {
+		    for (dy = 1; dy <= ny - j; dy += ddy) {
+			for (dz = 1; dz <= nz - k; dz += ddz) {
+
+			    /*
+			     * Describe the source and destination hyperslabs
+			     * and the arrays to which they belong.
+			     */
+			    hs_size[0] = dx;
+			    hs_size[1] = dy;
+			    hs_size[2] = dz;
+			    dst_size[0] = src_size[0] = nx;
+			    dst_size[1] = src_size[1] = ny;
+			    dst_size[2] = src_size[2] = nz;
+			    switch (mode) {
+			    case VARIABLE_SRC:
+				dst_offset[0] = 0;
+				dst_offset[1] = 0;
+				dst_offset[2] = 0;
+				src_offset[0] = i;
+				src_offset[1] = j;
+				src_offset[2] = k;
+				break;
+			    case VARIABLE_DST:
+				dst_offset[0] = i;
+				dst_offset[1] = j;
+				dst_offset[2] = k;
+				src_offset[0] = 0;
+				src_offset[1] = 0;
+				src_offset[2] = 0;
+				break;
+			    case VARIABLE_BOTH:
+				dst_offset[0] = i;
+				dst_offset[1] = j;
+				dst_offset[2] = k;
+				src_offset[0] = i;
+				src_offset[1] = j;
+				src_offset[2] = k;
+				break;
+			    default:
+				abort();
+			    }
+
+			    /*
+			     * Sum the main array directly to get a reference
+			     * value to compare against later.
+			     */
+			    ref_value = 0;
+			    for (u=src_offset[0]; u<src_offset[0]+dx; u++) {
+				for (v=src_offset[1];
+				     v<src_offset[1]+dy;
+				     v++) {
+				    for (w=src_offset[2];
+					 w<src_offset[2]+dz;
+					 w++) {
+					ref_value += src[u*ny*nz + v*nz + w];
+				    }
+				}
+			    }
+
+			    /*
+			     * Set all loc values to 1 so we can detect writing
+			     * outside the hyperslab.
+			     */
+			    for (u = 0; u < nx; u++) {
+				for (v = 0; v < ny; v++) {
+				    for (w = 0; w < nz; w++) {
+					dst[u * ny * nz + v * nz + w] = 1;
+				    }
+				}
+			    }
+
+			    /*
+			     * Copy a hyperslab from the global array to the
+			     * local array.
+			     */
+			    H5V_hyper_copy(ndims, hs_size,
+					   dst_size, dst_offset, dst,
+					   src_size, src_offset, src);
+
+			    /*
+			     * Sum the destination hyperslab.  It should be
+			     * the same as the reference value.
+			     */
+			    acc = 0;
+			    for (u=dst_offset[0]; u<dst_offset[0]+dx; u++) {
+				for (v=dst_offset[1];
+				     v<dst_offset[1]+dy;
+				     v++) {
+				    for (w = dst_offset[2];
+					 w < dst_offset[2] + dz;
+					 w++) {
+					acc += dst[u * ny * nz + v * nz + w];
+				    }
+				}
+			    }
+			    if (acc != ref_value) {
+				puts("*FAILED*");
+				if (!isatty(1)) {
+				    /*
+				     * Print debugging info unless output is
+				     * going directly to a terminal.
+				     */
+				    AT();
+				    printf("   acc != ref_value\n");
+				    printf("   i=%d, j=%d, k=%d, "
+					   "dx=%d, dy=%d, dz=%d\n",
+					   i, j, k, dx, dy, dz);
+				    print_ref(nx, ny, nz);
+				    printf("\n	 Destination array is:\n");
+				    print_array(dst, nx, ny, nz);
+				}
+				goto error;
+			    }
+			    /*
+			     * Sum the entire array. It should be a fixed
+			     * amount larger than the reference value since
+			     * we added the border of 1's to the hyperslab.
+			     */
+			    acc = 0;
+			    for (u = 0; u < nx; u++) {
+				for (v = 0; v < ny; v++) {
+				    for (w = 0; w < nz; w++) {
+					acc += dst[u * ny * nz + v * nz + w];
+				    }
+				}
+			    }
+			    if (acc != ref_value + nx*ny*nz - dx*dy*dz) {
+				puts("*FAILED*");
+				if (!isatty(1)) {
+				    /*
+				     * Print debugging info unless output is
+				     * going directly to a terminal.
+				     */
+				    AT();
+				    printf("   acc != ref_value + nx*ny*nz - "
+					   "dx*dy*dz\n");
+				    printf("   i=%d, j=%d, k=%d, "
+					   "dx=%d, dy=%d, dz=%d\n",
+					   i, j, k, dx, dy, dz);
+				    print_ref(nx, ny, nz);
+				    printf("\n	 Destination array is:\n");
+				    print_array(dst, nx, ny, nz);
+				}
+				goto error;
+			    }
+			}
+		    }
+		}
+	    }
+	}
     }
     puts(" PASSED");
     H5MM_xfree(src);
@@ -535,20 +551,20 @@ test_copy(int mode,
 }
 
 /*-------------------------------------------------------------------------
- * Function:    test_multifill
+ * Function:	test_multifill
  *
- * Purpose:     Tests the H5V_stride_copy() function by using it to fill a
- *              hyperslab by replicating a multi-byte sequence.  This might
- *              be useful to initialize an array of structs with a default
- *              struct value, or to initialize an array of floating-point
- *              values with a default bit-pattern.
+ * Purpose:	Tests the H5V_stride_copy() function by using it to fill a
+ *		hyperslab by replicating a multi-byte sequence.	 This might
+ *		be useful to initialize an array of structs with a default
+ *		struct value, or to initialize an array of floating-point
+ *		values with a default bit-pattern.
  *
- * Return:      Success:        SUCCEED
+ * Return:	Success:	SUCCEED
  *
- *              Failure:        FAIL
+ *		Failure:	FAIL
  *
- * Programmer:  Robb Matzke
- *              Saturday, October 11, 1997
+ * Programmer:	Robb Matzke
+ *		Saturday, October 11, 1997
  *
  * Modifications:
  *
@@ -557,17 +573,17 @@ test_copy(int mode,
 static herr_t
 test_multifill(int nx)
 {
-    int                     i, j;
-    size_t                  size;
-    intn                    src_stride;
-    intn                    dst_stride;
-    char                    s[64];
+    int			    i, j;
+    size_t		    size;
+    ssize_t		    src_stride;
+    ssize_t		    dst_stride;
+    char		    s[64];
 
     struct a_struct {
-        int                     left;
-        double                  mid;
-        int                     right;
-    } fill                 , *src = NULL, *dst = NULL;
+	int			left;
+	double			mid;
+	int			right;
+    } fill		   , *src = NULL, *dst = NULL;
 
     printf("%-70s", "Testing multi-byte fill value");
     fflush(stdout);
@@ -576,16 +592,16 @@ test_multifill(int nx)
     src = H5MM_xmalloc(nx * sizeof(*src));
     dst = H5MM_xmalloc(nx * sizeof(*dst));
     for (i = 0; i < nx; i++) {
-        src[i].left = 1111111;
-        src[i].mid = 12345.6789;
-        src[i].right = 2222222;
-        dst[i].left = 3333333;
-        dst[i].mid = 98765.4321;
-        dst[i].right = 4444444;
+	src[i].left = 1111111;
+	src[i].mid = 12345.6789;
+	src[i].right = 2222222;
+	dst[i].left = 3333333;
+	dst[i].mid = 98765.4321;
+	dst[i].right = 4444444;
     }
 
     /*
-     * Describe the fill value.  The zero stride says to read the same thing
+     * Describe the fill value.	 The zero stride says to read the same thing
      * over and over again.
      */
     fill.left = 55555555;
@@ -603,38 +619,38 @@ test_multifill(int nx)
      */
     size = nx;
     H5V_stride_copy(1, sizeof(double), &size,
-            &dst_stride, &          (dst[0].mid), &src_stride, &(fill.mid));
+		    &dst_stride, &(dst[0].mid), &src_stride, &(fill.mid));
 
     /*
      * Check
      */
     s[0] = '\0';
     for (i = 0; i < nx; i++) {
-        if (dst[i].left != 3333333) {
-            sprintf(s, "bad dst[%d].left", i);
-        } else if (dst[i].mid != fill.mid) {
-            sprintf(s, "bad dst[%d].mid", i);
-        } else if (dst[i].right != 4444444) {
-            sprintf(s, "bad dst[%d].right", i);
-        }
-        if (s[0]) {
-            puts("*FAILED*");
-            if (!isatty(1)) {
-                AT();
-                printf("   fill={%d,%g,%d}\n   ",
-                       fill.left, fill.mid, fill.right);
-                for (j = 0; j < sizeof(fill); j++) {
-                    printf(" %02x", ((uint8 *) &fill)[j]);
-                }
-                printf("\n   dst[%d]={%d,%g,%d}\n   ",
-                       i, dst[i].left, dst[i].mid, dst[i].right);
-                for (j = 0; j < sizeof(dst[i]); j++) {
-                    printf(" %02x", ((uint8 *) (dst + i))[j]);
-                }
-                printf("\n");
-            }
-            goto error;
-        }
+	if (dst[i].left != 3333333) {
+	    sprintf(s, "bad dst[%d].left", i);
+	} else if (dst[i].mid != fill.mid) {
+	    sprintf(s, "bad dst[%d].mid", i);
+	} else if (dst[i].right != 4444444) {
+	    sprintf(s, "bad dst[%d].right", i);
+	}
+	if (s[0]) {
+	    puts("*FAILED*");
+	    if (!isatty(1)) {
+		AT();
+		printf("   fill={%d,%g,%d}\n   ",
+		       fill.left, fill.mid, fill.right);
+		for (j = 0; j < sizeof(fill); j++) {
+		    printf(" %02x", ((uint8 *) &fill)[j]);
+		}
+		printf("\n   dst[%d]={%d,%g,%d}\n   ",
+		       i, dst[i].left, dst[i].mid, dst[i].right);
+		for (j = 0; j < sizeof(dst[i]); j++) {
+		    printf(" %02x", ((uint8 *) (dst + i))[j]);
+		}
+		printf("\n");
+	    }
+	    goto error;
+	}
     }
 
     puts(" PASSED");
@@ -649,18 +665,18 @@ test_multifill(int nx)
 }
 
 /*-------------------------------------------------------------------------
- * Function:    test_endian
+ * Function:	test_endian
  *
- * Purpose:     Tests the H5V_stride_copy() function by using it to copy an
- *              array of integers and swap the byte ordering from little
- *              endian to big endian or vice versa depending on the hardware.
+ * Purpose:	Tests the H5V_stride_copy() function by using it to copy an
+ *		array of integers and swap the byte ordering from little
+ *		endian to big endian or vice versa depending on the hardware.
  *
- * Return:      Success:        SUCCEED
+ * Return:	Success:	SUCCEED
  *
- *              Failure:        FAIL
+ *		Failure:	FAIL
  *
- * Programmer:  Robb Matzke
- *              Saturday, October 11, 1997
+ * Programmer:	Robb Matzke
+ *		Saturday, October 11, 1997
  *
  * Modifications:
  *
@@ -669,12 +685,12 @@ test_multifill(int nx)
 static herr_t
 test_endian(size_t nx)
 {
-    uint8                  *src = NULL;         /*source array                  */
-    uint8                  *dst = NULL;         /*destination array             */
-    intn                    src_stride[2];      /*source strides                */
-    intn                    dst_stride[2];      /*destination strides           */
-    size_t                  size[2];    /*size vector                   */
-    int                     i, j;
+    uint8	*src = NULL;		/*source array			*/
+    uint8	*dst = NULL;		/*destination array		*/
+    ssize_t	src_stride[2];		/*source strides		*/
+    ssize_t	dst_stride[2];		/*destination strides		*/
+    size_t	size[2];		/*size vector			*/
+    int		i, j;
 
     printf("%-70s", "Testing endian conversion by stride");
     fflush(stdout);
@@ -697,24 +713,24 @@ test_endian(size_t nx)
 
     /* Compare */
     for (i = 0; i < nx; i++) {
-        for (j = 0; j < 4; j++) {
-            if (src[i * 4 + j] != dst[i * 4 + 3 - j]) {
-                puts("*FAILED*");
-                if (!isatty(1)) {
-                    /*
-                     * Print debugging info unless output is going directly to a
-                     * terminal.
-                     */
-                    AT();
-                    printf("   i=%d, j=%d\n", i, j);
-                    printf("   Source array is:\n");
-                    print_array(src, nx, 4, 1);
-                    printf("\n   Result is:\n");
-                    print_array(dst, nx, 4, 1);
-                }
-                goto error;
-            }
-        }
+	for (j = 0; j < 4; j++) {
+	    if (src[i * 4 + j] != dst[i * 4 + 3 - j]) {
+		puts("*FAILED*");
+		if (!isatty(1)) {
+		    /*
+		     * Print debugging info unless output is going directly
+		     * to a terminal.
+		     */
+		    AT();
+		    printf("   i=%d, j=%d\n", i, j);
+		    printf("   Source array is:\n");
+		    print_array(src, nx, 4, 1);
+		    printf("\n	 Result is:\n");
+		    print_array(dst, nx, 4, 1);
+		}
+		goto error;
+	    }
+	}
     }
 
     puts(" PASSED");
@@ -729,17 +745,17 @@ test_endian(size_t nx)
 }
 
 /*-------------------------------------------------------------------------
- * Function:    test_transpose
+ * Function:	test_transpose
  *
- * Purpose:     Copy a 2d array from here to there and transpose the elements
- *              as it's copied.
+ * Purpose:	Copy a 2d array from here to there and transpose the elements
+ *		as it's copied.
  *
- * Return:      Success:        SUCCEED
+ * Return:	Success:	SUCCEED
  *
- *              Failure:        FAIL
+ *		Failure:	FAIL
  *
- * Programmer:  Robb Matzke
- *              Saturday, October 11, 1997
+ * Programmer:	Robb Matzke
+ *		Saturday, October 11, 1997
  *
  * Modifications:
  *
@@ -748,24 +764,24 @@ test_endian(size_t nx)
 static herr_t
 test_transpose(size_t nx, size_t ny)
 {
-    intn                   *src = NULL;
-    intn                   *dst = NULL;
-    int                     i, j;
-    intn                    src_stride[2], dst_stride[2];
-    size_t                  size[2];
-    char                    s[256];
+    intn	*src = NULL;
+    intn	*dst = NULL;
+    int		i, j;
+    ssize_t	src_stride[2], dst_stride[2];
+    size_t	size[2];
+    char	s[256];
 
     sprintf(s, "Testing 2d transpose by stride %4lux%-lud",
-            (unsigned long) nx, (unsigned long) ny);
+	    (unsigned long) nx, (unsigned long) ny);
     printf("%-70s", s);
     fflush(stdout);
 
     /* Initialize */
     src = H5MM_xmalloc(nx * ny * sizeof(*src));
     for (i = 0; i < nx; i++) {
-        for (j = 0; j < ny; j++) {
-            src[i * ny + j] = (intn)(i * ny + j);
-        }
+	for (j = 0; j < ny; j++) {
+	    src[i * ny + j] = (intn)(i * ny + j);
+	}
     }
     dst = H5MM_xcalloc(nx * ny, sizeof(*dst));
 
@@ -774,48 +790,48 @@ test_transpose(size_t nx, size_t ny)
     size[1] = ny;
     src_stride[0] = 0;
     src_stride[1] = sizeof(*src);
-    dst_stride[0] = (intn)((1 - nx * ny) * sizeof(*src));
-    dst_stride[1] = (intn)(nx * sizeof(*src));
+    dst_stride[0] = (1 - nx * ny) * sizeof(*src);
+    dst_stride[1] = nx * sizeof(*src);
 
     /* Copy and transpose */
     if (nx == ny) {
-        H5V_stride_copy(2, sizeof(*src), size,
-                        dst_stride, dst,
-                        src_stride, src);
+	H5V_stride_copy(2, sizeof(*src), size,
+			dst_stride, dst,
+			src_stride, src);
     } else {
-        H5V_stride_copy(2, sizeof(*src), size,
-                        dst_stride, dst,
-                        src_stride, src);
+	H5V_stride_copy(2, sizeof(*src), size,
+			dst_stride, dst,
+			src_stride, src);
     }
 
     /* Check */
     for (i = 0; i < nx; i++) {
-        for (j = 0; j < ny; j++) {
-            if (src[i * ny + j] != dst[j * nx + i]) {
-                puts("*FAILED*");
-                if (!isatty(1)) {
-                    AT();
-                    printf("   diff at i=%d, j=%d\n", i, j);
-                    printf("   Source is:\n");
-                    for (i = 0; i < nx; i++) {
-                        printf("%3d:", i);
-                        for (j = 0; j < ny; j++) {
-                            printf(" %6d", src[i * ny + j]);
-                        }
-                        printf("\n");
-                    }
-                    printf("\n   Destination is:\n");
-                    for (i = 0; i < ny; i++) {
-                        printf("%3d:", i);
-                        for (j = 0; j < nx; j++) {
-                            printf(" %6d", dst[i * nx + j]);
-                        }
-                        printf("\n");
-                    }
-                }
-                goto error;
-            }
-        }
+	for (j = 0; j < ny; j++) {
+	    if (src[i * ny + j] != dst[j * nx + i]) {
+		puts("*FAILED*");
+		if (!isatty(1)) {
+		    AT();
+		    printf("   diff at i=%d, j=%d\n", i, j);
+		    printf("   Source is:\n");
+		    for (i = 0; i < nx; i++) {
+			printf("%3d:", i);
+			for (j = 0; j < ny; j++) {
+			    printf(" %6d", src[i * ny + j]);
+			}
+			printf("\n");
+		    }
+		    printf("\n	 Destination is:\n");
+		    for (i = 0; i < ny; i++) {
+			printf("%3d:", i);
+			for (j = 0; j < nx; j++) {
+			    printf(" %6d", dst[i * nx + j]);
+			}
+			printf("\n");
+		    }
+		}
+		goto error;
+	    }
+	}
     }
 
     puts(" PASSED");
@@ -830,19 +846,19 @@ test_transpose(size_t nx, size_t ny)
 }
 
 /*-------------------------------------------------------------------------
- * Function:    test_sub_super
+ * Function:	test_sub_super
  *
- * Purpose:     Tests H5V_stride_copy() to reduce the resolution of an image
- *              by copying half the pixels in the X and Y directions.  Then
- *              we use the small image and duplicate every pixel to result in
- *              a 2x2 square.
+ * Purpose:	Tests H5V_stride_copy() to reduce the resolution of an image
+ *		by copying half the pixels in the X and Y directions.  Then
+ *		we use the small image and duplicate every pixel to result in
+ *		a 2x2 square.
  *
- * Return:      Success:        SUCCEED
+ * Return:	Success:	SUCCEED
  *
- *              Failure:        FAIL
+ *		Failure:	FAIL
  *
- * Programmer:  Robb Matzke
- *              Monday, October 13, 1997
+ * Programmer:	Robb Matzke
+ *		Monday, October 13, 1997
  *
  * Modifications:
  *
@@ -851,18 +867,18 @@ test_transpose(size_t nx, size_t ny)
 static herr_t
 test_sub_super(size_t nx, size_t ny)
 {
-    uint8                  *full = NULL;        /*original image                */
-    uint8                  *half = NULL;        /*image at 1/2 resolution       */
-    uint8                  *twice = NULL;       /*2x2 pixels                    */
-    intn                    src_stride[4];      /*source stride info            */
-    intn                    dst_stride[4];      /*destination stride info       */
-    size_t                  size[4];    /*number of sample points       */
-    int                     i, j;
-    char                    s[256];
+    uint8	*full = NULL;	/*original image		*/
+    uint8	*half = NULL;	/*image at 1/2 resolution	*/
+    uint8	*twice = NULL;	/*2x2 pixels			*/
+    ssize_t	src_stride[4];	/*source stride info		*/
+    ssize_t	dst_stride[4];	/*destination stride info	*/
+    size_t	size[4];	/*number of sample points	*/
+    int		i, j;
+    char	s[256];
 
     sprintf(s, "Testing image sampling %4lux%-4lu to %4lux%-4lu ",
-            (unsigned long) (2 * nx), (unsigned long) (2 * ny),
-            (unsigned long) nx, (unsigned long) ny);
+	    (unsigned long) (2 * nx), (unsigned long) (2 * ny),
+	    (unsigned long) nx, (unsigned long) ny);
     printf("%-70s", s);
     fflush(stdout);
 
@@ -875,31 +891,32 @@ test_sub_super(size_t nx, size_t ny)
     /* Setup */
     size[0] = nx;
     size[1] = ny;
-    src_stride[0] = (intn)(2 * ny);
+    src_stride[0] = 2 * ny;
     src_stride[1] = 2;
     dst_stride[0] = 0;
     dst_stride[1] = 1;
 
     /* Copy */
     H5V_stride_copy(2, sizeof(uint8), size,
-                    dst_stride, half, src_stride, full);
+		    dst_stride, half, src_stride, full);
 
     /* Check */
     for (i = 0; i < nx; i++) {
-        for (j = 0; j < ny; j++) {
-            if (full[4 * i * ny + 2 * j] != half[i * ny + j]) {
-                puts("*FAILED*");
-                if (!isatty(1)) {
-                    AT();
-                    printf("   full[%d][%d] != half[%d][%d]\n", i * 2, j * 2, i, j);
-                    printf("   full is:\n");
-                    print_array(full, 2 * nx, 2 * ny, 1);
-                    printf("\n   half is:\n");
-                    print_array(half, nx, ny, 1);
-                }
-                goto error;
-            }
-        }
+	for (j = 0; j < ny; j++) {
+	    if (full[4 * i * ny + 2 * j] != half[i * ny + j]) {
+		puts("*FAILED*");
+		if (!isatty(1)) {
+		    AT();
+		    printf("   full[%d][%d] != half[%d][%d]\n",
+			   i*2, j*2, i, j);
+		    printf("   full is:\n");
+		    print_array(full, 2 * nx, 2 * ny, 1);
+		    printf("\n	 half is:\n");
+		    print_array(half, nx, ny, 1);
+		}
+		goto error;
+	    }
+	}
     }
     puts(" PASSED");
 
@@ -908,8 +925,8 @@ test_sub_super(size_t nx, size_t ny)
      * dimension.
      */
     sprintf(s, "Testing image sampling %4lux%-4lu to %4lux%-4lu ",
-            (unsigned long) nx, (unsigned long) ny,
-            (unsigned long) (2 * nx), (unsigned long) (2 * ny));
+	    (unsigned long) nx, (unsigned long) ny,
+	    (unsigned long) (2 * nx), (unsigned long) (2 * ny));
     printf("%-70s", s);
     fflush(stdout);
 
@@ -922,40 +939,44 @@ test_sub_super(size_t nx, size_t ny)
     src_stride[1] = 1;
     src_stride[2] = 0;
     src_stride[3] = 0;
-    dst_stride[0] = (intn)(2 * ny);
-    dst_stride[1] = (intn)(2 * sizeof(uint8) - 4 * ny);
-    dst_stride[2] = (intn)(2 * ny - 2 * sizeof(uint8));
+    dst_stride[0] = 2 * ny;
+    dst_stride[1] = 2 * sizeof(uint8) - 4 * ny;
+    dst_stride[2] = 2 * ny - 2 * sizeof(uint8);
     dst_stride[3] = sizeof(uint8);
 
     /* Copy */
     H5V_stride_copy(4, sizeof(uint8), size,
-                    dst_stride, twice, src_stride, half);
+		    dst_stride, twice, src_stride, half);
 
     /* Check */
     s[0] = '\0';
     for (i = 0; i < nx; i++) {
-        for (j = 0; j < ny; j++) {
-            if (half[i * ny + j] != twice[4 * i * ny + 2 * j]) {
-                sprintf(s, "half[%d][%d] != twice[%d][%d]", i, j, 2 * i, 2 * j);
-            } else if (half[i * ny + j] != twice[4 * i * ny + 2 * j + 1]) {
-                sprintf(s, "half[%d][%d] != twice[%d][%d]", i, j, 2 * i, 2 * j + 1);
-            } else if (half[i * ny + j] != twice[(2 * i + 1) * 2 * ny + 2 * j]) {
-                sprintf(s, "half[%d][%d] != twice[%d][%d]", i, j, 2 * i + 1, 2 * j);
-            } else if (half[i * ny + j] != twice[(2 * i + 1) * 2 * ny + 2 * j + 1]) {
-                sprintf(s, "half[%d][%d] != twice[%d][%d]", i, j, 2 * i + 1, 2 * j + 1);
-            }
-            if (s[0]) {
-                puts("*FAILED*");
-                if (!isatty(1)) {
-                    AT();
-                    printf("   %s\n   Half is:\n", s);
-                    print_array(half, nx, ny, 1);
-                    printf("\n   Twice is:\n");
-                    print_array(twice, 2 * nx, 2 * ny, 1);
-                }
-                goto error;
-            }
-        }
+	for (j = 0; j < ny; j++) {
+	    if (half[i*ny+j] != twice[4*i*ny + 2*j]) {
+		sprintf(s, "half[%d][%d] != twice[%d][%d]",
+			i, j, 2 * i, 2 * j);
+	    } else if (half[i*ny + j] != twice[4*i*ny + 2*j + 1]) {
+		sprintf(s, "half[%d][%d] != twice[%d][%d]",
+			i, j, 2 * i, 2 * j + 1);
+	    } else if (half[i*ny + j] != twice[(2*i +1)*2*ny + 2*j]) {
+		sprintf(s, "half[%d][%d] != twice[%d][%d]",
+			i, j, 2 * i + 1, 2 * j);
+	    } else if (half[i*ny + j] != twice[(2*i+1)*2*ny + 2*j+1]) {
+		sprintf(s, "half[%d][%d] != twice[%d][%d]",
+			i, j, 2 * i + 1, 2 * j + 1);
+	    }
+	    if (s[0]) {
+		puts("*FAILED*");
+		if (!isatty(1)) {
+		    AT();
+		    printf("   %s\n   Half is:\n", s);
+		    print_array(half, nx, ny, 1);
+		    printf("\n	 Twice is:\n");
+		    print_array(twice, 2 * nx, 2 * ny, 1);
+		}
+		goto error;
+	    }
+	}
     }
     puts(" PASSED");
 
@@ -972,18 +993,18 @@ test_sub_super(size_t nx, size_t ny)
 }
 
 /*-------------------------------------------------------------------------
- * Function:    main
+ * Function:	main
  *
- * Purpose:     Test various hyperslab operations.  Give the words
- *              `small' and/or `medium' on the command line or only `small'
- *              is assumed.
+ * Purpose:	Test various hyperslab operations.  Give the words
+ *		`small' and/or `medium' on the command line or only `small'
+ *		is assumed.
  *
- * Return:      Success:        exit(0)
+ * Return:	Success:	exit(0)
  *
- *              Failure:        exit(non-zero)
+ *		Failure:	exit(non-zero)
  *
- * Programmer:  Robb Matzke
- *              Friday, October 10, 1997
+ * Programmer:	Robb Matzke
+ *		Friday, October 10, 1997
  *
  * Modifications:
  *
@@ -992,31 +1013,31 @@ test_sub_super(size_t nx, size_t ny)
 int
 main(int argc, char *argv[])
 {
-    herr_t                  status;
-    int                     nerrors = 0;
-    uintn                   size_of_test;
+    herr_t		    status;
+    int			    nerrors = 0;
+    uintn		    size_of_test;
 
     /* Parse arguments or assume `small' */
     if (1 == argc) {
-        size_of_test = TEST_SMALL;
+	size_of_test = TEST_SMALL;
     } else {
-        intn                    i;
-        for (i = 1, size_of_test = 0; i < argc; i++) {
-            if (!strcmp(argv[i], "small")) {
-                size_of_test |= TEST_SMALL;
-            } else if (!strcmp(argv[i], "medium")) {
-                size_of_test |= TEST_MEDIUM;
-            } else {
-                printf("unrecognized argument: %s\n", argv[i]);
-                exit(1);
-            }
-        }
+	intn			i;
+	for (i = 1, size_of_test = 0; i < argc; i++) {
+	    if (!strcmp(argv[i], "small")) {
+		size_of_test |= TEST_SMALL;
+	    } else if (!strcmp(argv[i], "medium")) {
+		size_of_test |= TEST_MEDIUM;
+	    } else {
+		printf("unrecognized argument: %s\n", argv[i]);
+		exit(1);
+	    }
+	}
     }
     printf("Test sizes: ");
     if (size_of_test & TEST_SMALL)
-        printf(" SMALL");
+	printf(" SMALL");
     if (size_of_test & TEST_MEDIUM)
-        printf(" MEDIUM");
+	printf(" MEDIUM");
     printf("\n");
 
     /*
@@ -1025,20 +1046,20 @@ main(int argc, char *argv[])
      *------------------------------ 
      */
     if (size_of_test & TEST_SMALL) {
-        status = test_fill(11, 0, 0, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
-        status = test_fill(11, 10, 0, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
-        status = test_fill(3, 5, 5, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
+	status = test_fill(11, 0, 0, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
+	status = test_fill(11, 10, 0, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
+	status = test_fill(3, 5, 5, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
     }
     if (size_of_test & TEST_MEDIUM) {
-        status = test_fill(113, 0, 0, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
-        status = test_fill(15, 11, 0, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
-        status = test_fill(5, 7, 7, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
+	status = test_fill(113, 0, 0, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
+	status = test_fill(15, 11, 0, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
+	status = test_fill(5, 7, 7, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
     }
    /*------------------------------
     * TEST HYPERSLAB COPY OPERATION
@@ -1047,63 +1068,63 @@ main(int argc, char *argv[])
 
     /* exhaustive, one-dimensional test */
     if (size_of_test & TEST_SMALL) {
-        status = test_copy(VARIABLE_SRC, 11, 0, 0, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
-        status = test_copy(VARIABLE_DST, 11, 0, 0, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
-        status = test_copy(VARIABLE_BOTH, 11, 0, 0, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
+	status = test_copy(VARIABLE_SRC, 11, 0, 0, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
+	status = test_copy(VARIABLE_DST, 11, 0, 0, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
+	status = test_copy(VARIABLE_BOTH, 11, 0, 0, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
     }
     if (size_of_test & TEST_MEDIUM) {
-        status = test_copy(VARIABLE_SRC, 179, 0, 0, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
-        status = test_copy(VARIABLE_DST, 179, 0, 0, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
-        status = test_copy(VARIABLE_BOTH, 179, 0, 0, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
+	status = test_copy(VARIABLE_SRC, 179, 0, 0, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
+	status = test_copy(VARIABLE_DST, 179, 0, 0, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
+	status = test_copy(VARIABLE_BOTH, 179, 0, 0, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
     }
     /* exhaustive, two-dimensional test */
     if (size_of_test & TEST_SMALL) {
-        status = test_copy(VARIABLE_SRC, 11, 10, 0, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
-        status = test_copy(VARIABLE_DST, 11, 10, 0, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
-        status = test_copy(VARIABLE_BOTH, 11, 10, 0, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
+	status = test_copy(VARIABLE_SRC, 11, 10, 0, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
+	status = test_copy(VARIABLE_DST, 11, 10, 0, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
+	status = test_copy(VARIABLE_BOTH, 11, 10, 0, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
     }
     if (size_of_test & TEST_MEDIUM) {
-        status = test_copy(VARIABLE_SRC, 13, 19, 0, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
-        status = test_copy(VARIABLE_DST, 13, 19, 0, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
-        status = test_copy(VARIABLE_BOTH, 13, 19, 0, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
+	status = test_copy(VARIABLE_SRC, 13, 19, 0, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
+	status = test_copy(VARIABLE_DST, 13, 19, 0, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
+	status = test_copy(VARIABLE_BOTH, 13, 19, 0, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
     }
     /* sparse, two-dimensional test */
     if (size_of_test & TEST_MEDIUM) {
-        status = test_copy(VARIABLE_SRC, 73, 67, 0, 7, 11, 1, 13, 11, 1);
-        nerrors += status < 0 ? 1 : 0;
-        status = test_copy(VARIABLE_DST, 73, 67, 0, 7, 11, 1, 13, 11, 1);
-        nerrors += status < 0 ? 1 : 0;
-        status = test_copy(VARIABLE_BOTH, 73, 67, 0, 7, 11, 1, 13, 11, 1);
-        nerrors += status < 0 ? 1 : 0;
+	status = test_copy(VARIABLE_SRC, 73, 67, 0, 7, 11, 1, 13, 11, 1);
+	nerrors += status < 0 ? 1 : 0;
+	status = test_copy(VARIABLE_DST, 73, 67, 0, 7, 11, 1, 13, 11, 1);
+	nerrors += status < 0 ? 1 : 0;
+	status = test_copy(VARIABLE_BOTH, 73, 67, 0, 7, 11, 1, 13, 11, 1);
+	nerrors += status < 0 ? 1 : 0;
     }
     /* exhaustive, three-dimensional test */
     if (size_of_test & TEST_SMALL) {
-        status = test_copy(VARIABLE_SRC, 3, 5, 5, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
-        status = test_copy(VARIABLE_DST, 3, 5, 5, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
-        status = test_copy(VARIABLE_BOTH, 3, 5, 5, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
+	status = test_copy(VARIABLE_SRC, 3, 5, 5, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
+	status = test_copy(VARIABLE_DST, 3, 5, 5, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
+	status = test_copy(VARIABLE_BOTH, 3, 5, 5, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
     }
     if (size_of_test & TEST_MEDIUM) {
-        status = test_copy(VARIABLE_SRC, 7, 9, 5, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
-        status = test_copy(VARIABLE_DST, 7, 9, 5, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
-        status = test_copy(VARIABLE_BOTH, 7, 9, 5, 1, 1, 1, 1, 1, 1);
-        nerrors += status < 0 ? 1 : 0;
+	status = test_copy(VARIABLE_SRC, 7, 9, 5, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
+	status = test_copy(VARIABLE_DST, 7, 9, 5, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
+	status = test_copy(VARIABLE_BOTH, 7, 9, 5, 1, 1, 1, 1, 1, 1);
+	nerrors += status < 0 ? 1 : 0;
     }
    /*---------------------
     * TEST MULTI-BYTE FILL
@@ -1111,12 +1132,12 @@ main(int argc, char *argv[])
     */
 
     if (size_of_test & TEST_SMALL) {
-        status = test_multifill(10);
-        nerrors += status < 0 ? 1 : 0;
+	status = test_multifill(10);
+	nerrors += status < 0 ? 1 : 0;
     }
     if (size_of_test & TEST_MEDIUM) {
-        status = test_multifill(500000);
-        nerrors += status < 0 ? 1 : 0;
+	status = test_multifill(500000);
+	nerrors += status < 0 ? 1 : 0;
     }
    /*---------------------------
     * TEST TRANSLATION OPERATORS
@@ -1124,20 +1145,20 @@ main(int argc, char *argv[])
     */
 
     if (size_of_test & TEST_SMALL) {
-        status = test_endian(10);
-        nerrors += status < 0 ? 1 : 0;
-        status = test_transpose(9, 9);
-        nerrors += status < 0 ? 1 : 0;
-        status = test_transpose(3, 11);
-        nerrors += status < 0 ? 1 : 0;
+	status = test_endian(10);
+	nerrors += status < 0 ? 1 : 0;
+	status = test_transpose(9, 9);
+	nerrors += status < 0 ? 1 : 0;
+	status = test_transpose(3, 11);
+	nerrors += status < 0 ? 1 : 0;
     }
     if (size_of_test & TEST_MEDIUM) {
-        status = test_endian(800000);
-        nerrors += status < 0 ? 1 : 0;
-        status = test_transpose(1200, 1200);
-        nerrors += status < 0 ? 1 : 0;
-        status = test_transpose(800, 1800);
-        nerrors += status < 0 ? 1 : 0;
+	status = test_endian(800000);
+	nerrors += status < 0 ? 1 : 0;
+	status = test_transpose(1200, 1200);
+	nerrors += status < 0 ? 1 : 0;
+	status = test_transpose(800, 1800);
+	nerrors += status < 0 ? 1 : 0;
     }
    /*-------------------------
     * TEST SAMPLING OPERATIONS
@@ -1145,23 +1166,23 @@ main(int argc, char *argv[])
     */
 
     if (size_of_test & TEST_SMALL) {
-        status = test_sub_super(5, 10);
-        nerrors += status < 0 ? 1 : 0;
+	status = test_sub_super(5, 10);
+	nerrors += status < 0 ? 1 : 0;
     }
     if (size_of_test & TEST_MEDIUM) {
-        status = test_sub_super(480, 640);
-        nerrors += status < 0 ? 1 : 0;
+	status = test_sub_super(480, 640);
+	nerrors += status < 0 ? 1 : 0;
     }
 /*--- END OF TESTS ---*/
 
     if (nerrors) {
-        printf("***** %d HYPERSLAB TEST%s FAILED! *****\n",
-               nerrors, 1 == nerrors ? "" : "S");
-        if (isatty(1)) {
-            printf("(Redirect output to a pager or a file to see "
-                   "debug output)\n");
-        }
-        exit(1);
+	printf("***** %d HYPERSLAB TEST%s FAILED! *****\n",
+	       nerrors, 1 == nerrors ? "" : "S");
+	if (isatty(1)) {
+	    printf("(Redirect output to a pager or a file to see "
+		   "debug output)\n");
+	}
+	exit(1);
     }
     printf("All hyperslab tests passed.\n");
     return 0;