[svn-r14902] Merged fortran_1_8 branch changes r14505:14901 into the trunk. New fortran wrappers added.

5 files changed, 1040 insertions, 1132 deletions

diff --git a/tools/lib/h5diff.c b/tools/lib/h5diff.c
index 9d64e44..4f4074f 100644
--- a/tools/lib/h5diff.c
+++ b/tools/lib/h5diff.c
@@ -47,7 +47,7 @@
 int
 print_objname (diff_opt_t * options, hsize_t nfound)
 {
-    return ((options->m_verbose || nfound) && !options->m_quiet) ? 1 : 0;
+ return ((options->m_verbose || nfound) && !options->m_quiet) ? 1 : 0;
 }
 
 /*-------------------------------------------------------------------------
@@ -186,17 +186,15 @@ hsize_t h5diff(const char *fname1,
                const char *objname2,
                diff_opt_t *options)
 {
-    trav_info_t  *info1=NULL;
-    trav_info_t  *info2=NULL;
-    hid_t        file1_id = (-1);
-    hid_t        file2_id = (-1);
+    trav_info_t  *info1;
+    trav_info_t  *info2;
+    hid_t        file1_id = (-1), file2_id = (-1);
     char         filenames[2][1024];
     hsize_t      nfound = 0;
 
     HDmemset(filenames, 0, 1024 * 2);
 
-    if(options->m_quiet && (options->m_verbose || options->m_report)) 
-    {
+    if(options->m_quiet && (options->m_verbose || options->m_report)) {
         printf("Error: -q (quiet mode) cannot be added to verbose or report modes\n");
         options->err_stat=1;
         return 0;
@@ -208,11 +206,9 @@ hsize_t h5diff(const char *fname1,
     */
 
     /* disable error reporting */
-    H5E_BEGIN_TRY 
-    {
-        /* open the files */
-        if((file1_id = H5Fopen(fname1, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0) 
-        {
+    H5E_BEGIN_TRY {
+        /* Open the files */
+        if((file1_id = H5Fopen(fname1, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0) {
             printf("h5diff: <%s>: unable to open file\n", fname1);
             options->err_stat = 1;
 
@@ -223,8 +219,7 @@ hsize_t h5diff(const char *fname1,
 #endif
             goto out;
         } /* end if */
-        if((file2_id = H5Fopen(fname2, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0) 
-        {
+        if((file2_id = H5Fopen(fname2, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0) {
             printf("h5diff: <%s>: unable to open file\n", fname2);
             options->err_stat = 1;
 
@@ -260,12 +255,11 @@ hsize_t h5diff(const char *fname1,
         goto out;
     } /* end if */
 
-   /*-------------------------------------------------------------------------
+    /*-------------------------------------------------------------------------
     * object name was supplied
     *-------------------------------------------------------------------------
     */
-    if( objname1 ) 
-    {
+    if(objname1) {
 #ifdef H5_HAVE_PARALLEL
         if(g_Parallel)
             /* Let tasks know that they won't be needed */
@@ -273,31 +267,22 @@ hsize_t h5diff(const char *fname1,
 #endif
         assert(objname2);
         options->cmn_objs = 1; /* eliminate warning */
-        nfound = diff_compare(file1_id, 
-                              fname1, 
-                              objname1, 
-                              info1,
-                              file2_id, 
-                              fname2, 
-                              objname2, 
-                              info2,
+        nfound = diff_compare(file1_id, fname1, objname1, info1,
+                              file2_id, fname2, objname2, info2,
                               options);
     } /* end if */
 
-   /*-------------------------------------------------------------------------
+    /*-------------------------------------------------------------------------
     * compare all
     *-------------------------------------------------------------------------
     */
 
-    else 
-    {
+    else {
 #ifdef H5_HAVE_PARALLEL
-        if(g_Parallel) 
-        {
+        if(g_Parallel) {
             int i;
 
-            if((HDstrlen(fname1) > 1024) || (HDstrlen(fname2) > 1024)) 
-            {
+            if((HDstrlen(fname1) > 1024) || (HDstrlen(fname2) > 1024)) {
                 fprintf(stderr, "The parallel diff only supports path names up to 1024 characters\n");
                 MPI_Abort(MPI_COMM_WORLD, 0);
             } /* end if */
@@ -310,12 +295,7 @@ hsize_t h5diff(const char *fname1,
                 MPI_Send(filenames, (1024 * 2), MPI_CHAR, i, MPI_TAG_PARALLEL, MPI_COMM_WORLD);
         } /* end if */
 #endif
-
-        nfound = diff_match(file1_id, 
-                            info1, 
-                            file2_id, 
-                            info2, 
-                            options);
+        nfound = diff_match(file1_id, info1, file2_id, info2, options);
     } /* end else */
 
     trav_info_free(info1);
@@ -323,8 +303,7 @@ hsize_t h5diff(const char *fname1,
 
 out:
     /* close */
-    H5E_BEGIN_TRY 
-    {
+    H5E_BEGIN_TRY {
         H5Fclose(file1_id);
         H5Fclose(file2_id);
     } H5E_END_TRY;
@@ -353,23 +332,22 @@ out:
  *-------------------------------------------------------------------------
  */
 hsize_t diff_match(hid_t file1_id,
-                   trav_info_t *info1,
-                   hid_t file2_id,
-                   trav_info_t *info2,
-                   diff_opt_t *options)
+                    trav_info_t * info1,
+                    hid_t file2_id,
+                    trav_info_t * info2,
+                    diff_opt_t * options)
 {
     trav_table_t *table = NULL;
-    size_t       curr1;
-    size_t       curr2;
-    unsigned     infile[2];
-    hsize_t      nfound = 0;
-    unsigned     i;
+    size_t curr1, curr2;
+    unsigned infile[2];
+    hsize_t nfound = 0;
+    unsigned i;
 
     /*-------------------------------------------------------------------------
     * build the list
     *-------------------------------------------------------------------------
     */
-    trav_table_init( &table );
+    trav_table_init(&table);
 
     curr1 = 0;
     curr2 = 0;
@@ -415,12 +393,11 @@ hsize_t diff_match(hid_t file1_id,
         curr2++;
     } /* end while */
 
-   /*-------------------------------------------------------------------------
+    /*-------------------------------------------------------------------------
     * print the list
     *-------------------------------------------------------------------------
     */
-    if(options->m_verbose) 
-    {
+    if(options->m_verbose) {
         printf("\n");
         printf("file1     file2\n");
         printf("---------------------------------------\n");
@@ -725,64 +702,59 @@ hsize_t diff_match(hid_t file1_id,
  *-------------------------------------------------------------------------
  */
 
-hsize_t diff_compare(hid_t file1_id,
-                     const char *file1_name,
-                     const char *obj1_name,
-                     trav_info_t *info1,
-                     hid_t file2_id,
-                     const char *file2_name,
-                     const char *obj2_name,
-                     trav_info_t *info2,
-                     diff_opt_t *options)
+hsize_t diff_compare (hid_t file1_id,
+                      const char *file1_name,
+                      const char *obj1_name,
+                      trav_info_t * info1,
+                      hid_t file2_id,
+                      const char *file2_name,
+                      const char *obj2_name,
+                      trav_info_t * info2,
+                      diff_opt_t * options)
 {
-    int     f1 = 0;
-    int     f2 = 0;
-    hsize_t nfound = 0;
-    
-    ssize_t i = h5trav_getindex (info1, obj1_name);
-    ssize_t j = h5trav_getindex (info2, obj2_name);
-    
-    if (i == -1)
-    {
-        parallel_print ("Object <%s> could not be found in <%s>\n", obj1_name,
-            file1_name);
-        f1 = 1;
-    }
-    if (j == -1)
-    {
-        parallel_print ("Object <%s> could not be found in <%s>\n", obj2_name,
-            file2_name);
-        f2 = 1;
-    }
-    if (f1 || f2)
-    {
-        options->err_stat = 1;
-        return 0;
-    }
-    
-    /* use the name with "/" first, as obtained by iterator function */
-    obj1_name = info1->paths[i].path;
-    obj2_name = info2->paths[j].path;
-    
-    /* objects are not the same type */
-    if (info1->paths[i].type != info2->paths[j].type)
-    {
-        if (options->m_verbose)
-            parallel_print("Comparison not possible: <%s> is of type %s and <%s> is of type %s\n",
-            obj1_name, get_type(info1->paths[i].type), obj2_name,
-            get_type(info2->paths[j].type));
-        options->not_cmp=1;
-        return 0;
-    }
-    
-    nfound = diff(file1_id, 
-                  obj1_name, 
-                  file2_id, 
-                  obj2_name, 
-                  options, 
-                  info1->paths[i].type);
-    
-    return nfound;
+ int f1 = 0, f2 = 0;
+ hsize_t nfound = 0;
+
+ ssize_t i = h5trav_getindex (info1, obj1_name);
+ ssize_t j = h5trav_getindex (info2, obj2_name);
+
+ if (i == -1)
+ {
+  parallel_print ("Object <%s> could not be found in <%s>\n", obj1_name,
+   file1_name);
+  f1 = 1;
+ }
+ if (j == -1)
+ {
+  parallel_print ("Object <%s> could not be found in <%s>\n", obj2_name,
+   file2_name);
+  f2 = 1;
+ }
+ if (f1 || f2)
+ {
+  options->err_stat = 1;
+  return 0;
+ }
+
+ /* use the name with "/" first, as obtained by iterator function */
+ obj1_name = info1->paths[i].path;
+ obj2_name = info2->paths[j].path;
+
+ /* objects are not the same type */
+ if (info1->paths[i].type != info2->paths[j].type)
+ {
+  if (options->m_verbose)
+   parallel_print("Comparison not possible: <%s> is of type %s and <%s> is of type %s\n",
+     obj1_name, get_type(info1->paths[i].type), obj2_name,
+     get_type(info2->paths[j].type));
+  options->not_cmp=1;
+  return 0;
+ }
+
+ nfound =
+  diff (file1_id, obj1_name, file2_id, obj2_name, options, info1->paths[i].type);
+
+ return nfound;
 }
 
 
@@ -812,15 +784,14 @@ hsize_t diff(hid_t file1_id,
               diff_opt_t * options, 
               h5trav_type_t type)
 {
-    hid_t   type1_id = (-1);
-    hid_t   type2_id = (-1);
-    hid_t   grp1_id = (-1);
-    hid_t   grp2_id = (-1);
-    int     ret;
+    hid_t       type1_id = (-1);
+    hid_t       type2_id = (-1);
+    hid_t       grp1_id = (-1);
+    hid_t       grp2_id = (-1);
+    int ret;
     hsize_t nfound = 0;
     
-    switch(type) 
-    {
+    switch(type) {
        /*-------------------------------------------------------------------------
         * H5TRAV_TYPE_DATASET
         *-------------------------------------------------------------------------
@@ -830,8 +801,7 @@ hsize_t diff(hid_t file1_id,
             * verbose, always print name
             *-------------------------------------------------------------------------
             */
-            if(options->m_verbose) 
-            {
+            if(options->m_verbose) {
                 if(print_objname(options, (hsize_t)1))
                     do_print_objname("dataset", path1, path2);
                 nfound = diff_dataset(file1_id, file2_id, path1, path2, options);
@@ -843,18 +813,15 @@ hsize_t diff(hid_t file1_id,
             * disabling quiet mode
             *-------------------------------------------------------------------------
             */
-            else 
-            {
-                if(options->m_quiet == 0) 
-                {
+            else {
+                if(options->m_quiet == 0) {
                     /* shut up temporarily */
                     options->m_quiet = 1;
                     nfound = diff_dataset(file1_id, file2_id, path1, path2, options);
 
                     /* print again */
                     options->m_quiet = 0;
-                    if(nfound) 
-                    {
+                    if(nfound) {
                         if(print_objname(options,nfound))
                             do_print_objname("dataset", path1, path2);
                         nfound = diff_dataset(file1_id, file2_id, path1, path2, options);
diff --git a/tools/lib/h5diff_array.c b/tools/lib/h5diff_array.c
index c5646ed..008b6b9 100644
--- a/tools/lib/h5diff_array.c
+++ b/tools/lib/h5diff_array.c
@@ -119,7 +119,7 @@ static int   not_comparable;
     is_zero=1;                                       \
 }
 
-#define PDIFF(a,b)      ( (b>a) ? (b-a) : (a-b))
+#   define PDIFF(a,b)		( (b>a) ? (b-a) : (a-b))
 
 /*-------------------------------------------------------------------------
  * local prototypes
@@ -127,12 +127,11 @@ static int   not_comparable;
  */
 static hsize_t diff_region(hid_t obj1_id, hid_t obj2_id,hid_t region1_id, hid_t region2_id, diff_opt_t *options);
 static hbool_t all_zero(const void *_mem, size_t size);
+static int     ull2float(unsigned long_long ull_value, float *f_value);
 static hsize_t character_compare(unsigned char *mem1,unsigned char *mem2,hsize_t i,int rank,hsize_t *dims,hsize_t *acc,hsize_t *pos,diff_opt_t *options,const char *obj1,const char *obj2,int *ph);
 static hsize_t character_compare_opt(unsigned char *mem1,unsigned char *mem2,hsize_t i,int rank,hsize_t *dims,hsize_t *acc,hsize_t *pos,diff_opt_t *options,const char *obj1,const char *obj2,int *ph);
 static hbool_t equal_float(float value, float expected);
 static hbool_t equal_double(double value, double expected);
-static int     ull2float(unsigned long_long ull_value, float *f_value);
-
 
 /*-------------------------------------------------------------------------
  * NaN detection
@@ -267,6 +266,8 @@ hsize_t diff_array( void *_mem1,
     size_t        size;              /* size of datum */
     unsigned char *mem1 = (unsigned char*)_mem1;
     unsigned char *mem2 = (unsigned char*)_mem2;
+    unsigned char *tmp1;
+    unsigned char *tmp2;
     hsize_t       acc[32];    /* accumulator position */
     hsize_t       pos[32];    /* matrix position */
     int           ph=1;       /* print header  */
@@ -287,26 +288,23 @@ hsize_t diff_array( void *_mem1,
     
     if(H5Tis_variable_str(m_type))
     {
-        for ( i = 0; i < nelmts; i++)
-        {
-            nfound+=diff_datum(
-                ((unsigned char**)mem1)[(size_t)i],
-                ((unsigned char**)mem2)[(size_t)i],
-                m_type,
-                i,
-                rank,
-                dims,
-                acc,
-                pos,
-                options,
-                name1,
-                name2,
-                container1_id,
-                container2_id,
-                &ph);
-            if (options->n && nfound>=options->count)
-                return nfound;
-        } /* i */
+        tmp1 = ((unsigned char**)mem1)[0];
+        tmp2 = ((unsigned char**)mem2)[0];
+        nfound+=diff_datum(
+            tmp1,
+            tmp2,
+            m_type,
+            (hsize_t)0,
+            rank,
+            dims,
+            acc,
+            pos,
+            options,
+            name1,
+            name2,
+            container1_id,
+            container2_id,
+            &ph);
     }
     
     else
@@ -517,35 +515,42 @@ hsize_t diff_datum(void       *_mem1,
     case H5T_STRING:
 
         {
+            
             H5T_str_t pad;
             char      *s;
             
-            /* Get pointer to first string to compare */
-            s = (char *)mem1;
-
-            /* check for NULL pointer for string */
-            if(s!=NULL)
+            if(H5Tis_variable_str(m_type))
             {
-                if(H5Tis_variable_str(m_type))
+               /* mem1 is the pointer into the struct where a `char*' is stored. So we have
+                * to dereference the pointer to get the `char*' to pass to HDstrlen(). */
+                s = *(char**)mem1;
+                if(s!=NULL)
                     size = HDstrlen(s);
-                else
-                    size = H5Tget_size(m_type);
-                
-                pad = H5Tget_strpad(m_type);
+            }
+            else
+            {
+                s = (char *)mem1;
+                size = H5Tget_size(m_type);
+            }
+            
+            pad = H5Tget_strpad(m_type);
             
+            /* check for NULL pointer for string */
+            if(s!=NULL)
+            {
                 for (u=0; u<size && (s[u] || pad!=H5T_STR_NULLTERM); u++)
                     nfound+=character_compare(
-                        mem1 + u,
-                        mem2 + u, /* offset */
-                        i,        /* index position */
-                        rank,
-                        dims,
-                        acc,
-                        pos,
-                        options,
-                        obj1,
-                        obj2,
-                        ph);
+                    mem1 + u,
+                    mem2 + u, /* offset */
+                    i,        /* index position */
+                    rank,
+                    dims,
+                    acc,
+                    pos,
+                    options,
+                    obj1,
+                    obj2,
+                    ph);
             }
                 
         }
@@ -692,6 +697,7 @@ hsize_t diff_datum(void       *_mem1,
             H5Tclose(memb_type);
         }
         break;
+        
    
         
    /*-------------------------------------------------------------------------
@@ -2861,6 +2867,7 @@ hsize_t diff_float(unsigned char *mem1,
 }
 
 
+
 /*-------------------------------------------------------------------------
  * Function: diff_double
  *
@@ -2890,111 +2897,80 @@ hsize_t diff_double(unsigned char *mem1,
     hsize_t     i;
     double      per;
     int         both_zero;
-    int         isnan1;
-    int         isnan2;
     
-
- /*-------------------------------------------------------------------------
-  * -d and !-p 
-  *-------------------------------------------------------------------------
-  */
- 
+    
+    /* -d and !-p */
     if (options->d && !options->p)
     {
+        
         for ( i = 0; i < nelmts; i++)
         {
             memcpy(&temp1_double, mem1, sizeof(double));
             memcpy(&temp2_double, mem2, sizeof(double));
-
-           /*-------------------------------------------------------------------------
-            * detect NaNs
-            *-------------------------------------------------------------------------
-            */
-            isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
-            isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
-
-            if ( !isnan1 && !isnan2)
-            {             
-                if (ABS(temp1_double-temp2_double) > options->delta)
+            
+            if (ABS(temp1_double-temp2_double) > options->delta)
+            {
+                if ( print_data(options) )
                 {
-                    if ( print_data(options) )
-                    {
-                        print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                        parallel_print(SPACES);
-                        parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
-                    }
-                    nfound++;
+                    print_pos(ph,0,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+                    parallel_print(SPACES);
+                    parallel_print(F_FORMAT,temp1_double,temp2_double,ABS(temp1_double-temp2_double));
                 }
-            } /* NaN */
+                nfound++;
+            }
             mem1+=sizeof(double);
             mem2+=sizeof(double);
             if (options->n && nfound>=options->count)
                 return nfound;
-        } /* i */
+        }
     }
-
- /*-------------------------------------------------------------------------
-  * !-d and -p 
-  *-------------------------------------------------------------------------
-  */
+    
+    /* !-d and -p */
     else if (!options->d && options->p)
     {
+        
         for ( i = 0; i < nelmts; i++)
         {
             memcpy(&temp1_double, mem1, sizeof(double));
             memcpy(&temp2_double, mem2, sizeof(double));
             
-           /*-------------------------------------------------------------------------
-            * detect NaNs
-            *-------------------------------------------------------------------------
-            */
-            isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
-            isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+            PER(temp1_double,temp2_double);
             
-            if ( !isnan1 && !isnan2)
-            {        
-                
-                PER(temp1_double,temp2_double);
+            if (not_comparable && !both_zero) /* not comparable */
+            {
+                if ( print_data(options) )
+                {
+                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+                    parallel_print(SPACES);
+                    parallel_print(F_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
+                        ABS(temp1_double-temp2_double));
+                }
+                options->not_cmp=1;
+                nfound++;
+            }
+            
+            else
                 
-                if (not_comparable && !both_zero) /* not comparable */
+                if ( per > options->percent )
                 {
                     if ( print_data(options) )
                     {
                         print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
-                            ABS(temp1_double-temp2_double));
+                        parallel_print(F_FORMAT_P,temp1_double,temp2_double,
+                            ABS(temp1_double-temp2_double),
+                            ABS(1-temp2_double/temp1_double));
                     }
-                    options->not_cmp=1;
                     nfound++;
                 }
-                
-                else
-                    
-                    if ( per > options->percent )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(F_FORMAT_P,temp1_double,temp2_double,
-                                ABS(temp1_double-temp2_double),
-                                ABS(1-temp2_double/temp1_double));
-                        }
-                        nfound++;
-                    }
-            } /* NaN */
-            mem1+=sizeof(double);
-            mem2+=sizeof(double);
-            if (options->n && nfound>=options->count)
-                return nfound;
-        } /* i */
+                mem1+=sizeof(double);
+                mem2+=sizeof(double);
+                if (options->n && nfound>=options->count)
+                    return nfound;
+        }
     }
     
- /*-------------------------------------------------------------------------
-  * -d and -p 
-  *-------------------------------------------------------------------------
-  */
+    /* -d and -p */
     else if ( options->d && options->p)
     {
         
@@ -3003,58 +2979,41 @@ hsize_t diff_double(unsigned char *mem1,
             memcpy(&temp1_double, mem1, sizeof(double));
             memcpy(&temp2_double, mem2, sizeof(double));
             
-            /*-------------------------------------------------------------------------
-            * detect NaNs
-            *-------------------------------------------------------------------------
-            */
-            isnan1 = my_isnan(FLT_DOUBLE,&temp1_double);
-            isnan2 = my_isnan(FLT_DOUBLE,&temp2_double);
+            PER(temp1_double,temp2_double);
             
-            if ( !isnan1 && !isnan2)
-            {        
-                
-                PER(temp1_double,temp2_double);
+            if (not_comparable && !both_zero) /* not comparable */
+            {
+                if ( print_data(options) )
+                {
+                    print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
+                    parallel_print(SPACES);
+                    parallel_print(F_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
+                        ABS(temp1_double-temp2_double));
+                }
+                options->not_cmp=1;
+                nfound++;
+            }
+            
+            else
                 
-                if (not_comparable && !both_zero) /* not comparable */
+                if ( per > options->percent && ABS(temp1_double-temp2_double) > options->delta )
                 {
                     if ( print_data(options) )
                     {
                         print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
                         parallel_print(SPACES);
-                        parallel_print(F_FORMAT_P_NOTCOMP,temp1_double,temp2_double,
-                            ABS(temp1_double-temp2_double));
+                        parallel_print(F_FORMAT_P,temp1_double,temp2_double,
+                            ABS(temp1_double-temp2_double),
+                            ABS(1-temp2_double/temp1_double));
                     }
-                    options->not_cmp=1;
                     nfound++;
                 }
-                
-                else
-                    
-                    if ( per > options->percent && ABS(temp1_double-temp2_double) > options->delta )
-                    {
-                        if ( print_data(options) )
-                        {
-                            print_pos(ph,1,hyper_start+i,acc,pos,rank,dims,obj1,obj2);
-                            parallel_print(SPACES);
-                            parallel_print(F_FORMAT_P,temp1_double,temp2_double,
-                                ABS(temp1_double-temp2_double),
-                                ABS(1-temp2_double/temp1_double));
-                        }
-                        nfound++;
-                    }
-                    
-            } /* NaN */
-            mem1+=sizeof(double);
-            mem2+=sizeof(double);
-            if (options->n && nfound>=options->count)
-                return nfound;
-        } /* i */
+                mem1+=sizeof(double);
+                mem2+=sizeof(double);
+                if (options->n && nfound>=options->count)
+                    return nfound;
+        }
     }
-
- /*-------------------------------------------------------------------------
-  * no -d and -p 
-  *-------------------------------------------------------------------------
-  */
     else
     {
         
@@ -3085,9 +3044,6 @@ hsize_t diff_double(unsigned char *mem1,
     return nfound;
 }
 
-
-
-
 /*-------------------------------------------------------------------------
  * Function: diff_schar
  *
diff --git a/tools/lib/h5diff_dset.c b/tools/lib/h5diff_dset.c
index 3f4e6a3..ea833db 100644
--- a/tools/lib/h5diff_dset.c
+++ b/tools/lib/h5diff_dset.c
@@ -19,6 +19,33 @@
 #include "h5tools.h"
 
 /*-------------------------------------------------------------------------
+ * Function: print_size
+ *
+ * Purpose: print dimensions 
+ *
+ *-------------------------------------------------------------------------
+ */
+#if defined (H5DIFF_DEBUG)
+static void
+print_size (int rank, hsize_t *dims)
+{
+    int i;
+
+    parallel_print("[" );
+    for ( i = 0; i < rank-1; i++)
+    {
+        parallel_print("%"H5_PRINTF_LL_WIDTH"u", (unsigned long_long)dims[i]);
+        parallel_print("x");
+    }
+    parallel_print("%"H5_PRINTF_LL_WIDTH"u", (unsigned long_long)dims[rank-1]);
+    parallel_print("]\n" );
+    
+}
+#endif /* H5DIFF_DEBUG */
+
+
+
+/*-------------------------------------------------------------------------
  * Function: diff_dataset
  *
  * Purpose: check for comparable datasets and read into a compatible
@@ -38,85 +65,79 @@ hsize_t diff_dataset( hid_t file1_id,
                       const char *obj2_name,
                       diff_opt_t *options)
 {
-    hid_t   did1 = -1;
-    hid_t   did2 = -1;
-    hid_t   dcpl1 = -1;
-    hid_t   dcpl2 = -1;
-    hsize_t nfound = 0;
-    
-   /*-------------------------------------------------------------------------
-    * open the handles
-    *-------------------------------------------------------------------------
-    */
-    /* disable error reporting */
-    H5E_BEGIN_TRY 
-    {
-        /* open the datasets */
-        if((did1 = H5Dopen2(file1_id, obj1_name, H5P_DEFAULT)) < 0) 
-        {
-            printf("Cannot open dataset <%s>\n", obj1_name);
-            goto error;
-        }
-        
-        if((did2 = H5Dopen2(file2_id, obj2_name, H5P_DEFAULT)) < 0) 
-        {
-            printf("Cannot open dataset <%s>\n", obj2_name);
-            goto error;
-        }
-        /* enable error reporting */
-    } H5E_END_TRY;
-    
-    
-    if ((dcpl1 = H5Dget_create_plist(did1)) < 0)
-        goto error;
-    if ((dcpl2 = H5Dget_create_plist(did2)) < 0)
-        goto error;
-    
-   /*-------------------------------------------------------------------------
-    * check if the dataset creation property list has filters that
-    * are not registered in the current configuration
-    * 1) the external filters GZIP and SZIP might not be available
-    * 2) the internal filters might be turned off
-    *-------------------------------------------------------------------------
-    */
-    if ((h5tools_canreadf((options->m_verbose?obj1_name:NULL),dcpl1)==1) &&
-        (h5tools_canreadf((options->m_verbose?obj2_name:NULL),dcpl2)==1))
-    {
-        nfound=diff_datasetid(did1,
-            did2,
-            obj1_name,
-            obj2_name,
-            options);
-    }
-   /*-------------------------------------------------------------------------
-    * close
-    *-------------------------------------------------------------------------
-    */
-    /* disable error reporting */
-    H5E_BEGIN_TRY 
-    {
-        H5Pclose(dcpl1);
-        H5Pclose(dcpl2);
-        H5Dclose(did1);
-        H5Dclose(did2);
-        /* enable error reporting */
-    } H5E_END_TRY;
-    
-    return nfound;
-    
+ hid_t   did1 = -1;
+ hid_t   did2 = -1;
+ hid_t   dcpl1 = -1;
+ hid_t   dcpl2 = -1;
+ hsize_t nfound = 0;
+
+/*-------------------------------------------------------------------------
+ * open the handles
+ *-------------------------------------------------------------------------
+ */
+ /* disable error reporting */
+ H5E_BEGIN_TRY {
+ /* Open the datasets */
+ if((did1 = H5Dopen2(file1_id, obj1_name, H5P_DEFAULT)) < 0) {
+  printf("Cannot open dataset <%s>\n", obj1_name);
+  goto error;
+ }
+ if((did2 = H5Dopen2(file2_id, obj2_name, H5P_DEFAULT)) < 0) {
+  printf("Cannot open dataset <%s>\n", obj2_name);
+  goto error;
+ }
+ /* enable error reporting */
+ } H5E_END_TRY;
+
+
+ if((dcpl1 = H5Dget_create_plist(did1)) < 0)
+  goto error;
+ if((dcpl2 = H5Dget_create_plist(did2)) < 0)
+  goto error;
+
+/*-------------------------------------------------------------------------
+ * check if the dataset creation property list has filters that
+ * are not registered in the current configuration
+ * 1) the external filters GZIP and SZIP might not be available
+ * 2) the internal filters might be turned off
+ *-------------------------------------------------------------------------
+ */
+ if ((h5tools_canreadf((options->m_verbose?obj1_name:NULL),dcpl1)==1) &&
+     (h5tools_canreadf((options->m_verbose?obj2_name:NULL),dcpl2)==1))
+ {
+  nfound=diff_datasetid(did1,
+                        did2,
+                        obj1_name,
+                        obj2_name,
+                        options);
+ }
+/*-------------------------------------------------------------------------
+ * close
+ *-------------------------------------------------------------------------
+ */
+ /* disable error reporting */
+ H5E_BEGIN_TRY {
+  H5Pclose(dcpl1);
+  H5Pclose(dcpl2);
+  H5Dclose(did1);
+  H5Dclose(did2);
+   /* enable error reporting */
+ } H5E_END_TRY;
+
+ return nfound;
+
 error:
-    options->err_stat=1;
-    /* disable error reporting */
-    H5E_BEGIN_TRY 
-    {
-        H5Pclose(dcpl1);
-        H5Pclose(dcpl2);
-        H5Dclose(did1);
-        H5Dclose(did2);
-        /* enable error reporting */
-    } H5E_END_TRY;
-    
-    return nfound;
+ options->err_stat=1;
+ /* disable error reporting */
+ H5E_BEGIN_TRY {
+  H5Pclose(dcpl1);
+  H5Pclose(dcpl2);
+  H5Dclose(did1);
+  H5Dclose(did2);
+   /* enable error reporting */
+ } H5E_END_TRY;
+
+ return nfound;
 }
 
 /*-------------------------------------------------------------------------
@@ -133,6 +154,7 @@ error:
  *
  * Modifications: 
  *
+ *
  * October 2006:  Read by hyperslabs for big datasets.
  *
  *  A threshold of H5TOOLS_MALLOCSIZE (128 MB) is the limit upon which I/O hyperslab is done
@@ -182,456 +204,448 @@ hsize_t diff_datasetid( hid_t did1,
                         const char *obj2_name,
                         diff_opt_t *options)
 {
-    hid_t      sid1=-1;
-    hid_t      sid2=-1;
-    hid_t      f_tid1=-1;
-    hid_t      f_tid2=-1;                
-    hid_t      m_tid1=-1;
-    hid_t      m_tid2=-1;                
-    size_t     m_size1;
-    size_t     m_size2;               
-    H5T_sign_t sign1;
-    H5T_sign_t sign2;                 
-    int        rank1;
-    int        rank2;
-    hsize_t    nelmts1;
-    hsize_t    nelmts2;
-    hsize_t    dims1[H5S_MAX_RANK];
-    hsize_t    dims2[H5S_MAX_RANK];
-    hsize_t    maxdim1[H5S_MAX_RANK];
-    hsize_t    maxdim2[H5S_MAX_RANK];
-    const char *name1=NULL;            /* relative names */
-    const char *name2=NULL;
-    hsize_t    storage_size1;
-    hsize_t    storage_size2;
-    hsize_t    nfound=0;               /* number of differences found */
-    int        cmp=1;                  /* do diff or not */
-    void       *buf1=NULL;                  
-    void       *buf2=NULL; 
-    void       *sm_buf1=NULL;                
-    void       *sm_buf2=NULL;
-    size_t     need;                   /* bytes needed for malloc */
-    int        i;
-    
-    /* get the dataspace handle */
-    if ( (sid1 = H5Dget_space(did1)) < 0 )
-        goto error;
-    
-    /* get rank */
-    if ( (rank1 = H5Sget_simple_extent_ndims(sid1)) < 0 )
-        goto error;
-    
-    /* get the dataspace handle */
-    if ( (sid2 = H5Dget_space(did2)) < 0 )
-        goto error;
-    
-    /* get rank */
-    if ( (rank2 = H5Sget_simple_extent_ndims(sid2)) < 0 )
-        goto error;
-    
-    /* get dimensions */
-    if ( H5Sget_simple_extent_dims(sid1,dims1,maxdim1) < 0 )
-        goto error;
-    
-    /* get dimensions */
-    if ( H5Sget_simple_extent_dims(sid2,dims2,maxdim2) < 0 )
-        goto error;
-    
-    /*-------------------------------------------------------------------------
-     * get the file data type
-     *-------------------------------------------------------------------------
-     */
-    
-    /* get the data type */
-    if ( (f_tid1 = H5Dget_type(did1)) < 0 )
-        goto error;
-    
-    /* get the data type */
-    if ( (f_tid2 = H5Dget_type(did2)) < 0 )
-        goto error;
-    
-    /*-------------------------------------------------------------------------
-     * check for empty datasets
-     *-------------------------------------------------------------------------
-     */
-    
-    storage_size1=H5Dget_storage_size(did1);
-    storage_size2=H5Dget_storage_size(did2);
-    if (storage_size1<0 || storage_size2<0)
-        goto error;
-    
-    if (storage_size1==0 || storage_size2==0)
-    {
-        if (options->m_verbose && obj1_name && obj2_name)
-            parallel_print("<%s> or <%s> are empty datasets\n", obj1_name, obj2_name);
-        cmp=0;
-        options->not_cmp=1;
-    }
-    
-   /*-------------------------------------------------------------------------
-    * check for comparable TYPE and SPACE
-    *-------------------------------------------------------------------------
-    */
-    
-    if (diff_can_type(f_tid1,
-        f_tid2,
-        rank1,
-        rank2,
-        dims1,
-        dims2,
-        maxdim1,
-        maxdim2,
-        obj1_name,
-        obj2_name,
-        options)!=1)
-    {
-        cmp=0;
-        options->not_cmp=1;
-    }
-    
-   /*-------------------------------------------------------------------------
-    * memory type and sizes
-    *-------------------------------------------------------------------------
-    */
-    if ((m_tid1=h5tools_get_native_type(f_tid1)) < 0)
-        goto error;
-    
-    if ((m_tid2=h5tools_get_native_type(f_tid2)) < 0)
-        goto error;
-    
-    m_size1 = H5Tget_size( m_tid1 );
-    m_size2 = H5Tget_size( m_tid2 );
-    
-   /*-------------------------------------------------------------------------
-    * check for different signed/unsigned types
-    *-------------------------------------------------------------------------
-    */
-    
-    sign1=H5Tget_sign(m_tid1);
-    sign2=H5Tget_sign(m_tid2);
-    if ( sign1 != sign2 )
-    {
-        if (options->m_verbose && obj1_name) 
-        {
-            parallel_print("Comparison not supported: <%s> has sign %s ", obj1_name, get_sign(sign1));
-            parallel_print("and <%s> has sign %s\n", obj2_name, get_sign(sign2));
-        }
-        
-        cmp=0;
-        options->not_cmp=1;
-    }
-    
-   /*-------------------------------------------------------------------------
-    * only attempt to compare if possible
-    *-------------------------------------------------------------------------
-    */
-    if (cmp)
-    {
-        
-       /*-------------------------------------------------------------------------
-        * get number of elements
-        *-------------------------------------------------------------------------
-        */
-        nelmts1 = 1;
-        for (i = 0; i < rank1; i++)
-        {
-            nelmts1 *= dims1[i];
-        }
-        
-        nelmts2 = 1;
-        for (i = 0; i < rank2; i++)
-        {
-            nelmts2 *= dims2[i];
-        }
-        
-        assert(nelmts1==nelmts2);
-        
-       /*-------------------------------------------------------------------------
-        * "upgrade" the smaller memory size
-        *-------------------------------------------------------------------------
-        */
-        
-        if ( m_size1 != m_size2 )
-        {
-            if ( m_size1 < m_size2 )
-            {
-                H5Tclose(m_tid1);
-                
-                if ((m_tid1=h5tools_get_native_type(f_tid2)) < 0)
-                    goto error;
-                
-                m_size1 = H5Tget_size( m_tid1 );
-            }
-            else
-            {
-                H5Tclose(m_tid2);
-                
-                if ((m_tid2=h5tools_get_native_type(f_tid1)) < 0)
-                    goto error;
-                
-                m_size2 = H5Tget_size( m_tid2 );
-            }
-        }
-        assert(m_size1==m_size2);
-        
-        /* print names */
-        if (obj1_name) {
-            name1=diff_basename(obj1_name);
-        }
-        if (obj2_name) {
-            name2=diff_basename(obj2_name);
-        }
-        
-        
-       /*-------------------------------------------------------------------------
-        * read/compare
-        *-------------------------------------------------------------------------
-        */
-        
-        need = (size_t)(nelmts1*m_size1);  /* bytes needed */
-        if ( need < H5TOOLS_MALLOCSIZE)
-        {
-            buf1 = HDmalloc(need);
-            buf2 = HDmalloc(need);
-        }
-        
-        if ( buf1!=NULL && buf2!=NULL)
-        {
-            if ( H5Dread(did1,m_tid1,H5S_ALL,H5S_ALL,H5P_DEFAULT,buf1) < 0 )
-                goto error;
-            if ( H5Dread(did2,m_tid2,H5S_ALL,H5S_ALL,H5P_DEFAULT,buf2) < 0 )
-                goto error;
-            
-            /* array diff */
-            nfound = diff_array(buf1,
-                buf2,
-                nelmts1,
-                (hsize_t)0,
-                rank1,
-                dims1,
-                options,
-                name1,
-                name2,
-                m_tid1,
-                did1,
-                did2);
-        }
-        
-        else /* possibly not enough memory, read/compare by hyperslabs */
-            
-        {
-            size_t        p_type_nbytes = m_size1; /*size of memory type */
-            hsize_t       p_nelmts = nelmts1;      /*total selected elmts */
-            hsize_t       elmtno;                  /*counter  */
-            int           carry;                   /*counter carry value */
-            unsigned int  vl_data = 0;             /*contains VL datatypes */
-            
-            /* stripmine info */
-            hsize_t       sm_size[H5S_MAX_RANK];   /*stripmine size */
-            hsize_t       sm_nbytes;               /*bytes per stripmine */
-            hsize_t       sm_nelmts;               /*elements per stripmine*/
-            hid_t         sm_space;                /*stripmine data space */
-            
-            /* hyperslab info */
-            hsize_t       hs_offset[H5S_MAX_RANK]; /*starting offset */
-            hsize_t       hs_size[H5S_MAX_RANK];   /*size this pass */
-            hsize_t       hs_nelmts;               /*elements in request */
-            hsize_t       zero[8];                 /*vector of zeros */
-            
-            /* check if we have VL data in the dataset's datatype */
-            if (H5Tdetect_class(m_tid1, H5T_VLEN) == TRUE)
-                vl_data = TRUE;
-            
-            /*
-             * determine the strip mine size and allocate a buffer. The strip mine is
-             * a hyperslab whose size is manageable.
-             */
-            sm_nbytes = p_type_nbytes;
-            
-            for (i = rank1; i > 0; --i) 
-            {
-                sm_size[i - 1] = MIN(dims1[i - 1], H5TOOLS_BUFSIZE / sm_nbytes);
-                sm_nbytes *= sm_size[i - 1];
-                assert(sm_nbytes > 0);
-            }
-            
-            sm_buf1 = malloc((size_t)sm_nbytes);
-            sm_buf2 = malloc((size_t)sm_nbytes);
-            
-            sm_nelmts = sm_nbytes / p_type_nbytes;
-            sm_space = H5Screate_simple(1, &sm_nelmts, NULL);
-            
-            /* the stripmine loop */
-            memset(hs_offset, 0, sizeof hs_offset);
-            memset(zero, 0, sizeof zero);
-            
-            for (elmtno = 0; elmtno < p_nelmts; elmtno += hs_nelmts) 
-            {
-                /* calculate the hyperslab size */
-                if (rank1 > 0) 
-                {
-                    for (i = 0, hs_nelmts = 1; i < rank1; i++) 
-                    {
-                        hs_size[i] = MIN(dims1[i] - hs_offset[i], sm_size[i]);
-                        hs_nelmts *= hs_size[i];
-                    }
-                    if (H5Sselect_hyperslab(sid1, H5S_SELECT_SET, hs_offset, NULL, hs_size, NULL) < 0)
-                        goto error;
-                    if (H5Sselect_hyperslab(sid2, H5S_SELECT_SET, hs_offset, NULL, hs_size, NULL) < 0)
-                        goto error;
-                    if (H5Sselect_hyperslab(sm_space, H5S_SELECT_SET, zero, NULL, &hs_nelmts, NULL) < 0)
-                        goto error;
-                } 
-                else 
-                {
-                    H5Sselect_all(sid1);
-                    H5Sselect_all(sid2);
-                    H5Sselect_all(sm_space);
-                    hs_nelmts = 1;
-                } /* rank */
-                
-                if ( H5Dread(did1,m_tid1,sm_space,sid1,H5P_DEFAULT,sm_buf1) < 0 )
-                    goto error;
-                if ( H5Dread(did2,m_tid2,sm_space,sid2,H5P_DEFAULT,sm_buf2) < 0 )
-                    goto error;
-                
-                /* get array differences. in the case of hyperslab read, increment the 
-                   number of differences found in each hyperslab and pass the 
-                   position at the beggining for printing
-                 */
-                nfound += diff_array(sm_buf1,
-                    sm_buf2,
-                    hs_nelmts,
-                    elmtno,
-                    rank1,
-                    dims1,
-                    options,
-                    name1,
-                    name2,
-                    m_tid1,
-                    did1,
-                    did2);
-                
-                /* reclaim any VL memory, if necessary */
-                if(vl_data)
-                {
-                    H5Dvlen_reclaim(m_tid1, sm_space, H5P_DEFAULT, sm_buf1);
-                    H5Dvlen_reclaim(m_tid1, sm_space, H5P_DEFAULT, sm_buf2);
-                }
-                
-                /* calculate the next hyperslab offset */
-                for (i = rank1, carry = 1; i > 0 && carry; --i) 
-                {
-                    hs_offset[i - 1] += hs_size[i - 1];
-                    if (hs_offset[i - 1] == dims1[i - 1])
-                        hs_offset[i - 1] = 0;
-                    else
-                        carry = 0;
-                } /* i */
-            } /* elmtno */
-            
-            H5Sclose(sm_space);
-            /* free */
-            if (sm_buf1!=NULL)
-            {
-                free(sm_buf1);
-                sm_buf1=NULL;
-            }
-            if (sm_buf2!=NULL)
-            {
-                free(sm_buf2);
-                sm_buf2=NULL;
-            }
-            
-  } /* hyperslab read */
- }/*cmp*/
- 
- /*-------------------------------------------------------------------------
-  * compare attributes
-  * the if condition refers to cases when the dataset is a referenced object
-  *-------------------------------------------------------------------------
-  */
-  
-  if (obj1_name)
-      nfound += diff_attr(did1,did2,obj1_name,obj2_name,options);
-  
- /*-------------------------------------------------------------------------
-  * close
-  *-------------------------------------------------------------------------
-  */
-  
-  /* free */
-  if (buf1!=NULL)
-  {
-      free(buf1);
-      buf1=NULL;
-  }
-  if (buf2!=NULL)
-  {
-      free(buf2);
-      buf2=NULL;
+ hid_t      sid1=-1;
+ hid_t      sid2=-1;
+ hid_t      f_tid1=-1;
+ hid_t      f_tid2=-1;                
+ hid_t      m_tid1=-1;
+ hid_t      m_tid2=-1;                
+ size_t     m_size1;
+ size_t     m_size2;               
+ H5T_sign_t sign1;
+ H5T_sign_t sign2;                 
+ int        rank1;
+ int        rank2;
+ hsize_t    nelmts1;
+ hsize_t    nelmts2;
+ hsize_t    dims1[H5S_MAX_RANK];
+ hsize_t    dims2[H5S_MAX_RANK];
+ hsize_t    maxdim1[H5S_MAX_RANK];
+ hsize_t    maxdim2[H5S_MAX_RANK];
+ const char *name1=NULL;            /* relative names */
+ const char *name2=NULL;
+ hsize_t    storage_size1;
+ hsize_t    storage_size2;
+ hsize_t    nfound=0;               /* number of differences found */
+ int        cmp=1;                  /* do diff or not */
+ void       *buf1=NULL;                  
+ void       *buf2=NULL; 
+ void       *sm_buf1=NULL;                
+ void       *sm_buf2=NULL;
+ size_t     need;                   /* bytes needed for malloc */
+ int        i;
+
+  /* Get the dataspace handle */
+ if ( (sid1 = H5Dget_space(did1)) < 0 )
+  goto error;
+
+ /* Get rank */
+ if ( (rank1 = H5Sget_simple_extent_ndims(sid1)) < 0 )
+  goto error;
+
+ /* Get the dataspace handle */
+ if ( (sid2 = H5Dget_space(did2)) < 0 )
+  goto error;
+
+ /* Get rank */
+ if ( (rank2 = H5Sget_simple_extent_ndims(sid2)) < 0 )
+  goto error;
+
+ /* Get dimensions */
+ if ( H5Sget_simple_extent_dims(sid1,dims1,maxdim1) < 0 )
+  goto error;
+
+ /* Get dimensions */
+ if ( H5Sget_simple_extent_dims(sid2,dims2,maxdim2) < 0 )
+  goto error;
+
+/*-------------------------------------------------------------------------
+ * Get the file data type
+ *-------------------------------------------------------------------------
+ */
+
+ /* Get the data type */
+ if ( (f_tid1 = H5Dget_type(did1)) < 0 )
+  goto error;
+
+ /* Get the data type */
+ if ( (f_tid2 = H5Dget_type(did2)) < 0 )
+  goto error;
+
+/*-------------------------------------------------------------------------
+ * check for empty datasets
+ *-------------------------------------------------------------------------
+ */
+
+ storage_size1=H5Dget_storage_size(did1);
+ storage_size2=H5Dget_storage_size(did2);
+
+ if (storage_size1==0 || storage_size2==0)
+ {
+  if (options->m_verbose && obj1_name && obj2_name)
+   parallel_print("<%s> or <%s> are empty datasets\n", obj1_name, obj2_name);
+  cmp=0;
+  options->not_cmp=1;
+ }
+
+/*-------------------------------------------------------------------------
+ * check for comparable TYPE and SPACE
+ *-------------------------------------------------------------------------
+ */
+
+ if (diff_can_type(f_tid1,
+                   f_tid2,
+                   rank1,
+                   rank2,
+                   dims1,
+                   dims2,
+                   maxdim1,
+                   maxdim2,
+                   obj1_name,
+                   obj2_name,
+                   options)!=1)
+ {
+  cmp=0;
+  options->not_cmp=1;
+ }
+
+/*-------------------------------------------------------------------------
+ * memory type and sizes
+ *-------------------------------------------------------------------------
+ */
+ if ((m_tid1=h5tools_get_native_type(f_tid1)) < 0)
+  goto error;
+
+ if ((m_tid2=h5tools_get_native_type(f_tid2)) < 0)
+  goto error;
+
+ m_size1 = H5Tget_size( m_tid1 );
+ m_size2 = H5Tget_size( m_tid2 );
+
+/*-------------------------------------------------------------------------
+ * check for different signed/unsigned types
+ *-------------------------------------------------------------------------
+ */
+
+ sign1=H5Tget_sign(m_tid1);
+ sign2=H5Tget_sign(m_tid2);
+ if ( sign1 != sign2 )
+ {
+  if (options->m_verbose && obj1_name) {
+   parallel_print("Comparison not supported: <%s> has sign %s ", obj1_name, get_sign(sign1));
+   parallel_print("and <%s> has sign %s\n", obj2_name, get_sign(sign2));
   }
-  if (sm_buf1!=NULL)
+
+  cmp=0;
+  options->not_cmp=1;
+ }
+
+/*-------------------------------------------------------------------------
+ * only attempt to compare if possible
+ *-------------------------------------------------------------------------
+ */
+ if (cmp)
+ {
+
+/*-------------------------------------------------------------------------
+ * get number of elements
+ *-------------------------------------------------------------------------
+ */
+ nelmts1 = 1;
+ for (i = 0; i < rank1; i++)
+ {
+  nelmts1 *= dims1[i];
+ }
+
+ nelmts2 = 1;
+ for (i = 0; i < rank2; i++)
+ {
+  nelmts2 *= dims2[i];
+ }
+
+ assert(nelmts1==nelmts2);
+
+/*-------------------------------------------------------------------------
+ * "upgrade" the smaller memory size
+ *-------------------------------------------------------------------------
+ */
+
+ if ( m_size1 != m_size2 )
+ {
+  if ( m_size1 < m_size2 )
   {
-      free(sm_buf1);
-      sm_buf1=NULL;
+   H5Tclose(m_tid1);
+
+   if ((m_tid1=h5tools_get_native_type(f_tid2)) < 0)
+    goto error;
+
+   m_size1 = H5Tget_size( m_tid1 );
   }
-  if (sm_buf2!=NULL)
+  else
   {
-      free(sm_buf2);
-      sm_buf2=NULL;
+   H5Tclose(m_tid2);
+
+   if ((m_tid2=h5tools_get_native_type(f_tid1)) < 0)
+    goto error;
+
+   m_size2 = H5Tget_size( m_tid2 );
   }
+ }
+ assert(m_size1==m_size2);
+
+ /* print names */
+ if (obj1_name) {
+  name1=diff_basename(obj1_name);
+ }
+ if (obj2_name) {
+  name2=diff_basename(obj2_name);
+ }
+
+ 
+/*-------------------------------------------------------------------------
+ * read/compare
+ *-------------------------------------------------------------------------
+ */
+
+ need = (size_t)(nelmts1*m_size1);  /* bytes needed */
+ if ( need < H5TOOLS_MALLOCSIZE)
+ {
+  buf1 = HDmalloc(need);
+  buf2 = HDmalloc(need);
+ }
+
+ if ( buf1!=NULL && buf2!=NULL)
+ {
+  if ( H5Dread(did1,m_tid1,H5S_ALL,H5S_ALL,H5P_DEFAULT,buf1) < 0 )
+   goto error;
+  if ( H5Dread(did2,m_tid2,H5S_ALL,H5S_ALL,H5P_DEFAULT,buf2) < 0 )
+   goto error;
+
+  /* array diff */
+  nfound = diff_array(buf1,
+                      buf2,
+                      nelmts1,
+                      (hsize_t)0,
+                      rank1,
+                      dims1,
+                      options,
+                      name1,
+                      name2,
+                      m_tid1,
+                      did1,
+                      did2);
+ }
+ 
+ else /* possibly not enough memory, read/compare by hyperslabs */
   
-  H5E_BEGIN_TRY 
-  {
-      H5Sclose(sid1);
-      H5Sclose(sid2);
-      H5Tclose(f_tid1);
-      H5Tclose(f_tid2);
-      H5Tclose(m_tid1);
-      H5Tclose(m_tid2);
-  } H5E_END_TRY;
+ {
+  size_t        p_type_nbytes = m_size1; /*size of memory type */
+  hsize_t       p_nelmts = nelmts1;      /*total selected elmts */
+  hsize_t       elmtno;                  /*counter  */
+  int           carry;                   /*counter carry value */
+  unsigned int  vl_data = 0;             /*contains VL datatypes */
   
-  return nfound;
+  /* stripmine info */
+  hsize_t       sm_size[H5S_MAX_RANK];   /*stripmine size */
+  hsize_t       sm_nbytes;               /*bytes per stripmine */
+  hsize_t       sm_nelmts;               /*elements per stripmine*/
+  hid_t         sm_space;                /*stripmine data space */
   
-error:
-  options->err_stat=1;
+  /* hyperslab info */
+  hsize_t       hs_offset[H5S_MAX_RANK]; /*starting offset */
+  hsize_t       hs_size[H5S_MAX_RANK];   /*size this pass */
+  hsize_t       hs_nelmts;               /*elements in request */
+  hsize_t       zero[8];                 /*vector of zeros */
   
-  /* free */
-  if (buf1!=NULL)
-  {
-      free(buf1);
-      buf1=NULL;
+  /* check if we have VL data in the dataset's datatype */
+  if (H5Tdetect_class(m_tid1, H5T_VLEN) == TRUE)
+   vl_data = TRUE;
+  
+  /*
+   * determine the strip mine size and allocate a buffer. The strip mine is
+   * a hyperslab whose size is manageable.
+   */
+  sm_nbytes = p_type_nbytes;
+  
+  for (i = rank1; i > 0; --i) {
+   sm_size[i - 1] = MIN(dims1[i - 1], H5TOOLS_BUFSIZE / sm_nbytes);
+   sm_nbytes *= sm_size[i - 1];
+   assert(sm_nbytes > 0);
   }
-  if (buf2!=NULL)
+  
+  sm_buf1 = malloc((size_t)sm_nbytes);
+  sm_buf2 = malloc((size_t)sm_nbytes);
+  
+  sm_nelmts = sm_nbytes / p_type_nbytes;
+  sm_space = H5Screate_simple(1, &sm_nelmts, NULL);
+  
+  /* the stripmine loop */
+  memset(hs_offset, 0, sizeof hs_offset);
+  memset(zero, 0, sizeof zero);
+
+  for (elmtno = 0; elmtno < p_nelmts; elmtno += hs_nelmts) 
   {
-      free(buf2);
-      buf2=NULL;
-  }
+   /* calculate the hyperslab size */
+   if (rank1 > 0) 
+   {
+    for (i = 0, hs_nelmts = 1; i < rank1; i++) 
+    {
+     hs_size[i] = MIN(dims1[i] - hs_offset[i], sm_size[i]);
+     hs_nelmts *= hs_size[i];
+    }
+    if (H5Sselect_hyperslab(sid1, H5S_SELECT_SET, hs_offset, NULL, hs_size, NULL) < 0)
+     goto error;
+    if (H5Sselect_hyperslab(sid2, H5S_SELECT_SET, hs_offset, NULL, hs_size, NULL) < 0)
+     goto error;
+    if (H5Sselect_hyperslab(sm_space, H5S_SELECT_SET, zero, NULL, &hs_nelmts, NULL) < 0)
+     goto error;
+   } 
+   else 
+   {
+    H5Sselect_all(sid1);
+    H5Sselect_all(sid2);
+    H5Sselect_all(sm_space);
+    hs_nelmts = 1;
+   } /* rank */
+ 
+   if ( H5Dread(did1,m_tid1,sm_space,sid1,H5P_DEFAULT,sm_buf1) < 0 )
+    goto error;
+   if ( H5Dread(did2,m_tid2,sm_space,sid2,H5P_DEFAULT,sm_buf2) < 0 )
+    goto error;
+   
+   /* get array differences. in the case of hyperslab read, increment the number of differences 
+      found in each hyperslab and pass the position at the beggining for printing */
+   nfound += diff_array(sm_buf1,
+                        sm_buf2,
+                        hs_nelmts,
+                        elmtno,
+                        rank1,
+                        dims1,
+                        options,
+                        name1,
+                        name2,
+                        m_tid1,
+                        did1,
+                        did2);
+
+   /* reclaim any VL memory, if necessary */
+   if(vl_data)
+   {
+    H5Dvlen_reclaim(m_tid1, sm_space, H5P_DEFAULT, sm_buf1);
+    H5Dvlen_reclaim(m_tid1, sm_space, H5P_DEFAULT, sm_buf2);
+   }
+   
+   /* calculate the next hyperslab offset */
+   for (i = rank1, carry = 1; i > 0 && carry; --i) 
+   {
+    hs_offset[i - 1] += hs_size[i - 1];
+    if (hs_offset[i - 1] == dims1[i - 1])
+     hs_offset[i - 1] = 0;
+    else
+     carry = 0;
+   } /* i */
+  } /* elmtno */
+  
+  H5Sclose(sm_space);
+  /* free */
   if (sm_buf1!=NULL)
   {
-      free(sm_buf1);
-      sm_buf1=NULL;
+   free(sm_buf1);
+   sm_buf1=NULL;
   }
   if (sm_buf2!=NULL)
   {
-      free(sm_buf2);
-      sm_buf2=NULL;
+   free(sm_buf2);
+   sm_buf2=NULL;
   }
   
-  /* disable error reporting */
-  H5E_BEGIN_TRY 
-  {
-      H5Sclose(sid1);
-      H5Sclose(sid2);
-      H5Tclose(f_tid1);
-      H5Tclose(f_tid2);
-      H5Tclose(m_tid1);
-      H5Tclose(m_tid2);
-      /* enable error reporting */
-  } H5E_END_TRY;
-  
-  return nfound;
+ } /* hyperslab read */
+ }/*cmp*/
+ 
+/*-------------------------------------------------------------------------
+ * compare attributes
+ * the if condition refers to cases when the dataset is a referenced object
+ *-------------------------------------------------------------------------
+ */
+
+ if (obj1_name)
+  nfound += diff_attr(did1,did2,obj1_name,obj2_name,options);
+
+/*-------------------------------------------------------------------------
+ * close
+ *-------------------------------------------------------------------------
+ */
+ 
+ /* free */
+ if (buf1!=NULL)
+ {
+  free(buf1);
+  buf1=NULL;
+ }
+ if (buf2!=NULL)
+ {
+  free(buf2);
+  buf2=NULL;
+ }
+ if (sm_buf1!=NULL)
+ {
+  free(sm_buf1);
+  sm_buf1=NULL;
+ }
+ if (sm_buf2!=NULL)
+ {
+  free(sm_buf2);
+  sm_buf2=NULL;
+ }
+
+ H5E_BEGIN_TRY {
+  H5Sclose(sid1);
+  H5Sclose(sid2);
+  H5Tclose(f_tid1);
+  H5Tclose(f_tid2);
+  H5Tclose(m_tid1);
+  H5Tclose(m_tid2);
+ } H5E_END_TRY;
+
+ return nfound;
+
+error:
+ options->err_stat=1;
+ 
+ /* free */
+ if (buf1!=NULL)
+ {
+  free(buf1);
+  buf1=NULL;
+ }
+ if (buf2!=NULL)
+ {
+  free(buf2);
+  buf2=NULL;
+ }
+ if (sm_buf1!=NULL)
+ {
+  free(sm_buf1);
+  sm_buf1=NULL;
+ }
+ if (sm_buf2!=NULL)
+ {
+  free(sm_buf2);
+  sm_buf2=NULL;
+ }
+
+ /* disable error reporting */
+ H5E_BEGIN_TRY {
+  H5Sclose(sid1);
+  H5Sclose(sid2);
+  H5Tclose(f_tid1);
+  H5Tclose(f_tid2);
+  H5Tclose(m_tid1);
+  H5Tclose(m_tid2);
+   /* enable error reporting */
+ } H5E_END_TRY;
+
+ return nfound;
 }
 
 /*-------------------------------------------------------------------------
@@ -663,164 +677,163 @@ int diff_can_type( hid_t       f_tid1, /* file data type */
                    const char  *obj2_name,
                    diff_opt_t  *options )
 {
-    H5T_class_t  tclass1;
-    H5T_class_t  tclass2;
-    int          maxdim_diff=0;          /* maximum dimensions are different */
-    int          dim_diff=0;             /* current dimensions are different */
-    int          i;
-    
-   /*-------------------------------------------------------------------------
-    * check for the same class
-    *-------------------------------------------------------------------------
-    */
-    
-    if ((tclass1=H5Tget_class(f_tid1)) < 0)
-        return -1;
-    
-    if ((tclass2=H5Tget_class(f_tid2)) < 0)
-        return -1;
-    
-    if ( tclass1 != tclass2 )
-    {
-        if (options->m_verbose && obj1_name) 
-        {
-            printf("Comparison not possible: <%s> is of class %s and <%s> is of class %s\n",
-                obj1_name, get_class(tclass1),
-                obj2_name, get_class(tclass2) );
-        }
-        return 0;
-    }
-    
-   /*-------------------------------------------------------------------------
-    * check for non supported classes
-    *-------------------------------------------------------------------------
-    */
-    
-    assert(tclass1==tclass2);
-    switch (tclass1)
-    {
-    case H5T_INTEGER:
-    case H5T_FLOAT:
-    case H5T_COMPOUND:
-    case H5T_STRING:
-    case H5T_ARRAY:
-    case H5T_BITFIELD:
-    case H5T_OPAQUE:
-    case H5T_ENUM:
-    case H5T_VLEN:
-    case H5T_REFERENCE:
-        
-        break;
-        
-    default: /*H5T_TIME */
-        if (options->m_verbose && obj1_name )
-            printf("Comparison not supported: <%s> and <%s> are of class %s\n",
-            obj1_name,obj2_name,get_class(tclass2) );
-        return 0;
-    }
-    
-   /*-------------------------------------------------------------------------
-    * check for equal file datatype; warning only
-    *-------------------------------------------------------------------------
-    */
-    
-    if ( (H5Tequal(f_tid1, f_tid2)==0) && options->m_verbose && obj1_name)
-    {
-        printf("Warning: different storage datatype\n");
-        printf("<%s> has file datatype ", obj1_name);
-        print_type(f_tid1);
-        printf("\n");
-        printf("<%s> has file datatype ", obj2_name);
-        print_type(f_tid2);
-        printf("\n");
-    }
-    
-   /*-------------------------------------------------------------------------
-    * check for the same rank
-    *-------------------------------------------------------------------------
-    */
-    
-    if ( rank1 != rank2 )
-    {
-        if (options->m_verbose && obj1_name) 
-        {
-            printf("Comparison not supported: <%s> has rank %d, dimensions ", obj1_name, rank1);
-            print_dimensions(rank1,dims1);
-            printf(", max dimensions ");
-            print_dimensions(rank1,maxdim1);
-            printf("\n" );
-            printf("<%s> has rank %d, dimensions ", obj2_name, rank2);
-            print_dimensions(rank2,dims2);
-            printf(", max dimensions ");
-            print_dimensions(rank2,maxdim2);
-        }
-        return 0;
-    }
-    
-   /*-------------------------------------------------------------------------
-    * check for different dimensions
-    *-------------------------------------------------------------------------
-    */
-    
-    assert(rank1==rank2);
-    for ( i=0; i<rank1; i++)
-    {
-        if (maxdim1 && maxdim2)
-        {
-            if ( maxdim1[i] != maxdim2[i] )
-                maxdim_diff=1;
-        }
-        if ( dims1[i] != dims2[i] )
-            dim_diff=1;
-    }
-    
-   /*-------------------------------------------------------------------------
-    * current dimensions
-    *-------------------------------------------------------------------------
-    */
-    
-    if (dim_diff==1)
-    {
-        if (options->m_verbose && obj1_name) 
-        {
-            printf("Comparison not supported: <%s> has rank %d, dimensions ", obj1_name, rank1);
-            print_dimensions(rank1,dims1);
-            if (maxdim1 && maxdim2) 
-            {
-                printf(", max dimensions ");
-                print_dimensions(rank1,maxdim1);
-                printf("\n" );
-                printf("<%s> has rank %d, dimensions ", obj2_name, rank2);
-                print_dimensions(rank2,dims2);
-                printf(", max dimensions ");
-                print_dimensions(rank2,maxdim2);
-            }
-        }
-        return 0;
-    }
-    
-   /*-------------------------------------------------------------------------
-    * maximum dimensions; just give a warning
-    *-------------------------------------------------------------------------
-    */
-    if (maxdim1 && maxdim2 && maxdim_diff==1 && obj1_name )
-    {
-        if (options->m_verbose) 
-        {
-            printf( "Warning: different maximum dimensions\n");
-            printf("<%s> has max dimensions ", obj1_name);
-            print_dimensions(rank1,maxdim1);
-            printf("\n");
-            printf("<%s> has max dimensions ", obj2_name);
-            print_dimensions(rank2,maxdim2);
-            printf("\n");
-        }
-    }
-    
-    return 1;
+
+
+ H5T_class_t  tclass1;
+ H5T_class_t  tclass2;
+ int          maxdim_diff=0;          /* maximum dimensions are different */
+ int          dim_diff=0;             /* current dimensions are different */
+ int          i;
+
+/*-------------------------------------------------------------------------
+ * check for the same class
+ *-------------------------------------------------------------------------
+ */
+
+ if ((tclass1=H5Tget_class(f_tid1)) < 0)
+  return -1;
+
+ if ((tclass2=H5Tget_class(f_tid2)) < 0)
+  return -1;
+
+ if ( tclass1 != tclass2 )
+ {
+  if (options->m_verbose && obj1_name) {
+   printf("Comparison not possible: <%s> is of class %s and <%s> is of class %s\n",
+    obj1_name, get_class(tclass1),
+    obj2_name, get_class(tclass2) );
+  }
+  return 0;
+ }
+
+/*-------------------------------------------------------------------------
+ * check for non supported classes
+ *-------------------------------------------------------------------------
+ */
+
+ assert(tclass1==tclass2);
+ switch (tclass1)
+ {
+ case H5T_INTEGER:
+ case H5T_FLOAT:
+ case H5T_COMPOUND:
+ case H5T_STRING:
+ case H5T_ARRAY:
+ case H5T_BITFIELD:
+ case H5T_OPAQUE:
+ case H5T_ENUM:
+ case H5T_VLEN:
+ case H5T_REFERENCE:
+
+  break;
+
+ default: /*H5T_TIME */
+  if (options->m_verbose && obj1_name )
+   printf("Comparison not supported: <%s> and <%s> are of class %s\n",
+    obj1_name,obj2_name,get_class(tclass2) );
+  return 0;
+ }
+
+/*-------------------------------------------------------------------------
+ * check for equal file datatype; warning only
+ *-------------------------------------------------------------------------
+ */
+
+ if ( (H5Tequal(f_tid1, f_tid2)==0) && options->m_verbose && obj1_name)
+ {
+  printf("Warning: different storage datatype\n");
+  printf("<%s> has file datatype ", obj1_name);
+  print_type(f_tid1);
+  printf("\n");
+  printf("<%s> has file datatype ", obj2_name);
+  print_type(f_tid2);
+  printf("\n");
+ }
+
+/*-------------------------------------------------------------------------
+ * check for the same rank
+ *-------------------------------------------------------------------------
+ */
+
+ if ( rank1 != rank2 )
+ {
+  if (options->m_verbose && obj1_name) {
+   printf("Comparison not supported: <%s> has rank %d, dimensions ", obj1_name, rank1);
+   print_dimensions(rank1,dims1);
+   printf(", max dimensions ");
+   print_dimensions(rank1,maxdim1);
+   printf("\n" );
+   printf("<%s> has rank %d, dimensions ", obj2_name, rank2);
+   print_dimensions(rank2,dims2);
+   printf(", max dimensions ");
+   print_dimensions(rank2,maxdim2);
+  }
+  return 0;
+ }
+
+/*-------------------------------------------------------------------------
+ * check for different dimensions
+ *-------------------------------------------------------------------------
+ */
+
+ assert(rank1==rank2);
+ for ( i=0; i<rank1; i++)
+ {
+  if (maxdim1 && maxdim2)
+  {
+   if ( maxdim1[i] != maxdim2[i] )
+    maxdim_diff=1;
+  }
+  if ( dims1[i] != dims2[i] )
+   dim_diff=1;
+ }
+
+/*-------------------------------------------------------------------------
+ * current dimensions
+ *-------------------------------------------------------------------------
+ */
+
+ if (dim_diff==1)
+ {
+  if (options->m_verbose && obj1_name) {
+   printf("Comparison not supported: <%s> has rank %d, dimensions ", obj1_name, rank1);
+   print_dimensions(rank1,dims1);
+   if (maxdim1 && maxdim2) {
+    printf(", max dimensions ");
+    print_dimensions(rank1,maxdim1);
+    printf("\n" );
+    printf("<%s> has rank %d, dimensions ", obj2_name, rank2);
+    print_dimensions(rank2,dims2);
+    printf(", max dimensions ");
+    print_dimensions(rank2,maxdim2);
+   }
+  }
+  return 0;
+ }
+
+/*-------------------------------------------------------------------------
+ * maximum dimensions; just give a warning
+ *-------------------------------------------------------------------------
+ */
+ if (maxdim1 && maxdim2 && maxdim_diff==1 && obj1_name )
+ {
+  if (options->m_verbose) {
+   printf( "Warning: different maximum dimensions\n");
+   printf("<%s> has max dimensions ", obj1_name);
+   print_dimensions(rank1,maxdim1);
+   printf("\n");
+   printf("<%s> has max dimensions ", obj2_name);
+   print_dimensions(rank2,maxdim2);
+   printf("\n");
+  }
+ }
+
+ return 1;
 }
 
 
+
+
 /*-------------------------------------------------------------------------
  * Function: print_sizes
  *
@@ -874,29 +887,3 @@ void print_sizes( const char *obj1,
  printf("\n");
 }
 #endif /* H5DIFF_DEBUG */
-
-/*-------------------------------------------------------------------------
- * Function: print_size
- *
- * Purpose: print dimensions 
- *
- *-------------------------------------------------------------------------
- */
-#if defined (H5DIFF_DEBUG)
-static void
-print_size (int rank, hsize_t *dims)
-{
-    int i;
-
-    parallel_print("[" );
-    for ( i = 0; i < rank-1; i++)
-    {
-        parallel_print("%"H5_PRINTF_LL_WIDTH"u", (unsigned long_long)dims[i]);
-        parallel_print("x");
-    }
-    parallel_print("%"H5_PRINTF_LL_WIDTH"u", (unsigned long_long)dims[rank-1]);
-    parallel_print("]\n" );
-    
-}
-#endif /* H5DIFF_DEBUG */
-
diff --git a/tools/lib/h5diff_util.c b/tools/lib/h5diff_util.c
index 4cddbfb..9e9c556 100644
--- a/tools/lib/h5diff_util.c
+++ b/tools/lib/h5diff_util.c
@@ -131,91 +131,91 @@ print_dimensions (int rank, hsize_t *dims)
  */
 void print_type(hid_t type)
 {
-    switch (H5Tget_class(type))
-    {
-    default:
-        return;
-    case H5T_INTEGER:
-        if (H5Tequal(type, H5T_STD_I8BE)) {
-            printf("H5T_STD_I8BE");
-        } else if (H5Tequal(type, H5T_STD_I8LE)) {
-            printf("H5T_STD_I8LE");
-        } else if (H5Tequal(type, H5T_STD_I16BE)) {
-            printf("H5T_STD_I16BE");
-        } else if (H5Tequal(type, H5T_STD_I16LE)) {
-            printf("H5T_STD_I16LE");
-        } else if (H5Tequal(type, H5T_STD_I32BE)) {
-            printf("H5T_STD_I32BE");
-        } else if (H5Tequal(type, H5T_STD_I32LE)) {
-            printf("H5T_STD_I32LE");
-        } else if (H5Tequal(type, H5T_STD_I64BE)) {
-            printf("H5T_STD_I64BE");
-        } else if (H5Tequal(type, H5T_STD_I64LE)) {
-            printf("H5T_STD_I64LE");
-        } else if (H5Tequal(type, H5T_STD_U8BE)) {
-            printf("H5T_STD_U8BE");
-        } else if (H5Tequal(type, H5T_STD_U8LE)) {
-            printf("H5T_STD_U8LE");
-        } else if (H5Tequal(type, H5T_STD_U16BE)) {
-            printf("H5T_STD_U16BE");
-        } else if (H5Tequal(type, H5T_STD_U16LE)) {
-            printf("H5T_STD_U16LE");
-        } else if (H5Tequal(type, H5T_STD_U32BE)) {
-            printf("H5T_STD_U32BE");
-        } else if (H5Tequal(type, H5T_STD_U32LE)) {
-            printf("H5T_STD_U32LE");
-        } else if (H5Tequal(type, H5T_STD_U64BE)) {
-            printf("H5T_STD_U64BE");
-        } else if (H5Tequal(type, H5T_STD_U64LE)) {
-            printf("H5T_STD_U64LE");
-        } else if (H5Tequal(type, H5T_NATIVE_SCHAR)) {
-            printf("H5T_NATIVE_SCHAR");
-        } else if (H5Tequal(type, H5T_NATIVE_UCHAR)) {
-            printf("H5T_NATIVE_UCHAR");
-        } else if (H5Tequal(type, H5T_NATIVE_SHORT)) {
-            printf("H5T_NATIVE_SHORT");
-        } else if (H5Tequal(type, H5T_NATIVE_USHORT)) {
-            printf("H5T_NATIVE_USHORT");
-        } else if (H5Tequal(type, H5T_NATIVE_INT)) {
-            printf("H5T_NATIVE_INT");
-        } else if (H5Tequal(type, H5T_NATIVE_UINT)) {
-            printf("H5T_NATIVE_UINT");
-        } else if (H5Tequal(type, H5T_NATIVE_LONG)) {
-            printf("H5T_NATIVE_LONG");
-        } else if (H5Tequal(type, H5T_NATIVE_ULONG)) {
-            printf("H5T_NATIVE_ULONG");
-        } else if (H5Tequal(type, H5T_NATIVE_LLONG)) {
-            printf("H5T_NATIVE_LLONG");
-        } else if (H5Tequal(type, H5T_NATIVE_ULLONG)) {
-            printf("H5T_NATIVE_ULLONG");
-        } else {
-            printf("undefined integer");
-        }
-        break;
-        
-    case H5T_FLOAT:
-        if (H5Tequal(type, H5T_IEEE_F32BE)) {
-            printf("H5T_IEEE_F32BE");
-        } else if (H5Tequal(type, H5T_IEEE_F32LE)) {
-            printf("H5T_IEEE_F32LE");
-        } else if (H5Tequal(type, H5T_IEEE_F64BE)) {
-            printf("H5T_IEEE_F64BE");
-        } else if (H5Tequal(type, H5T_IEEE_F64LE)) {
-            printf("H5T_IEEE_F64LE");
-        } else if (H5Tequal(type, H5T_NATIVE_FLOAT)) {
-            printf("H5T_NATIVE_FLOAT");
-        } else if (H5Tequal(type, H5T_NATIVE_DOUBLE)) {
-            printf("H5T_NATIVE_DOUBLE");
+ switch (H5Tget_class(type))
+ {
+ default:
+  return;
+ case H5T_INTEGER:
+  if (H5Tequal(type, H5T_STD_I8BE)) {
+   printf("H5T_STD_I8BE");
+  } else if (H5Tequal(type, H5T_STD_I8LE)) {
+   printf("H5T_STD_I8LE");
+  } else if (H5Tequal(type, H5T_STD_I16BE)) {
+   printf("H5T_STD_I16BE");
+  } else if (H5Tequal(type, H5T_STD_I16LE)) {
+   printf("H5T_STD_I16LE");
+  } else if (H5Tequal(type, H5T_STD_I32BE)) {
+   printf("H5T_STD_I32BE");
+  } else if (H5Tequal(type, H5T_STD_I32LE)) {
+   printf("H5T_STD_I32LE");
+  } else if (H5Tequal(type, H5T_STD_I64BE)) {
+   printf("H5T_STD_I64BE");
+  } else if (H5Tequal(type, H5T_STD_I64LE)) {
+   printf("H5T_STD_I64LE");
+  } else if (H5Tequal(type, H5T_STD_U8BE)) {
+   printf("H5T_STD_U8BE");
+  } else if (H5Tequal(type, H5T_STD_U8LE)) {
+   printf("H5T_STD_U8LE");
+  } else if (H5Tequal(type, H5T_STD_U16BE)) {
+   printf("H5T_STD_U16BE");
+  } else if (H5Tequal(type, H5T_STD_U16LE)) {
+   printf("H5T_STD_U16LE");
+  } else if (H5Tequal(type, H5T_STD_U32BE)) {
+   printf("H5T_STD_U32BE");
+  } else if (H5Tequal(type, H5T_STD_U32LE)) {
+   printf("H5T_STD_U32LE");
+  } else if (H5Tequal(type, H5T_STD_U64BE)) {
+   printf("H5T_STD_U64BE");
+  } else if (H5Tequal(type, H5T_STD_U64LE)) {
+   printf("H5T_STD_U64LE");
+  } else if (H5Tequal(type, H5T_NATIVE_SCHAR)) {
+   printf("H5T_NATIVE_SCHAR");
+  } else if (H5Tequal(type, H5T_NATIVE_UCHAR)) {
+   printf("H5T_NATIVE_UCHAR");
+  } else if (H5Tequal(type, H5T_NATIVE_SHORT)) {
+   printf("H5T_NATIVE_SHORT");
+  } else if (H5Tequal(type, H5T_NATIVE_USHORT)) {
+   printf("H5T_NATIVE_USHORT");
+  } else if (H5Tequal(type, H5T_NATIVE_INT)) {
+   printf("H5T_NATIVE_INT");
+  } else if (H5Tequal(type, H5T_NATIVE_UINT)) {
+   printf("H5T_NATIVE_UINT");
+  } else if (H5Tequal(type, H5T_NATIVE_LONG)) {
+   printf("H5T_NATIVE_LONG");
+  } else if (H5Tequal(type, H5T_NATIVE_ULONG)) {
+   printf("H5T_NATIVE_ULONG");
+  } else if (H5Tequal(type, H5T_NATIVE_LLONG)) {
+   printf("H5T_NATIVE_LLONG");
+  } else if (H5Tequal(type, H5T_NATIVE_ULLONG)) {
+   printf("H5T_NATIVE_ULLONG");
+  } else {
+   printf("undefined integer");
+  }
+  break;
+
+ case H5T_FLOAT:
+  if (H5Tequal(type, H5T_IEEE_F32BE)) {
+   printf("H5T_IEEE_F32BE");
+  } else if (H5Tequal(type, H5T_IEEE_F32LE)) {
+   printf("H5T_IEEE_F32LE");
+  } else if (H5Tequal(type, H5T_IEEE_F64BE)) {
+   printf("H5T_IEEE_F64BE");
+  } else if (H5Tequal(type, H5T_IEEE_F64LE)) {
+   printf("H5T_IEEE_F64LE");
+  } else if (H5Tequal(type, H5T_NATIVE_FLOAT)) {
+   printf("H5T_NATIVE_FLOAT");
+  } else if (H5Tequal(type, H5T_NATIVE_DOUBLE)) {
+   printf("H5T_NATIVE_DOUBLE");
 #if H5_SIZEOF_LONG_DOUBLE !=0
-        } else if (H5Tequal(type, H5T_NATIVE_LDOUBLE)) {
-            printf("H5T_NATIVE_LDOUBLE");
+  } else if (H5Tequal(type, H5T_NATIVE_LDOUBLE)) {
+   printf("H5T_NATIVE_LDOUBLE");
 #endif
-        } else {
-            printf("undefined float");
-        }
-        break;
-        
-    }/*switch*/
+  } else {
+   printf("undefined float");
+  }
+  break;
+
+ }/*switch*/
 }
 
 /*-------------------------------------------------------------------------
@@ -232,21 +232,21 @@ void print_type(hid_t type)
 const char*
 diff_basename(const char *name)
 {
-    size_t i;
-    
-    if (name==NULL)
-        return NULL;
-    
-    /* Find the end of the base name */
-    i = strlen(name);
-    while (i>0 && '/'==name[i-1])
-        --i;
-    
-    /* Skip backward over base name */
-    while (i>0 && '/'!=name[i-1])
-        --i;
-    
-    return(name+i);
+ size_t i;
+
+ if (name==NULL)
+  return NULL;
+
+ /* Find the end of the base name */
+ i = strlen(name);
+ while (i>0 && '/'==name[i-1])
+  --i;
+
+ /* Skip backward over base name */
+ while (i>0 && '/'!=name[i-1])
+  --i;
+
+ return(name+i);
 }
 
 /*-------------------------------------------------------------------------
@@ -295,15 +295,15 @@ get_type(h5trav_type_t type)
 const char*
 get_sign(H5T_sign_t sign)
 {
-    switch (sign)
-    {
-    default:
-        return("H5T_SGN_ERROR");
-    case H5T_SGN_NONE:
-        return("H5T_SGN_NONE");
-    case H5T_SGN_2:
-        return("H5T_SGN_2");
-    }
+ switch (sign)
+ {
+ default:
+  return("H5T_SGN_ERROR");
+ case H5T_SGN_NONE:
+  return("H5T_SGN_NONE");
+ case H5T_SGN_2:
+  return("H5T_SGN_2");
+ }
 }
 
 
@@ -321,33 +321,33 @@ get_sign(H5T_sign_t sign)
 const char*
 get_class(H5T_class_t tclass)
 {
-    switch (tclass)
-    {
-    default:
-        return("Invalid class");
-    case H5T_TIME:
-        return("H5T_TIME");
-    case H5T_INTEGER:
-        return("H5T_INTEGER");
-    case H5T_FLOAT:
-        return("H5T_FLOAT");
-    case H5T_STRING:
-        return("H5T_STRING");
-    case H5T_BITFIELD:
-        return("H5T_BITFIELD");
-    case H5T_OPAQUE:
-        return("H5T_OPAQUE");
-    case H5T_COMPOUND:
-        return("H5T_COMPOUND");
-    case H5T_REFERENCE:
-        return("H5T_REFERENCE");
-    case H5T_ENUM:
-        return("H5T_ENUM");
-    case H5T_VLEN:
-        return("H5T_VLEN");
-    case H5T_ARRAY:
-        return("H5T_ARRAY");
-    }
+ switch (tclass)
+ {
+ default:
+  return("Invalid class");
+ case H5T_TIME:
+  return("H5T_TIME");
+ case H5T_INTEGER:
+  return("H5T_INTEGER");
+ case H5T_FLOAT:
+  return("H5T_FLOAT");
+ case H5T_STRING:
+  return("H5T_STRING");
+ case H5T_BITFIELD:
+  return("H5T_BITFIELD");
+ case H5T_OPAQUE:
+  return("H5T_OPAQUE");
+ case H5T_COMPOUND:
+  return("H5T_COMPOUND");
+ case H5T_REFERENCE:
+  return("H5T_REFERENCE");
+ case H5T_ENUM:
+  return("H5T_ENUM");
+ case H5T_VLEN:
+  return("H5T_VLEN");
+ case H5T_ARRAY:
+  return("H5T_ARRAY");
+ }
 }
 
 /*-------------------------------------------------------------------------
diff --git a/tools/lib/h5tools.c b/tools/lib/h5tools.c
index 120d433..6fc09d7 100644
--- a/tools/lib/h5tools.c
+++ b/tools/lib/h5tools.c
@@ -538,31 +538,29 @@ h5tools_dump_simple_data(FILE *stream, const h5tool_format_t *info, hid_t contai
                          hsize_t nelmts, hid_t type, void *_mem)
 {
     unsigned char *mem = (unsigned char*)_mem;
-    hsize_t       i;          /*element counter  */
-    char          *s;
-    char          *section;   /*a section of output  */
-    int           secnum;     /*section sequence number */
-    size_t        size;       /*size of each datum  */
-    size_t        ncols = 80; /*available output width */
-    h5tools_str_t buffer;     /*string into which to render */
-    int           multiline;  /*datum was multiline  */
-    hsize_t       curr_pos;   /* total data element position   */
-    int           elmt_counter = 0;/*counts the # elements printed.
-                                    *I (ptl?) needed something that
-                                    *isn't going to get reset when a new
-                                    *line is formed. I'm going to use
-                                    *this var to count elements and
-                                    *break after we see a number equal
-                                    *to the ctx->size_last_dim.   */
+    hsize_t  i;  /*element counter  */
+    char  *s, *section; /*a section of output  */
+    int   secnum;  /*section sequence number */
+    size_t  size;  /*size of each datum  */
+    size_t  ncols = 80; /*available output width */
+    h5tools_str_t buffer;  /*string into which to render */
+    int   multiline; /*datum was multiline  */
+    hsize_t  curr_pos;  /* total data element position   */
+    int                 elmt_counter = 0;/*counts the # elements printed.
+                                          *I (ptl?) needed something that
+                                          *isn't going to get reset when a new
+                                          *line is formed. I'm going to use
+                                          *this var to count elements and
+                                          *break after we see a number equal
+                                          *to the ctx->size_last_dim.   */
 
      /* binary dump */
-    if(bin_output) 
-    {
+    if(bin_output) {
         do_bin_output(stream, nelmts, type, _mem);
+        bin_output = 0;
     } /* end if */
-    else 
-    {
-        /* setup */
+    else {
+        /* Setup */
         HDmemset(&buffer, 0, sizeof(h5tools_str_t));
         size = H5Tget_size(type);
 
@@ -615,7 +613,7 @@ h5tools_dump_simple_data(FILE *stream, const h5tool_format_t *info, hid_t contai
             }
 
             /*
-             * We need to break after each row of a dimension---> we should
+             * We need to break after each row_counter of a dimension---> we should
              * break at the end of the each last dimension well that is the
              * way the dumper did it before
              */