[svn-r22287] Description:

    Clean up more FUNC_ENTER/FUNC_LEAVE macros and move H5D & H5T code toward
the final design (as exemplified by the H5EA & H5FA code).

Tested on:
    Mac OSX/64 10.7.3 (amazon) w/debug & parallel

6 files changed, 160 insertions, 156 deletions

diff --git a/test/bittests.c b/test/bittests.c
index f063cee..c527bb8 100644
--- a/test/bittests.c
+++ b/test/bittests.c
@@ -56,13 +56,13 @@ test_find (void)
 
     /* The zero length buffer */
     HDmemset(v1, 0xaa, sizeof v1);
-    n = H5T_bit_find(v1, (size_t)0, (size_t)0, H5T_BIT_LSB, TRUE);
+    n = H5T__bit_find(v1, (size_t)0, (size_t)0, H5T_BIT_LSB, TRUE);
     if(-1 != n) {
 	H5_FAILED();
 	puts ("    Zero length test failed (lsb)!");
 	goto failed;
     }
-    n = H5T_bit_find(v1, (size_t)0, (size_t)0, H5T_BIT_MSB, TRUE);
+    n = H5T__bit_find(v1, (size_t)0, (size_t)0, H5T_BIT_MSB, TRUE);
     if(-1 != n) {
 	H5_FAILED();
 	puts ("    Zero length test failed (msb)!");
@@ -72,13 +72,13 @@ test_find (void)
 
     /* The zero buffer */
     HDmemset(v1, 0, sizeof v1);
-    n = H5T_bit_find(v1, (size_t)0, 8 * sizeof(v1), H5T_BIT_LSB, TRUE);
+    n = H5T__bit_find(v1, (size_t)0, 8 * sizeof(v1), H5T_BIT_LSB, TRUE);
     if(-1 != n) {
 	H5_FAILED();
 	puts ("    Zero buffer test failed (lsb)!");
 	goto failed;
     }
-    n = H5T_bit_find(v1, (size_t)0, 8 * sizeof(v1), H5T_BIT_MSB, TRUE);
+    n = H5T__bit_find(v1, (size_t)0, 8 * sizeof(v1), H5T_BIT_MSB, TRUE);
     if(-1 != n) {
 	H5_FAILED();
 	puts ("    Zero buffer test failed (msb)!");
@@ -89,13 +89,13 @@ test_find (void)
     for(i = 0; i < 8 * (int)sizeof(v1); i++) {
 	HDmemset(v1, 0, sizeof v1);
 	v1[i / 8] = 1 << (i % 8);
-	n = H5T_bit_find(v1, (size_t)0, 8 * sizeof(v1), H5T_BIT_LSB, TRUE);
+	n = H5T__bit_find(v1, (size_t)0, 8 * sizeof(v1), H5T_BIT_LSB, TRUE);
 	if((ssize_t)i != n) {
 	    H5_FAILED();
 	    printf ("    Test for set bit %d failed (lsb)!\n", i);
 	    goto failed;
 	}
-	n = H5T_bit_find(v1, (size_t)0, 8 * sizeof(v1), H5T_BIT_MSB, TRUE);
+	n = H5T__bit_find(v1, (size_t)0, 8 * sizeof(v1), H5T_BIT_MSB, TRUE);
 	if((ssize_t)i != n) {
 	    H5_FAILED();
 	    printf ("    Test for set bit %d failed (msb)!\n", i);
@@ -105,13 +105,13 @@ test_find (void)
 
     /* The one buffer */
     HDmemset(v1, 0xff, sizeof v1);
-    n = H5T_bit_find(v1, (size_t)0, 8 * sizeof(v1), H5T_BIT_LSB, FALSE);
+    n = H5T__bit_find(v1, (size_t)0, 8 * sizeof(v1), H5T_BIT_LSB, FALSE);
     if(-1 != n) {
 	H5_FAILED();
 	puts ("    One buffer test failed (lsb)!");
 	goto failed;
     }
-    n = H5T_bit_find(v1, (size_t)0, 8 * sizeof(v1), H5T_BIT_MSB, FALSE);
+    n = H5T__bit_find(v1, (size_t)0, 8 * sizeof(v1), H5T_BIT_MSB, FALSE);
     if(-1 != n) {
 	H5_FAILED();
 	puts ("    One buffer test failed (msb)!");
@@ -122,13 +122,13 @@ test_find (void)
     for (i=0; i<8*(int)sizeof(v1); i++) {
 	memset (v1, 0xff, sizeof v1);
 	v1[i/8] &= ~(1<<(i%8));
-	n = H5T_bit_find (v1, (size_t)0, 8*sizeof(v1), H5T_BIT_LSB, FALSE);
+	n = H5T__bit_find (v1, (size_t)0, 8*sizeof(v1), H5T_BIT_LSB, FALSE);
 	if ((ssize_t)i!=n) {
 	    H5_FAILED();
 	    printf ("    Test for clear bit %d failed (lsb)!\n", i);
 	    goto failed;
 	}
-	n = H5T_bit_find (v1, (size_t)0, 8*sizeof(v1), H5T_BIT_MSB, FALSE);
+	n = H5T__bit_find (v1, (size_t)0, 8*sizeof(v1), H5T_BIT_MSB, FALSE);
 	if ((ssize_t)i!=n) {
 	    H5_FAILED();
 	    printf ("    Test for clear bit %d failed (lsb)!\n", i);
@@ -183,7 +183,7 @@ test_copy (void)
 	memset (v2, 0x00, sizeof v2);
 
 	/* Copy some bits to v2 and make sure something was copied */
-	H5T_bit_copy (v2, d_offset, v1, s_offset, size);
+	H5T__bit_copy (v2, d_offset, v1, s_offset, size);
 	for (j=0; j<(int)sizeof(v2); j++) if (v2[j]) break;
 	if (size>0 && j>=(int)sizeof(v2)) {
 	    H5_FAILED();
@@ -198,7 +198,7 @@ test_copy (void)
 
 
 	/* Look for the zeros and ones */
-	n = H5T_bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_LSB, 1);
+	n = H5T__bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_LSB, 1);
 	if (size>0 && n!=(ssize_t)d_offset) {
 	    H5_FAILED();
 	    printf ("    Unable to find first copied bit in destination "
@@ -210,7 +210,7 @@ test_copy (void)
 	    puts ("    Found copied bits and shouldn't have!");
 	    goto failed;
 	}
-	n = H5T_bit_find (v2, d_offset, 8*sizeof(v2)-d_offset, H5T_BIT_LSB, 0);
+	n = H5T__bit_find (v2, d_offset, 8*sizeof(v2)-d_offset, H5T_BIT_LSB, 0);
 	if (d_offset+size<8*sizeof(v2) && n!=(ssize_t)size) {
 	    H5_FAILED();
 	    printf ("    Unable to find last copied bit in destination "
@@ -227,7 +227,7 @@ test_copy (void)
 	 * Look for zeros and ones in reverse order.  This is only to test
 	 * that reverse searches work as expected.
 	 */
-	n = H5T_bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_MSB, 1);
+	n = H5T__bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_MSB, 1);
 	if (size>0 && (size_t)(n+1)!=d_offset+size) {
 	    H5_FAILED();
 	    printf ("    Unable to find last copied bit in destination "
@@ -239,7 +239,7 @@ test_copy (void)
 	    puts ("    Found copied bits but shouldn't have (reverse)!");
 	    goto failed;
 	}
-	n = H5T_bit_find (v2, (size_t)0, d_offset+size, H5T_BIT_MSB, 0);
+	n = H5T__bit_find (v2, (size_t)0, d_offset+size, H5T_BIT_MSB, 0);
 	if (d_offset>0 && n+1!=(ssize_t)d_offset) {
 	    H5_FAILED();
 	    printf ("    Unable to find beginning of copied data "
@@ -305,12 +305,12 @@ test_shift (void)
 
 	/*-------- LEFT-shift some bits and make sure something was shifted --------*/
 	memset (vector, 0x00, sizeof vector);
-        H5T_bit_set (vector, offset, size, 1);
+        H5T__bit_set (vector, offset, size, 1);
 
-        H5T_bit_shift (vector, shift_dist, offset, size);
+        H5T__bit_shift (vector, shift_dist, offset, size);
 
 	/* Look for the ones */
-	n = H5T_bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
+	n = H5T__bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
 	if ((size_t)n!=offset+shift_dist) {
 	    H5_FAILED();
 	    printf ("    Unable to find first bit in destination "
@@ -322,7 +322,7 @@ test_shift (void)
 	 * Look for zeros and ones in reverse order.  This is only to test
 	 * that reverse searches work as expected.
 	 */
-	n = H5T_bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_MSB, 1);
+	n = H5T__bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_MSB, 1);
 	if (n!=(ssize_t)(offset+size-1)) {
 	    H5_FAILED();
 	    printf ("    Unable to find last bit in destination "
@@ -332,12 +332,12 @@ test_shift (void)
 
 	/*-------- RIGHT-shift some bits and make sure something was shifted --------*/
 	memset (vector, 0x00, sizeof vector);
-        H5T_bit_set (vector, offset, size, 1);
+        H5T__bit_set (vector, offset, size, 1);
 
-        H5T_bit_shift (vector, -shift_dist, offset, size);
+        H5T__bit_shift (vector, -shift_dist, offset, size);
 
 	/* Look for the ones */
-	n = H5T_bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
+	n = H5T__bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
 	if ((size_t)n!=offset) {
 	    H5_FAILED();
 	    printf ("    Unable to find first bit in destination "
@@ -349,7 +349,7 @@ test_shift (void)
 	 * Look for zeros and ones in reverse order.  This is only to test
 	 * that reverse searches work as expected.
 	 */
-	n = H5T_bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_MSB, 1);
+	n = H5T__bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_MSB, 1);
 	if (n!=(ssize_t)(offset+size-shift_dist-1)) {
 	    H5_FAILED();
 	    printf ("    Unable to find last bit in destination "
@@ -367,12 +367,12 @@ test_shift (void)
             shift_dist = -((ssize_t)size);
 
 	memset (vector, 0x00, sizeof vector);
-        H5T_bit_set (vector, offset, size, 1);
+        H5T__bit_set (vector, offset, size, 1);
 
-        H5T_bit_shift (vector, shift_dist, offset, size);
+        H5T__bit_shift (vector, shift_dist, offset, size);
 
 	/* Supposed to fail to find any ones */
-	n = H5T_bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
+	n = H5T__bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
 	if (n >= 0) {
 	    H5_FAILED();
 	    printf ("    Unable to verify all bits are zero in destination(LSB) "
@@ -381,7 +381,7 @@ test_shift (void)
 	}
 
         /* Look from the other direction */
-	n = H5T_bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_MSB, 1);
+	n = H5T__bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_MSB, 1);
 	if (n >= 0) {
 	    H5_FAILED();
 	    printf ("    Unable to verify all bits are zero in destination(MSB) "
@@ -437,15 +437,15 @@ test_increment (void)
 
 	memset (vector, 0x00, sizeof vector);
         if(size>1)  /* if size=6, make a sequence like 011111 */
-            H5T_bit_set (vector, offset, size-1, 1);
+            H5T__bit_set (vector, offset, size-1, 1);
         else  /* if size=1, just set this one bit to 1 */
-            H5T_bit_set (vector, offset, size, 1);
+            H5T__bit_set (vector, offset, size, 1);
 
 	/* Increment the sequence by one */
-        H5T_bit_inc (vector, offset, size);
+        H5T__bit_inc (vector, offset, size);
 
 	/* Look for the one */
-	n = H5T_bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
+	n = H5T__bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
 	if (size!=1 && (size_t)n!=offset+size-1) {
 	    H5_FAILED();
 	    printf ("    Unable to find first bit in destination "
@@ -463,7 +463,7 @@ test_increment (void)
 	 * Look for one in reverse order.  This is only to test
 	 * that reverse searches work as expected.
 	 */
-	n = H5T_bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_MSB, 1);
+	n = H5T__bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_MSB, 1);
 	if (size!=1 && n!=(ssize_t)(offset+size-1)) {
 	    H5_FAILED();
 	    printf ("    Unable to find last bit in destination "
@@ -526,10 +526,10 @@ test_decrement (void)
 	memset (vector, 0x00, sizeof vector);
 
 	/* decrement the sequence by one */
-        H5T_bit_dec (vector, offset, size);
+        H5T__bit_dec (vector, offset, size);
 
 	/* Look for the ones */
-	n = H5T_bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
+	n = H5T__bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
 	if ((size_t)n!=offset) {
 	    H5_FAILED();
 	    printf ("    Unable to find first bit in destination "
@@ -541,7 +541,7 @@ test_decrement (void)
 	 * Look for zeros and ones in reverse order.  This is only to test
 	 * that reverse searches work as expected.
 	 */
-	n = H5T_bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_MSB, 1);
+	n = H5T__bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_MSB, 1);
 	if (n!=(ssize_t)(offset+size-1)) {
 	    H5_FAILED();
 	    printf ("    Unable to find last bit in destination "
@@ -598,10 +598,10 @@ test_negate (void)
 	memset (vector, 0x00, sizeof vector);
 
 	/* negate the sequence */
-        H5T_bit_neg (vector, offset, size);
+        H5T__bit_neg (vector, offset, size);
 
 	/* Look for the ones */
-	n = H5T_bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
+	n = H5T__bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
 	if ((size_t)n!=offset) {
 	    H5_FAILED();
 	    printf ("    Unable to find first bit in destination "
@@ -613,7 +613,7 @@ test_negate (void)
 	 * Look for zeros and ones in reverse order.  This is only to test
 	 * that reverse searches work as expected.
 	 */
-	n = H5T_bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_MSB, 1);
+	n = H5T__bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_MSB, 1);
 	if (n!=(ssize_t)(offset+size-1)) {
 	    H5_FAILED();
 	    printf ("    Unable to find last bit in destination "
@@ -623,13 +623,13 @@ test_negate (void)
 
         /* All-one sequence will become 000000(size=6) after negating */
 	memset (vector, 0x00, sizeof vector);
-        H5T_bit_set (vector, offset, size, 1);
+        H5T__bit_set (vector, offset, size, 1);
 
 	/* negate the sequence */
-        H5T_bit_neg (vector, offset, size);
+        H5T__bit_neg (vector, offset, size);
 
 	/* Look for the ones */
-	n = H5T_bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
+	n = H5T__bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_LSB, 1);
 	if (n>=0) {
 	    H5_FAILED();
 	    printf ("    Unable to verify all-zero bits in destination "
@@ -641,7 +641,7 @@ test_negate (void)
 	 * Look for ones in reverse order.  This is only to test
 	 * that reverse searches work as expected.
 	 */
-	n = H5T_bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_MSB, 1);
+	n = H5T__bit_find (vector, (size_t)0, 8*sizeof(vector), H5T_BIT_MSB, 1);
 	if (n>=0) {
 	    H5_FAILED();
 	    printf ("    Unable to verify all-zero bits in destination "
@@ -695,7 +695,7 @@ test_set (void)
 	memset (v2, 0x00, sizeof v2);
 
 	/* Set some bits in v2 */
-	H5T_bit_set (v2, d_offset, size, TRUE);
+	H5T__bit_set (v2, d_offset, size, TRUE);
 	for (j=0; j<(int)sizeof(v2); j++) if (v2[j]) break;
 	if (size>0 && j>=(int)sizeof(v2)) {
 	    H5_FAILED();
@@ -710,7 +710,7 @@ test_set (void)
 
 
 	/* Look for the zeros and ones */
-	n = H5T_bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_LSB, 1);
+	n = H5T__bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_LSB, 1);
 	if (size>0 && n!=(ssize_t)d_offset) {
 	    H5_FAILED();
 	    printf ("    Unable to find first set bit in destination "
@@ -722,7 +722,7 @@ test_set (void)
 	    puts ("    Found set bits and shouldn't have!");
 	    goto failed;
 	}
-	n = H5T_bit_find (v2, d_offset, 8*sizeof(v2)-d_offset, H5T_BIT_LSB, 0);
+	n = H5T__bit_find (v2, d_offset, 8*sizeof(v2)-d_offset, H5T_BIT_LSB, 0);
 	if (d_offset+size<8*sizeof(v2) && n!=(ssize_t)size) {
 	    H5_FAILED();
 	    printf ("    Unable to find last set bit in destination "
@@ -739,7 +739,7 @@ test_set (void)
 	 * Look for zeros and ones in reverse order.  This is only to test
 	 * that reverse searches work as expected.
 	 */
-	n = H5T_bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_MSB, 1);
+	n = H5T__bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_MSB, 1);
 	if (size>0 && (size_t)(n+1)!=d_offset+size) {
 	    H5_FAILED();
 	    printf ("    Unable to find last set bit in destination "
@@ -751,7 +751,7 @@ test_set (void)
 	    puts ("    Found set bits but shouldn't have (reverse)!");
 	    goto failed;
 	}
-	n = H5T_bit_find (v2, (size_t)0, d_offset+size, H5T_BIT_MSB, 0);
+	n = H5T__bit_find (v2, (size_t)0, d_offset+size, H5T_BIT_MSB, 0);
 	if (d_offset>0 && n+1!=(ssize_t)d_offset) {
 	    H5_FAILED();
 	    printf ("    Unable to find beginning of set bit region "
@@ -812,7 +812,7 @@ test_clear (void)
 	memset (v2, 0xff, sizeof v2);
 
 	/* Clear some bits in v2 */
-	H5T_bit_set (v2, d_offset, size, FALSE);
+	H5T__bit_set (v2, d_offset, size, FALSE);
 	for (j=0; j<(int)sizeof(v2); j++) if (0xff!=v2[j]) break;
 	if (size>0 && j>=(int)sizeof(v2)) {
 	    H5_FAILED();
@@ -827,7 +827,7 @@ test_clear (void)
 
 
 	/* Look for the zeros and ones */
-	n = H5T_bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_LSB, 0);
+	n = H5T__bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_LSB, 0);
 	if (size>0 && n!=(ssize_t)d_offset) {
 	    H5_FAILED();
 	    printf ("    Unable to find first cleared bit in destination "
@@ -839,7 +839,7 @@ test_clear (void)
 	    puts ("    Found cleared bits and shouldn't have!");
 	    goto failed;
 	}
-	n = H5T_bit_find (v2, d_offset, 8*sizeof(v2)-d_offset, H5T_BIT_LSB, 1);
+	n = H5T__bit_find (v2, d_offset, 8*sizeof(v2)-d_offset, H5T_BIT_LSB, 1);
 	if (d_offset+size<8*sizeof(v2) && n!=(ssize_t)size) {
 	    H5_FAILED();
 	    printf ("    Unable to find last cleared bit in destination "
@@ -856,7 +856,7 @@ test_clear (void)
 	 * Look for zeros and ones in reverse order.  This is only to test
 	 * that reverse searches work as expected.
 	 */
-	n = H5T_bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_MSB, 0);
+	n = H5T__bit_find (v2, (size_t)0, 8*sizeof(v2), H5T_BIT_MSB, 0);
 	if (size>0 && (size_t)(n+1)!=d_offset+size) {
 	    H5_FAILED();
 	    printf ("    Unable to find last cleared bit in destination "
@@ -868,7 +868,7 @@ test_clear (void)
 	    puts ("    Found cleared bits but shouldn't have (reverse)!");
 	    goto failed;
 	}
-	n = H5T_bit_find (v2, (size_t)0, d_offset+size, H5T_BIT_MSB, 1);
+	n = H5T__bit_find (v2, (size_t)0, d_offset+size, H5T_BIT_MSB, 1);
 	if (d_offset>0 && n+1!=(ssize_t)d_offset) {
 	    H5_FAILED();
 	    printf ("    Unable to find beginning of cleared bit region "
diff --git a/test/cmpd_dset.c b/test/cmpd_dset.c
index d7f7842..433c488 100644
--- a/test/cmpd_dset.c
+++ b/test/cmpd_dset.c
@@ -2183,7 +2183,7 @@ main (int argc, char *argv[])
 	    fprintf(stderr, "usage: %s [--noopt]\n", argv[0]);
 	    exit(1);
 	}
-	H5Tunregister(H5T_PERS_DONTCARE, NULL, -1, -1, H5T_conv_struct_opt);
+	H5Tunregister(H5T_PERS_DONTCARE, NULL, -1, -1, H5T__conv_struct_opt);
     }
 
     /* Create the file */
diff --git a/test/dt_arith.c b/test/dt_arith.c
index 054f069..0001755 100644
--- a/test/dt_arith.c
+++ b/test/dt_arith.c
@@ -306,9 +306,9 @@ static int without_hardware_g = 0;
      *00000111,..., until 11111111.*/                                                           \
     memset(tmp1, 0, SRC_SIZE);                                                                  \
     memset(tmp2, 0, SRC_SIZE);                                                                  \
-    H5T_bit_set (tmp2, SRC_PREC-1, (size_t)1, TRUE);       /*the negative value*/                       \
+    H5T__bit_set (tmp2, SRC_PREC-1, (size_t)1, TRUE);       /*the negative value*/                       \
     for(n=0; n<SRC_MANT_DIG-1; n++) {                                                           \
-        H5T_bit_set (tmp1, n, (size_t)1, TRUE);            /*turn on 1 bit each time*/                  \
+        H5T__bit_set (tmp1, n, (size_t)1, TRUE);            /*turn on 1 bit each time*/                  \
         CHANGE_ORDER(tmp1, SRC_ORDR, SRC_SIZE);    /*change order for big endian*/              \
         memcpy(buf_p, tmp1, SRC_SIZE);                                                          \
         memcpy(saved_p, tmp1, SRC_SIZE);                                                        \
@@ -317,7 +317,7 @@ static int without_hardware_g = 0;
         saved_p += SRC_SIZE;                                                                    \
                                                                                                 \
         /*negative values*/                                                                     \
-        H5T_bit_set (tmp2, n, (size_t)1, TRUE);                                                         \
+        H5T__bit_set (tmp2, n, (size_t)1, TRUE);                                                         \
         CHANGE_ORDER(tmp2, SRC_ORDR, SRC_SIZE);                                                 \
         memcpy(buf_p, tmp2, SRC_SIZE);                                                          \
         memcpy(saved_p, tmp2, SRC_SIZE);                                                        \
@@ -353,7 +353,7 @@ static int without_hardware_g = 0;
     buf_p = BUF;                                                                                \
                                                                                                 \
     /* +0 */                                                                                    \
-    H5T_bit_set(value, (size_t)0, SRC_PREC, FALSE);                                                     \
+    H5T__bit_set(value, (size_t)0, SRC_PREC, FALSE);                                                     \
     memcpy(buf_p, value, SRC_SIZE*sizeof(unsigned char));                                       \
     buf_p += SRC_SIZE;                                                                          \
                                                                                                 \
@@ -361,7 +361,7 @@ static int without_hardware_g = 0;
         if(n==1) {                                                                              \
             memset(value, 0, SRC_SIZE*sizeof(unsigned char));                                   \
             /* -0 */                                                                            \
-            H5T_bit_set(value, (size_t)(SRC_PREC - 1), (size_t)1, TRUE);                                            \
+            H5T__bit_set(value, (size_t)(SRC_PREC - 1), (size_t)1, TRUE);                                            \
             CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE);/*change order for big endian*/             \
             HDmemcpy(buf_p, value, SRC_SIZE*sizeof(unsigned char));                               \
             CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE);/*change back the order for bit operation*/ \
@@ -369,21 +369,21 @@ static int without_hardware_g = 0;
         }                                                                                       \
                                                                                                 \
         /* +/-infinity */                                                                       \
-        H5T_bit_set(value, (size_t)(SRC_MANT_DIG - 1), SRC_PREC-SRC_MANT_DIG, TRUE);                        \
+        H5T__bit_set(value, (size_t)(SRC_MANT_DIG - 1), SRC_PREC-SRC_MANT_DIG, TRUE);                        \
         CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE);    /*change order for big endian*/             \
         HDmemcpy(buf_p, value, SRC_SIZE*sizeof(unsigned char));                                   \
         CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE);    /*change back the order for bit operation*/ \
         buf_p += SRC_SIZE;                                                                      \
                                                                                                 \
         /* +/-SNaN */                                                                           \
-        H5T_bit_set(value, (size_t)0, (size_t)1, TRUE);                                                         \
+        H5T__bit_set(value, (size_t)0, (size_t)1, TRUE);                                                         \
         CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE);    /*change order for big endian*/             \
         HDmemcpy(buf_p, value, SRC_SIZE * sizeof(unsigned char));                                   \
         CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE);    /*change back the order for bit operation*/ \
         buf_p += SRC_SIZE;                                                                      \
                                                                                                 \
         /* +/-QNaN */                                                                           \
-        H5T_bit_set(value, (size_t)(SRC_MANT_DIG - 2), (size_t)1, TRUE);                                            \
+        H5T__bit_set(value, (size_t)(SRC_MANT_DIG - 2), (size_t)1, TRUE);                                            \
         CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE);    /*change order for big endian*/             \
         HDmemcpy(buf_p, value, SRC_SIZE*sizeof(unsigned char));                                   \
         CHANGE_ORDER(value, SRC_ORDR, SRC_SIZE);    /*change back the order for bit operation*/ \
@@ -634,7 +634,7 @@ test_hard_query(void)
 
     /* Unregister the hard conversion from int to float.  Verify the conversion
      * is a soft conversion. */
-    H5Tunregister(H5T_PERS_HARD, NULL, H5T_NATIVE_INT, H5T_NATIVE_FLOAT, H5T_conv_int_float);
+    H5Tunregister(H5T_PERS_HARD, NULL, H5T_NATIVE_INT, H5T_NATIVE_FLOAT, H5T__conv_int_float);
     if(H5Tcompiler_conv(H5T_NATIVE_INT, H5T_NATIVE_FLOAT) != FALSE) {
         H5_FAILED();
         printf("Can't query conversion function\n");
@@ -643,7 +643,7 @@ test_hard_query(void)
 
     /* Register the hard conversion from int to float.  Verify the conversion
      * is a hard conversion. */
-    H5Tregister(H5T_PERS_HARD, "int_flt", H5T_NATIVE_INT, H5T_NATIVE_FLOAT, H5T_conv_int_float);
+    H5Tregister(H5T_PERS_HARD, "int_flt", H5T_NATIVE_INT, H5T_NATIVE_FLOAT, H5T__conv_int_float);
     if(H5Tcompiler_conv(H5T_NATIVE_INT, H5T_NATIVE_FLOAT) != TRUE) {
         H5_FAILED();
         printf("Can't query conversion function\n");
@@ -2337,92 +2337,92 @@ test_conv_int_1(const char *name, hid_t src, hid_t dst)
          */
         if (H5T_SGN_2==src_sign && H5T_SGN_2==dst_sign) {
             if (src_nbits>dst_nbits) {
-                if(0==H5T_bit_get_d(src_bits, src_nbits-1, (size_t)1) &&
-                        H5T_bit_find(src_bits, dst_nbits-1, (src_nbits-dst_nbits),
+                if(0==H5T__bit_get_d(src_bits, src_nbits-1, (size_t)1) &&
+                        H5T__bit_find(src_bits, dst_nbits-1, (src_nbits-dst_nbits),
                             H5T_BIT_MSB, 1)>=0) {
                     /*
                      * Source is positive and the magnitude is too large for
                      * the destination.  The destination should be set to the
                      * maximum possible value: 0x7f...f
                      */
-                    if (0==H5T_bit_get_d(dst_bits, dst_nbits-1, (size_t)1) &&
-                            H5T_bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 0) < 0)
+                    if (0==H5T__bit_get_d(dst_bits, dst_nbits-1, (size_t)1) &&
+                            H5T__bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 0) < 0)
                         continue; /*no error*/
-                } else if (1==H5T_bit_get_d(src_bits, src_nbits-1, (size_t)1) &&
-                       H5T_bit_find(src_bits, (size_t)0, src_nbits-1, H5T_BIT_MSB,
+                } else if (1==H5T__bit_get_d(src_bits, src_nbits-1, (size_t)1) &&
+                       H5T__bit_find(src_bits, (size_t)0, src_nbits-1, H5T_BIT_MSB,
                             0)+1>=(ssize_t)dst_nbits) {
                     /*
                      * Source is negative but the magnitude is too large for
                      * the destination. The destination should be set to the
                      * smallest possible value: 0x80...0
                      */
-                    if (1==H5T_bit_get_d(dst_bits, dst_nbits-1, (size_t)1) &&
-                            H5T_bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 1) < 0)
+                    if (1==H5T__bit_get_d(dst_bits, dst_nbits-1, (size_t)1) &&
+                            H5T__bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 1) < 0)
                         continue; /*no error*/
                 }
             } else if(src_nbits<dst_nbits) {
                 /* Source is smaller than the destination */
-                if(0==H5T_bit_get_d(src_bits, src_nbits-1, (size_t)1)) {
+                if(0==H5T__bit_get_d(src_bits, src_nbits-1, (size_t)1)) {
                     /*
                      * Source is positive, so the excess bits in the
                      * destination should be set to 0's.
                      */
-                    if (0==H5T_bit_get_d(dst_bits, src_nbits-1, (size_t)1) &&
-                            H5T_bit_find(dst_bits, src_nbits, dst_nbits-src_nbits, H5T_BIT_LSB, 1) < 0)
+                    if (0==H5T__bit_get_d(dst_bits, src_nbits-1, (size_t)1) &&
+                            H5T__bit_find(dst_bits, src_nbits, dst_nbits-src_nbits, H5T_BIT_LSB, 1) < 0)
                         continue; /*no error*/
                 } else {
                     /*
                      * Source is negative, so the excess bits in the
                      * destination should be set to 1's.
                      */
-                    if (1==H5T_bit_get_d(dst_bits, src_nbits-1, (size_t)1) &&
-                            H5T_bit_find(dst_bits, src_nbits, dst_nbits-src_nbits, H5T_BIT_LSB, 0) < 0)
+                    if (1==H5T__bit_get_d(dst_bits, src_nbits-1, (size_t)1) &&
+                            H5T__bit_find(dst_bits, src_nbits, dst_nbits-src_nbits, H5T_BIT_LSB, 0) < 0)
                         continue; /*no error*/
                 }
             }
         } else if (H5T_SGN_2==src_sign && H5T_SGN_NONE==dst_sign) {
-            if (H5T_bit_get_d(src_bits, src_nbits-1, (size_t)1)) {
+            if (H5T__bit_get_d(src_bits, src_nbits-1, (size_t)1)) {
                 /*
                  * The source is negative so the result should be zero.
                  * The source is negative if the most significant bit is
                  * set.  The destination is zero if all bits are zero.
                  */
-                if (H5T_bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 1) < 0)
+                if (H5T__bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 1) < 0)
                     continue; /*no error*/
             } else if (src_nbits>dst_nbits &&
-                   H5T_bit_find(src_bits, dst_nbits-1,
+                   H5T__bit_find(src_bits, dst_nbits-1,
                         src_nbits-dst_nbits, H5T_BIT_LSB, 1)>=0) {
                 /*
                  * The source is a value with a magnitude too large for
                  * the destination.  The destination should be the
                  * largest possible value: 0xff...f
                  */
-                if (H5T_bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 0) < 0)
+                if (H5T__bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 0) < 0)
                     continue; /*no error*/
             }
         } else if (H5T_SGN_NONE==src_sign && H5T_SGN_2==dst_sign) {
             if (src_nbits>=dst_nbits &&
-                    H5T_bit_find(src_bits, dst_nbits-1, (src_nbits-dst_nbits)+1,
+                    H5T__bit_find(src_bits, dst_nbits-1, (src_nbits-dst_nbits)+1,
                         H5T_BIT_LSB, 1)>=0) {
                 /*
                  * The source value has a magnitude that is larger than
                  * the destination can handle.  The destination should be
                  * set to the largest possible positive value: 0x7f...f
                  */
-                if (0==H5T_bit_get_d(dst_bits, dst_nbits-1, (size_t)1) &&
-                        H5T_bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 0) < 0)
+                if (0==H5T__bit_get_d(dst_bits, dst_nbits-1, (size_t)1) &&
+                        H5T__bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 0) < 0)
                     continue; /*no error*/
             }
         } else {
             if (src_nbits>dst_nbits &&
-                    H5T_bit_find(src_bits, dst_nbits, src_nbits-dst_nbits,
+                    H5T__bit_find(src_bits, dst_nbits, src_nbits-dst_nbits,
                          H5T_BIT_LSB, 1)>=0) {
                 /*
                  * The unsigned source has a value which is too large for
                  * the unsigned destination.  The destination should be
                  * set to the largest possible value: 0xff...f
                  */
-                if (H5T_bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 0) < 0)
+                if (H5T__bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 0) < 0)
                     continue; /*no error*/
             }
         }
@@ -2610,8 +2610,8 @@ error:
 /*-------------------------------------------------------------------------
  * Function:	test_conv_int_2
  *
- * Purpose:	Tests overlap calculates in H5T_conv_i_i(), which should be
- *		the same as for H5T_conv_f_f() and H5T_conv_s_s().
+ * Purpose:	Tests overlap calculates in H5T__conv_i_i(), which should be
+ *		the same as for H5T__conv_f_f() and H5T__conv_s_s().
  *
  * Return:	Success:	0
  *
@@ -2648,7 +2648,7 @@ test_conv_int_2(void)
 
 	    /*
 	     * Conversion. If overlap calculations aren't right then an
-	     * assertion will fail in H5T_conv_i_i()
+	     * assertion will fail in H5T__conv_i_i()
 	     */
 	    H5Tconvert(src_type, dst_type, (size_t)100, buf, NULL, H5P_DEFAULT);
 	    H5Tclose(src_type);
@@ -2788,8 +2788,8 @@ my_isinf(int endian, unsigned char *val, size_t size,
         bits[size-(i+1)] = *(val + ENDIAN(size, i, endian));
 #endif /*H5_VMS*/
 
-    if(H5T_bit_find(bits, mpos, msize, H5T_BIT_LSB, 1) < 0 &&
-            H5T_bit_find(bits, epos, esize, H5T_BIT_LSB, 0) < 0)
+    if(H5T__bit_find(bits, mpos, msize, H5T_BIT_LSB, 1) < 0 &&
+            H5T__bit_find(bits, epos, esize, H5T_BIT_LSB, 0) < 0)
         retval = 1;
 
     free(bits);
@@ -3321,7 +3321,7 @@ test_conv_flt_1 (const char *name, int run_test, hid_t src, hid_t dst)
                 }
             }
 
-            expo = H5T_bit_get_d(tmp, src_epos, src_esize);
+            expo = H5T__bit_get_d(tmp, src_epos, src_esize);
             if(expo==0)
                 continue;   /* Denormalized floating-point value detected */
             else {
@@ -3341,7 +3341,7 @@ test_conv_flt_1 (const char *name, int run_test, hid_t src, hid_t dst)
                     }
                 }
 
-                expo = H5T_bit_get_d(tmp, dst_epos, dst_esize);
+                expo = H5T__bit_get_d(tmp, dst_epos, dst_esize);
                 if(expo==0)
                     continue;   /* Denormalized floating-point value detected */
                 else {
@@ -4348,7 +4348,7 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst)
                     )
                 && (INT_SCHAR==dst_type || INT_SHORT==dst_type || INT_INT==dst_type
                 || INT_LONG==dst_type || INT_LLONG==dst_type)) {
-            if(0==H5T_bit_get_d(src_bits, src_nbits-1, (size_t)1) &&
+            if(0==H5T__bit_get_d(src_bits, src_nbits-1, (size_t)1) &&
                     overflows(src_bits, src, dst_nbits-1)) {
                 /*
                  * Source is positive and the magnitude is too large for
@@ -4356,15 +4356,15 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst)
                  * maximum possible value: 0x7f...f
                  */
                 if(!except_set) {
-                    if (0==H5T_bit_get_d(dst_bits, dst_nbits-1, (size_t)1) &&
-                            H5T_bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 0) < 0)
+                    if (0==H5T__bit_get_d(dst_bits, dst_nbits-1, (size_t)1) &&
+                            H5T__bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 0) < 0)
                         continue; /*no error*/
                 } else {
                     /* fill_value is small so we know only the 1st byte is set */
                     if (dst_bits[0] == fill_value)
                         continue; /*no error*/
                 }
-            } else if (1==H5T_bit_get_d(src_bits, src_nbits-1, (size_t)1) &&
+            } else if (1==H5T__bit_get_d(src_bits, src_nbits-1, (size_t)1) &&
                     overflows(src_bits, src, dst_nbits-1)) {
                 /*
                  * Source is negative but the magnitude is too large for
@@ -4372,8 +4372,8 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst)
                  * smallest possible value: 0x80...0
                  */
                 if(!except_set) {
-                    if (1==H5T_bit_get_d(dst_bits, dst_nbits-1, (size_t)1) &&
-                            H5T_bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 1) < 0)
+                    if (1==H5T__bit_get_d(dst_bits, dst_nbits-1, (size_t)1) &&
+                            H5T__bit_find(dst_bits, (size_t)0, dst_nbits-1, H5T_BIT_LSB, 1) < 0)
                         continue; /*no error*/
                 } else {
                     if (dst_bits[0] == fill_value)
@@ -4389,14 +4389,14 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst)
                 )
                 && (INT_UCHAR==dst_type || INT_USHORT==dst_type || INT_UINT==dst_type
                 || INT_ULONG==dst_type || INT_ULLONG==dst_type)) {
-            if (H5T_bit_get_d(src_bits, src_nbits-1, (size_t)1)) {
+            if (H5T__bit_get_d(src_bits, src_nbits-1, (size_t)1)) {
                 /*
                  * The source is negative so the result should be zero.
                  * The source is negative if the most significant bit is
                  * set.  The destination is zero if all bits are zero.
                  */
                 if(!except_set) {
-                    if (H5T_bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 1) < 0)
+                    if (H5T__bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 1) < 0)
                         continue; /*no error*/
                 } else {
                     if (dst_bits[0] == fill_value)
@@ -4409,7 +4409,7 @@ test_conv_int_fp(const char *name, int run_test, hid_t src, hid_t dst)
                  * largest possible value: 0xff...f
                  */
                 if(!except_set) {
-                    if (H5T_bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 0) < 0)
+                    if (H5T__bit_find(dst_bits, (size_t)0, dst_nbits, H5T_BIT_LSB, 0) < 0)
                         continue; /*no error*/
                 } else {
                     if (dst_bits[0] == fill_value)
@@ -4757,13 +4757,13 @@ overflows(unsigned char *origin_bits, hid_t src_id, size_t dst_num_bits)
     HDmemcpy(bits, origin_bits, src_prec/8+1);
 
     /*Check for special cases: +Inf, -Inf*/
-    if (H5T_bit_find (bits, mpos, mant_digits, H5T_BIT_LSB, TRUE) < 0) {
-        if (H5T_bit_find (bits, epos, expt_digits, H5T_BIT_LSB, FALSE) < 0) {
+    if (H5T__bit_find (bits, mpos, mant_digits, H5T_BIT_LSB, TRUE) < 0) {
+        if (H5T__bit_find (bits, epos, expt_digits, H5T_BIT_LSB, FALSE) < 0) {
             ret_value=TRUE;
             goto done;
         }
-    } else if (H5T_NORM_NONE==norm && H5T_bit_find (bits, mpos, mant_digits-1,
-        H5T_BIT_LSB, TRUE) < 0 && H5T_bit_find (bits, epos, expt_digits,
+    } else if (H5T_NORM_NONE==norm && H5T__bit_find (bits, mpos, mant_digits-1,
+        H5T_BIT_LSB, TRUE) < 0 && H5T__bit_find (bits, epos, expt_digits,
         H5T_BIT_LSB, FALSE) < 0) {
         /*This is a special case for the source of no implied mantissa bit.
          *If the exponent bits are all 1s and only the 1st bit of mantissa
@@ -4773,7 +4773,7 @@ overflows(unsigned char *origin_bits, hid_t src_id, size_t dst_num_bits)
     }
 
     /* get exponent */
-    expt = H5T_bit_get_d(bits, mant_digits, expt_digits) - bias;
+    expt = H5T__bit_get_d(bits, mant_digits, expt_digits) - bias;
 
     if(expt>=(dst_num_bits-1)) {
        ret_value=TRUE;
@@ -4781,19 +4781,19 @@ overflows(unsigned char *origin_bits, hid_t src_id, size_t dst_num_bits)
     }
 
     /* get significand */
-    H5T_bit_copy (mant_bits, (size_t)0, bits, (size_t)0, mant_digits);
+    H5T__bit_copy (mant_bits, (size_t)0, bits, (size_t)0, mant_digits);
 
 
     /* restore implicit bit if normalization is implied*/
     if(norm == H5T_NORM_IMPLIED) {
-        H5T_bit_inc(mant_bits, mant_digits, (size_t)1);
+        H5T__bit_inc(mant_bits, mant_digits, (size_t)1);
         mant_digits++;
     }
 
     /* shift significand */
-    H5T_bit_shift (mant_bits, (ssize_t)(expt-expt_digits), (size_t)0, (size_t)(32 * 8));
+    H5T__bit_shift (mant_bits, (ssize_t)(expt-expt_digits), (size_t)0, (size_t)(32 * 8));
 
-    indx = H5T_bit_find(mant_bits, (size_t)0, (size_t)(32 * 8), H5T_BIT_MSB, 1);
+    indx = H5T__bit_find(mant_bits, (size_t)0, (size_t)(32 * 8), H5T_BIT_MSB, 1);
 
     if((size_t)indx>=dst_num_bits)
         ret_value=TRUE;
diff --git a/test/external.c b/test/external.c
index 1dedeab..ae1008c 100644
--- a/test/external.c
+++ b/test/external.c
@@ -111,6 +111,7 @@ test_1a(hid_t file)
     char	name[256];		/*external file name		*/
     off_t	file_offset;		/*external file offset		*/
     hsize_t	file_size;		/*sizeof external file segment	*/
+    haddr_t     dset_addr;              /*address of dataset            */
 
     TESTING("fixed-size data space, exact storage");
 
@@ -130,7 +131,10 @@ test_1a(hid_t file)
     if((dset = H5Dopen2(file, "dset1", H5P_DEFAULT)) < 0) goto error;
 
     /* Test dataset address.  Should be undefined. */
-    if(H5Dget_offset(dset) != HADDR_UNDEF) goto error;
+    H5E_BEGIN_TRY {
+        dset_addr = H5Dget_offset(dset);
+    } H5E_END_TRY;
+    if(dset_addr != HADDR_UNDEF) goto error;
 
     if((dcpl = H5Dget_create_plist(dset)) < 0) goto error;
     if((n = H5Pget_external_count(dcpl)) < 0) goto error;
diff --git a/test/testfiles/error_test_1 b/test/testfiles/error_test_1
index 8d6e208..b322460 100644
--- a/test/testfiles/error_test_1
+++ b/test/testfiles/error_test_1
@@ -44,13 +44,13 @@ HDF5-DIAG: Error detected in HDF5 (version (number)) thread (IDs):
   #000: (file name) line (number) in H5Dread(): can't read data
     major: Dataset
     minor: Read failed
-  #001: (file name) line (number) in H5D_read(): can't read data
+  #001: (file name) line (number) in H5D__read(): can't read data
     major: Dataset
     minor: Read failed
-  #002: (file name) line (number) in H5D_chunk_read(): unable to read raw data chunk
+  #002: (file name) line (number) in H5D__chunk_read(): unable to read raw data chunk
     major: Low-level I/O
     minor: Read failed
-  #003: (file name) line (number) in H5D_chunk_lock(): data pipeline read failed
+  #003: (file name) line (number) in H5D__chunk_lock(): data pipeline read failed
     major: Data filters
     minor: Filter operation failed
   #004: (file name) line (number) in H5Z_pipeline(): required filter 'bogus' is not registered
diff --git a/test/tmisc.c b/test/tmisc.c
index 5539cee..6fcf557 100644
--- a/test/tmisc.c
+++ b/test/tmisc.c
@@ -3460,14 +3460,14 @@ test_misc20(void)
     CHECK(did, FAIL, "H5Dopen2");
 
     /* Get the layout version */
-    ret = H5D_layout_version_test(did,&version);
-    CHECK(ret, FAIL, "H5D_layout_version_test");
-    VERIFY(version, 3, "H5D_layout_version_test");
+    ret = H5D__layout_version_test(did,&version);
+    CHECK(ret, FAIL, "H5D__layout_version_test");
+    VERIFY(version, 3, "H5D__layout_version_test");
 
     /* Get the layout contiguous storage size */
-    ret = H5D_layout_contig_size_test(did,&contig_size);
-    CHECK(ret, FAIL, "H5D_layout_contig_size_test");
-    VERIFY(contig_size, (MISC20_SPACE_DIM0 * MISC20_SPACE_DIM1 * H5Tget_size(H5T_NATIVE_INT)), "H5D_layout_contig_size_test");
+    ret = H5D__layout_contig_size_test(did,&contig_size);
+    CHECK(ret, FAIL, "H5D__layout_contig_size_test");
+    VERIFY(contig_size, (MISC20_SPACE_DIM0 * MISC20_SPACE_DIM1 * H5Tget_size(H5T_NATIVE_INT)), "H5D__layout_contig_size_test");
 
     /* Close datasset */
     ret = H5Dclose(did);
@@ -3478,14 +3478,14 @@ test_misc20(void)
     CHECK(did, FAIL, "H5Dopen2");
 
     /* Get the layout version */
-    ret = H5D_layout_version_test(did,&version);
-    CHECK(ret, FAIL, "H5D_layout_version_test");
-    VERIFY(version, 3, "H5D_layout_version_test");
+    ret = H5D__layout_version_test(did,&version);
+    CHECK(ret, FAIL, "H5D__layout_version_test");
+    VERIFY(version, 3, "H5D__layout_version_test");
 
     /* Get the layout contiguous storage size */
-    ret = H5D_layout_contig_size_test(did,&contig_size);
-    CHECK(ret, FAIL, "H5D_layout_contig_size_test");
-    VERIFY(contig_size, (MISC20_SPACE2_DIM0 * MISC20_SPACE2_DIM1 * H5Tget_size(H5T_NATIVE_INT)), "H5D_layout_contig_size_test");
+    ret = H5D__layout_contig_size_test(did,&contig_size);
+    CHECK(ret, FAIL, "H5D__layout_contig_size_test");
+    VERIFY(contig_size, (MISC20_SPACE2_DIM0 * MISC20_SPACE2_DIM1 * H5Tget_size(H5T_NATIVE_INT)), "H5D__layout_contig_size_test");
 
     /* Close datasset */
     ret = H5Dclose(did);
@@ -3508,14 +3508,14 @@ test_misc20(void)
     CHECK(did, FAIL, "H5Dopen2");
 
     /* Get the layout version */
-    ret = H5D_layout_version_test(did,&version);
-    CHECK(ret, FAIL, "H5D_layout_version_test");
-    VERIFY(version, 2, "H5D_layout_version_test");
+    ret = H5D__layout_version_test(did,&version);
+    CHECK(ret, FAIL, "H5D__layout_version_test");
+    VERIFY(version, 2, "H5D__layout_version_test");
 
     /* Get the layout contiguous storage size */
-    ret = H5D_layout_contig_size_test(did,&contig_size);
-    CHECK(ret, FAIL, "H5D_layout_contig_size_test");
-    VERIFY(contig_size, (MISC20_SPACE_DIM0 * MISC20_SPACE_DIM1 * H5Tget_size(H5T_STD_I32LE)), "H5D_layout_contig_size_test");
+    ret = H5D__layout_contig_size_test(did,&contig_size);
+    CHECK(ret, FAIL, "H5D__layout_contig_size_test");
+    VERIFY(contig_size, (MISC20_SPACE_DIM0 * MISC20_SPACE_DIM1 * H5Tget_size(H5T_STD_I32LE)), "H5D__layout_contig_size_test");
 
     /* Close datasset */
     ret = H5Dclose(did);
@@ -4963,10 +4963,10 @@ test_misc28(void)
     CHECK(did, FAIL, "H5Dcreate2");
 
     /* Verify that the chunk cache is empty */
-    ret = H5D_current_cache_size_test(did, &nbytes_used, &nused);
-    CHECK(ret, FAIL, "H5D_current_cache_size_test");
-    VERIFY(nbytes_used, (size_t) 0, "H5D_current_cache_size_test");
-    VERIFY(nused, 0, "H5D_current_cache_size_test");
+    ret = H5D__current_cache_size_test(did, &nbytes_used, &nused);
+    CHECK(ret, FAIL, "H5D__current_cache_size_test");
+    VERIFY(nbytes_used, (size_t) 0, "H5D__current_cache_size_test");
+    VERIFY(nused, 0, "H5D__current_cache_size_test");
 
     /* Initialize write buffer */
     for(i=0; i<MISC28_SIZE; i++)
@@ -4984,10 +4984,10 @@ test_misc28(void)
     CHECK(ret, FAIL, "H5Dwrite");
 
     /* Verify that all 10 chunks written have been cached */
-    ret = H5D_current_cache_size_test(did, &nbytes_used, &nused);
-    CHECK(ret, FAIL, "H5D_current_cache_size_test");
-    VERIFY(nbytes_used, (size_t) MISC28_SIZE, "H5D_current_cache_size_test");
-    VERIFY(nused, MISC28_SIZE, "H5D_current_cache_size_test");
+    ret = H5D__current_cache_size_test(did, &nbytes_used, &nused);
+    CHECK(ret, FAIL, "H5D__current_cache_size_test");
+    VERIFY(nbytes_used, (size_t) MISC28_SIZE, "H5D__current_cache_size_test");
+    VERIFY(nused, MISC28_SIZE, "H5D__current_cache_size_test");
 
     /* Initialize write buffer */
     for(i=0; i<MISC28_SIZE; i++)
@@ -5003,10 +5003,10 @@ test_misc28(void)
     CHECK(ret, FAIL, "H5Dwrite");
 
     /* Verify that the size of the cache remains at 10 */
-    ret = H5D_current_cache_size_test(did, &nbytes_used, &nused);
-    CHECK(ret, FAIL, "H5D_current_cache_size_test");
-    VERIFY(nbytes_used, (size_t) MISC28_SIZE, "H5D_current_cache_size_test");
-    VERIFY(nused, MISC28_SIZE, "H5D_current_cache_size_test");
+    ret = H5D__current_cache_size_test(did, &nbytes_used, &nused);
+    CHECK(ret, FAIL, "H5D__current_cache_size_test");
+    VERIFY(nbytes_used, (size_t) MISC28_SIZE, "H5D__current_cache_size_test");
+    VERIFY(nused, MISC28_SIZE, "H5D__current_cache_size_test");
 
     /* Close dataset */
     ret = H5Dclose(did);
@@ -5018,10 +5018,10 @@ test_misc28(void)
     CHECK(did, FAIL, "H5Dopen2");
 
     /* Verify that the chunk cache is empty */
-    ret = H5D_current_cache_size_test(did, &nbytes_used, &nused);
-    CHECK(ret, FAIL, "H5D_current_cache_size_test");
-    VERIFY(nbytes_used, (size_t) 0, "H5D_current_cache_size_test");
-    VERIFY(nused, 0, "H5D_current_cache_size_test");
+    ret = H5D__current_cache_size_test(did, &nbytes_used, &nused);
+    CHECK(ret, FAIL, "H5D__current_cache_size_test");
+    VERIFY(nbytes_used, (size_t) 0, "H5D__current_cache_size_test");
+    VERIFY(nused, 0, "H5D__current_cache_size_test");
 
     /* Select hyperslabe for reading */
     start[1] = 0;
@@ -5037,10 +5037,10 @@ test_misc28(void)
         VERIFY(buf[i], i, "H5Dread");
 
     /* Verify that all 10 chunks read have been cached */
-    ret = H5D_current_cache_size_test(did, &nbytes_used, &nused);
-    CHECK(ret, FAIL, "H5D_current_cache_size_test");
-    VERIFY(nbytes_used, (size_t) MISC28_SIZE, "H5D_current_cache_size_test");
-    VERIFY(nused, MISC28_SIZE, "H5D_current_cache_size_test");
+    ret = H5D__current_cache_size_test(did, &nbytes_used, &nused);
+    CHECK(ret, FAIL, "H5D__current_cache_size_test");
+    VERIFY(nbytes_used, (size_t) MISC28_SIZE, "H5D__current_cache_size_test");
+    VERIFY(nused, MISC28_SIZE, "H5D__current_cache_size_test");
 
     /* Select new hyperslab */
     start[1] = 1;
@@ -5056,10 +5056,10 @@ test_misc28(void)
         VERIFY(buf[i], MISC28_SIZE - 1 - i, "H5Dread");
 
     /* Verify that the size of the cache remains at 10 */
-    ret = H5D_current_cache_size_test(did, &nbytes_used, &nused);
-    CHECK(ret, FAIL, "H5D_current_cache_size_test");
-    VERIFY(nbytes_used, (size_t) MISC28_SIZE, "H5D_current_cache_size_test");
-    VERIFY(nused, MISC28_SIZE, "H5D_current_cache_size_test");
+    ret = H5D__current_cache_size_test(did, &nbytes_used, &nused);
+    CHECK(ret, FAIL, "H5D__current_cache_size_test");
+    VERIFY(nbytes_used, (size_t) MISC28_SIZE, "H5D__current_cache_size_test");
+    VERIFY(nused, MISC28_SIZE, "H5D__current_cache_size_test");
 
     /* Close dataset */
     ret = H5Dclose(did);