[svn-r12134] Purpose:

bug fix

Description:
1) added a more explainative usage message
2) the percent relative error for the integer type (division) was being done using integer arythmetic; use floating point arythmetic instead
3) added a new test for integer percent

Solution:

Platforms tested:
linux (32,64)
AIX
solaris

Misc. update:

6 files changed, 1366 insertions, 1377 deletions

diff --git a/tools/lib/h5diff.c b/tools/lib/h5diff.c
index 3322d99..4fd9c10 100644
--- a/tools/lib/h5diff.c
+++ b/tools/lib/h5diff.c
@@ -20,12 +20,12 @@
 /*
  * Debug printf macros. The prefix allows output filtering by test scripts.
  */
-#ifdef debug
-#define h5diffdebug(x)	fprintf(stderr, "h5diff debug: " x)
-#define h5diffdebug2(x1, x2)	fprintf(stderr, "h5diff debug: " x1, x2)
-#define h5diffdebug3(x1, x2, x3)	fprintf(stderr, "h5diff debug: " x1, x2, x3)
-#define h5diffdebug4(x1, x2, x3, x4)	fprintf(stderr, "h5diff debug: " x1, x2, x3, x4)
-#define h5diffdebug5(x1, x2, x3, x4, x5)	fprintf(stderr, "h5diff debug: " x1, x2, x3, x4, x5)
+#ifdef H5DIFF_DEBUG
+#define h5diffdebug(x) fprintf(stderr, "h5diff debug: " x)
+#define h5diffdebug2(x1, x2) fprintf(stderr, "h5diff debug: " x1, x2)
+#define h5diffdebug3(x1, x2, x3) fprintf(stderr, "h5diff debug: " x1, x2, x3)
+#define h5diffdebug4(x1, x2, x3, x4) fprintf(stderr, "h5diff debug: " x1, x2, x3, x4)
+#define h5diffdebug5(x1, x2, x3, x4, x5) fprintf(stderr, "h5diff debug: " x1, x2, x3, x4, x5)
 #else
 #define h5diffdebug(x)
 #define h5diffdebug2(x1, x2)
@@ -46,7 +46,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;
 }
 
 #ifdef H5_HAVE_PARALLEL
@@ -65,9 +65,9 @@ print_objname (diff_opt_t * options, hsize_t nfound)
  */
 void phdiff_dismiss_workers(void)
 {
-    int i;
-    for(i=1; i<g_nTasks; i++)
-	MPI_Send(NULL, 0, MPI_BYTE, i, MPI_TAG_END, MPI_COMM_WORLD);
+ int i;
+ for(i=1; i<g_nTasks; i++)
+  MPI_Send(NULL, 0, MPI_BYTE, i, MPI_TAG_END, MPI_COMM_WORLD);
 }
 
 
@@ -87,31 +87,31 @@ void phdiff_dismiss_workers(void)
  */
 void print_manager_output(void)
 {
-    /* If there was something we buffered, let's print it now */
-    if( (outBuffOffset>0) && g_Parallel)
-    {
-	printf("%s", outBuff);
-
-	if(overflow_file)
-	{
-	    int     tmp;
-
-	    rewind(overflow_file);
-	    while((tmp = getc(overflow_file)) >= 0)
-		putchar(tmp);
-
-	    fclose(overflow_file);
-	    overflow_file = NULL;
-	}
-
-	fflush(stdout);
-	memset(outBuff, 0, OUTBUFF_SIZE);
-	outBuffOffset = 0;
-    }
-    else if( (outBuffOffset>0) && !g_Parallel)
-    {
-	fprintf(stderr, "h5diff error: outBuffOffset>0, but we're not in parallel!\n");
-    }
+ /* If there was something we buffered, let's print it now */
+ if( (outBuffOffset>0) && g_Parallel)
+ {
+  printf("%s", outBuff);
+  
+  if(overflow_file)
+  {
+   int     tmp;
+   
+   rewind(overflow_file);
+   while((tmp = getc(overflow_file)) >= 0)
+    putchar(tmp);
+   
+   fclose(overflow_file);
+   overflow_file = NULL;
+  }
+  
+  fflush(stdout);
+  memset(outBuff, 0, OUTBUFF_SIZE);
+  outBuffOffset = 0;
+ }
+ else if( (outBuffOffset>0) && !g_Parallel)
+ {
+  fprintf(stderr, "h5diff error: outBuffOffset>0, but we're not in parallel!\n");
+ }
 }
 
 /*-------------------------------------------------------------------------
@@ -131,21 +131,21 @@ void print_manager_output(void)
 
 static void print_incoming_data(void)
 {
-    char data[PRINT_DATA_MAX_SIZE+1];
-    int  incomingMessage;
-    MPI_Status Status;
-
-    do
-    {
-	MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_PRINT_DATA, MPI_COMM_WORLD, &incomingMessage, &Status);
-	if(incomingMessage)
-	{
-	    memset(data, 0, PRINT_DATA_MAX_SIZE+1);
-	    MPI_Recv(data, PRINT_DATA_MAX_SIZE, MPI_CHAR, Status.MPI_SOURCE, MPI_TAG_PRINT_DATA, MPI_COMM_WORLD, &Status);
-
-	    printf("%s", data);
-	}
-    } while(incomingMessage);
+ char data[PRINT_DATA_MAX_SIZE+1];
+ int  incomingMessage;
+ MPI_Status Status;
+ 
+ do
+ {
+  MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_PRINT_DATA, MPI_COMM_WORLD, &incomingMessage, &Status);
+  if(incomingMessage)
+  {
+   memset(data, 0, PRINT_DATA_MAX_SIZE+1);
+   MPI_Recv(data, PRINT_DATA_MAX_SIZE, MPI_CHAR, Status.MPI_SOURCE, MPI_TAG_PRINT_DATA, MPI_COMM_WORLD, &Status);
+   
+   printf("%s", data);
+  }
+ } while(incomingMessage);
 }
 #endif
 
@@ -170,183 +170,180 @@ hsize_t h5diff(const char *fname1,
                const char *objname2,
                diff_opt_t *options)
 {
-  int nobjects1, nobjects2;
-  trav_info_t *info1 = NULL;
-  trav_info_t *info2 = NULL;
-  hid_t        file1_id=(-1), file2_id=(-1);
-  char         filenames[2][1024];
-  hsize_t      nfound = 0;
-
-  memset(filenames, 0, 1024*2);
-
+ int nobjects1, nobjects2;
+ trav_info_t *info1 = NULL;
+ trav_info_t *info2 = NULL;
+ hid_t        file1_id=(-1), file2_id=(-1);
+ char         filenames[2][1024];
+ hsize_t      nfound = 0;
+ 
+ memset(filenames, 0, 1024*2);
+ 
  if (options->m_quiet &&
-     (options->m_verbose || options->m_report))
+  (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;
  }
-
+ 
 /*-------------------------------------------------------------------------
  * open the files first; if they are not valid, no point in continuing
  *-------------------------------------------------------------------------
  */
-
-  /* disable error reporting */
-  H5E_BEGIN_TRY
+ 
+ /* disable error reporting */
+ H5E_BEGIN_TRY
+ {
+  /* Open the files */
+  if ((file1_id = H5Fopen (fname1, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0)
   {
-    /* 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;
-
+   printf ("h5diff: <%s>: unable to open file\n", fname1);
+   options->err_stat = 1;
+   
 #ifdef H5_HAVE_PARALLEL
- if(g_Parallel)
- {
-     /* Let tasks know that they won't be needed */
-     phdiff_dismiss_workers();
- }
+   if(g_Parallel)
+   {
+    /* Let tasks know that they won't be needed */
+    phdiff_dismiss_workers();
+   }
 #endif
-
- goto out;
-      }
-    if ((file2_id = H5Fopen (fname2, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0)
-    {
- printf ("h5diff: <%s>: unable to open file\n", fname2);
- options->err_stat = 1;
-
+   
+   goto out;
+  }
+  if ((file2_id = H5Fopen (fname2, H5F_ACC_RDONLY, H5P_DEFAULT)) < 0)
+  {
+   printf ("h5diff: <%s>: unable to open file\n", fname2);
+   options->err_stat = 1;
+   
 #ifdef H5_HAVE_PARALLEL
- if(g_Parallel)
- {
-     /* Let tasks know that they won't be needed */
-     phdiff_dismiss_workers();
- }
+   if(g_Parallel)
+   {
+    /* Let tasks know that they won't be needed */
+    phdiff_dismiss_workers();
+   }
 #endif
-
- goto out;
-      }
-    /* enable error reporting */
+   
+   goto out;
   }
-  H5E_END_TRY;
-
-
+  /* enable error reporting */
+ }
+ H5E_END_TRY;
+ 
 /*-------------------------------------------------------------------------
  * get the number of objects in the files
  *-------------------------------------------------------------------------
  */
-  nobjects1 = h5trav_getinfo (file1_id, NULL, 0);
-  nobjects2 = h5trav_getinfo (file2_id, NULL, 0);
-
-  if (nobjects1 < 0 || nobjects2 < 0)
-    {
-      printf ("Error: Could not get get file contents\n");
-      options->err_stat = 1;
-#ifdef H5_HAVE_PARALLEL
- if(g_Parallel)
+ nobjects1 = h5trav_getinfo (file1_id, NULL, 0);
+ nobjects2 = h5trav_getinfo (file2_id, NULL, 0);
+ 
+ if (nobjects1 < 0 || nobjects2 < 0)
  {
-     /* Let tasks know that they won't be needed */
-     phdiff_dismiss_workers();
- }
+  printf ("Error: Could not get get file contents\n");
+  options->err_stat = 1;
+#ifdef H5_HAVE_PARALLEL
+  if(g_Parallel)
+  {
+   /* Let tasks know that they won't be needed */
+   phdiff_dismiss_workers();
+  }
 #endif
-      goto out;
-    }
-
+  goto out;
+ }
+ 
 /*-------------------------------------------------------------------------
  * get the list of objects in the files
  *-------------------------------------------------------------------------
  */
-
-  info1 = (trav_info_t *) malloc (nobjects1 * sizeof (trav_info_t));
-  info2 = (trav_info_t *) malloc (nobjects2 * sizeof (trav_info_t));
-  if (info1 == NULL || info2 == NULL)
-    {
-      printf ("Error: Not enough memory for object list\n");
-      options->err_stat = 1;
-      if (info1) h5trav_freeinfo (info1, nobjects1);
-      if (info2) h5trav_freeinfo (info2, nobjects1);
-#ifdef H5_HAVE_PARALLEL
- if(g_Parallel)
+ 
+ info1 = (trav_info_t *) malloc (nobjects1 * sizeof (trav_info_t));
+ info2 = (trav_info_t *) malloc (nobjects2 * sizeof (trav_info_t));
+ if (info1 == NULL || info2 == NULL)
  {
-     /* Let tasks know that they won't be needed */
-     phdiff_dismiss_workers();
- }
+  printf ("Error: Not enough memory for object list\n");
+  options->err_stat = 1;
+  if (info1) h5trav_freeinfo (info1, nobjects1);
+  if (info2) h5trav_freeinfo (info2, nobjects1);
+#ifdef H5_HAVE_PARALLEL
+  if(g_Parallel)
+  {
+   /* Let tasks know that they won't be needed */
+   phdiff_dismiss_workers();
+  }
 #endif
-      goto out;
-    }
-
-  h5trav_getinfo (file1_id, info1, 0);
-  h5trav_getinfo (file2_id, info2, 0);
-
+  goto out;
+ }
+ 
+ h5trav_getinfo (file1_id, info1, 0);
+ h5trav_getinfo (file2_id, info2, 0);
+ 
 /*-------------------------------------------------------------------------
  * object name was supplied
  *-------------------------------------------------------------------------
  */
-
-  if (objname1)
-    {
-
-#ifdef H5_HAVE_PARALLEL
- if(g_Parallel)
+ 
+ if (objname1)
  {
-     /* Let tasks know that they won't be needed */
-     phdiff_dismiss_workers();
- }
+  
+#ifdef H5_HAVE_PARALLEL
+  if(g_Parallel)
+  {
+   /* Let tasks know that they won't be needed */
+   phdiff_dismiss_workers();
+  }
 #endif
-      assert (objname2);
-      options->cmn_objs = 1; /* eliminate warning */
-      nfound = diff_compare (file1_id, fname1, objname1, nobjects1, info1,
-        file2_id, fname2, objname2, nobjects2, info2,
-        options);
-    }
-
+  assert (objname2);
+  options->cmn_objs = 1; /* eliminate warning */
+  nfound = diff_compare (file1_id, fname1, objname1, nobjects1, info1,
+   file2_id, fname2, objname2, nobjects2, info2,
+   options);
+ }
+ 
 /*-------------------------------------------------------------------------
  * compare all
  *-------------------------------------------------------------------------
  */
-
-  else
-  {
-
+ 
+ else
+ {
+  
 #ifdef H5_HAVE_PARALLEL
-      if(g_Parallel)
-      {
-          int i;
-
+  if(g_Parallel)
+  {
+   int i;
+   
    if(  (strlen(fname1) > 1024) || (strlen(fname2) > 1024))
    {
-       fprintf(stderr, "The parallel diff only supports path names up to 1024 characters\n");
-       MPI_Abort(MPI_COMM_WORLD, 0);
+    fprintf(stderr, "The parallel diff only supports path names up to 1024 characters\n");
+    MPI_Abort(MPI_COMM_WORLD, 0);
    }
-
+   
    strcpy(filenames[0], fname1);
    strcpy(filenames[1], fname2);
-
+   
    /* Alert the worker tasks that there's going to be work. */
-
+   
    for(i=1; i<g_nTasks; i++)
-       MPI_Send(filenames, 1024*2, MPI_CHAR, i, MPI_TAG_PARALLEL, MPI_COMM_WORLD);
-      }
-#endif
-      nfound = diff_match (file1_id, nobjects1, info1,
-       file2_id, nobjects2, info2, options);
-
+    MPI_Send(filenames, 1024*2, MPI_CHAR, i, MPI_TAG_PARALLEL, MPI_COMM_WORLD);
   }
-
-
-  h5trav_freeinfo (info1, nobjects1);
-  h5trav_freeinfo (info2, nobjects2);
-
+#endif
+  nfound = diff_match (file1_id, nobjects1, info1,
+   file2_id, nobjects2, info2, options);
+ }
+ 
+ h5trav_freeinfo (info1, nobjects1);
+ h5trav_freeinfo (info2, nobjects2);
+ 
 out:
-  /* close */
-  H5E_BEGIN_TRY
-  {
-      H5Fclose (file1_id);
-      H5Fclose (file2_id);
-  }
-  H5E_END_TRY;
-
-  return nfound;
+ /* close */
+ H5E_BEGIN_TRY
+ {
+  H5Fclose (file1_id);
+  H5Fclose (file2_id);
+ }
+ H5E_END_TRY;
+ 
+ return nfound;
 }
 
 
@@ -369,423 +366,425 @@ out:
  *
  *-------------------------------------------------------------------------
  */
-hsize_t
-diff_match (hid_t file1_id,
- int nobjects1,
- trav_info_t * info1,
- hid_t file2_id,
- int nobjects2, trav_info_t * info2, diff_opt_t * options)
+hsize_t diff_match (hid_t file1_id, 
+                    int nobjects1,
+                    trav_info_t * info1,
+                    hid_t file2_id,
+                    int nobjects2, 
+                    trav_info_t * info2, 
+                    diff_opt_t * options)
 {
-    int more_names_exist = (nobjects1 > 0 && nobjects2 > 0) ? 1 : 0;
-    trav_table_t *table = NULL;
-    int cmp;
-    int curr1 = 0;
-    int curr2 = 0;
-    unsigned infile[2];
-    char c1, c2;
-    hsize_t nfound = 0;
-    int i;
-
-    /*-------------------------------------------------------------------------
-     * build the list
-     *-------------------------------------------------------------------------
-     */
-    trav_table_init (&table);
-
-    while (more_names_exist)
-    {
- /* criteria is string compare */
- cmp = strcmp (info1[curr1].name, info2[curr2].name);
- if (cmp == 0)
- {
-     infile[0] = 1;
-     infile[1] = 1;
-     trav_table_addflags (infile, info1[curr1].name, info1[curr1].type,
-      table);
-
-     curr1++;
-     curr2++;
- }
- else if (cmp < 0)
+ int more_names_exist = (nobjects1 > 0 && nobjects2 > 0) ? 1 : 0;
+ trav_table_t *table = NULL;
+ int cmp;
+ int curr1 = 0;
+ int curr2 = 0;
+ unsigned infile[2];
+ char c1, c2;
+ hsize_t nfound = 0;
+ int i;
+ 
+/*-------------------------------------------------------------------------
+ * build the list
+ *-------------------------------------------------------------------------
+ */
+ trav_table_init (&table);
+ 
+ while (more_names_exist)
  {
-     infile[0] = 1;
-     infile[1] = 0;
-     trav_table_addflags (infile, info1[curr1].name, info1[curr1].type,
-      table);
-     curr1++;
- }
- else
+  /* criteria is string compare */
+  cmp = strcmp (info1[curr1].name, info2[curr2].name);
+  if (cmp == 0)
+  {
+   infile[0] = 1;
+   infile[1] = 1;
+   trav_table_addflags (infile, info1[curr1].name, info1[curr1].type,
+    table);
+   
+   curr1++;
+   curr2++;
+  }
+  else if (cmp < 0)
+  {
+   infile[0] = 1;
+   infile[1] = 0;
+   trav_table_addflags (infile, info1[curr1].name, info1[curr1].type,
+    table);
+   curr1++;
+  }
+  else
+  {
+   infile[0] = 0;
+   infile[1] = 1;
+   trav_table_addflags (infile, info2[curr2].name, info2[curr2].type,
+    table);
+   curr2++;
+  }
+  
+  more_names_exist = (curr1 < nobjects1 && curr2 < nobjects2) ? 1 : 0;
+  
+  
+ }    /* end while */
+ 
+ /* list1 did not end */
+ if (curr1 < nobjects1)
  {
-     infile[0] = 0;
-     infile[1] = 1;
-     trav_table_addflags (infile, info2[curr2].name, info2[curr2].type,
-      table);
-     curr2++;
+  while (curr1 < nobjects1)
+  {
+   infile[0] = 1;
+   infile[1] = 0;
+   trav_table_addflags (infile, info1[curr1].name, info1[curr1].type,
+    table);
+   curr1++;
+  }
  }
-
- more_names_exist = (curr1 < nobjects1 && curr2 < nobjects2) ? 1 : 0;
-
-
-    }    /* end while */
-
-    /* list1 did not end */
-    if (curr1 < nobjects1)
-    {
- while (curr1 < nobjects1)
+ 
+ /* list2 did not end */
+ if (curr2 < nobjects2)
  {
-     infile[0] = 1;
-     infile[1] = 0;
-     trav_table_addflags (infile, info1[curr1].name, info1[curr1].type,
-      table);
-     curr1++;
+  while (curr2 < nobjects2)
+  {
+   infile[0] = 0;
+   infile[1] = 1;
+   trav_table_addflags (infile, info2[curr2].name, info2[curr2].type,
+    table);
+   curr2++;
+  }
  }
-    }
-
-    /* list2 did not end */
-    if (curr2 < nobjects2)
-    {
- while (curr2 < nobjects2)
+ 
+/*-------------------------------------------------------------------------
+ * print the list
+ *-------------------------------------------------------------------------
+ */
+ 
+ if (options->m_verbose)
  {
-     infile[0] = 0;
-     infile[1] = 1;
-     trav_table_addflags (infile, info2[curr2].name, info2[curr2].type,
-      table);
-     curr2++;
+  printf ("\n");
+  printf ("file1     file2\n");
+  printf ("---------------------------------------\n");
+  for (i = 0; i < table->nobjs; i++)
+  {
+   c1 = (table->objs[i].flags[0]) ? 'x' : ' ';
+   c2 = (table->objs[i].flags[1]) ? 'x' : ' ';
+   printf ("%5c %6c    %-15s\n", c1, c2, table->objs[i].name);
+  }
+  printf ("\n");
  }
-    }
-
-    /*-------------------------------------------------------------------------
-     * print the list
-     *-------------------------------------------------------------------------
-     */
-
-    if (options->m_verbose)
-    {
- printf ("\n");
- printf ("file1     file2\n");
- printf ("---------------------------------------\n");
- for (i = 0; i < table->nobjs; i++)
+ 
+ 
+/*-------------------------------------------------------------------------
+ * do the diff for common objects
+ *-------------------------------------------------------------------------
+ */
  {
-     c1 = (table->objs[i].flags[0]) ? 'x' : ' ';
-     c2 = (table->objs[i].flags[1]) ? 'x' : ' ';
-     printf ("%5c %6c    %-15s\n", c1, c2, table->objs[i].name);
- }
- printf ("\n");
-    }
-
-
-    /*-------------------------------------------------------------------------
-     * do the diff for common objects
-     *-------------------------------------------------------------------------
-     */
-    {
 #ifdef H5_HAVE_PARALLEL
-	char* workerTasks = malloc((g_nTasks-1) * sizeof(char));
-	int n;
-	int busyTasks=0;
-	struct diffs_found nFoundbyWorker;
-	struct diff_args args;
-	int havePrintToken = 1;
-	MPI_Status Status;
-
-	/*set all tasks as free */
-	memset(workerTasks, 1, g_nTasks-1);
+  char* workerTasks = malloc((g_nTasks-1) * sizeof(char));
+  int n;
+  int busyTasks=0;
+  struct diffs_found nFoundbyWorker;
+  struct diff_args args;
+  int havePrintToken = 1;
+  MPI_Status Status;
+  
+  /*set all tasks as free */
+  memset(workerTasks, 1, g_nTasks-1);
 #endif
-
- for (i = 0; i < table->nobjs; i++)
- {
-     if (table->objs[i].flags[0] && table->objs[i].flags[1])
-     {
+  
+  for (i = 0; i < table->nobjs; i++)
+  {
+   if (table->objs[i].flags[0] && table->objs[i].flags[1])
+   {
 #ifdef H5_HAVE_PARALLEL
-  int workerFound = 0;
+    int workerFound = 0;
 #endif /* H5_HAVE_PARALLEL */
-  options->cmn_objs = 1;
-  if(!g_Parallel)
-  {
-      nfound += diff (file1_id,
-       table->objs[i].name,
-       file2_id,
-       table->objs[i].name, options, table->objs[i].type);
-  }
+    options->cmn_objs = 1;
+    if(!g_Parallel)
+    {
+     nfound += diff (file1_id,
+      table->objs[i].name,
+      file2_id,
+      table->objs[i].name, options, table->objs[i].type);
+    }
 #ifdef H5_HAVE_PARALLEL
-  else
-  {
-h5diffdebug("beginning of big else block\n");
-      /* We're in parallel mode */
-      /* Since the data type of diff value is hsize_t which can
-       * be arbitary large such that there is no MPI type that
-       * matches it, the value is passed between processes as
-       * an array of bytes in order to be portable.  But this
-       * may not work in non-homogeneous MPI environments.
-       */
-
-      /*Set up args to pass to worker task. */
-      if(strlen(table->objs[i].name) > 255)
+    else
+    {
+     h5diffdebug("beginning of big else block\n");
+     /* We're in parallel mode */
+     /* Since the data type of diff value is hsize_t which can
+     * be arbitary large such that there is no MPI type that
+     * matches it, the value is passed between processes as
+     * an array of bytes in order to be portable.  But this
+     * may not work in non-homogeneous MPI environments.
+     */
+     
+     /*Set up args to pass to worker task. */
+     if(strlen(table->objs[i].name) > 255)
+     {
+      printf("The parallel diff only supports object names up to 255 characters\n");
+      MPI_Abort(MPI_COMM_WORLD, 0);
+     }
+     
+     strcpy(args.name, table->objs[i].name);
+     args.options = *options;
+     args.type= table->objs[i].type;
+     
+     h5diffdebug2("busyTasks=%d\n", busyTasks);
+     /* if there are any outstanding print requests, let's handle one. */
+     if(busyTasks > 0)
+     {
+      int incomingMessage;
+      /* check if any tasks freed up, and didn't need to print. */
+      MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_DONE, MPI_COMM_WORLD, &incomingMessage, &Status);
+      
+      /* first block*/
+      if(incomingMessage)
       {
-	  printf("The parallel diff only supports object names up to 255 characters\n");
-	  MPI_Abort(MPI_COMM_WORLD, 0);
+       workerTasks[Status.MPI_SOURCE-1] = 1;
+       MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_DONE, MPI_COMM_WORLD, &Status);
+       nfound += nFoundbyWorker.nfound;
+       options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
+       busyTasks--;
       }
-
-      strcpy(args.name, table->objs[i].name);
-      args.options = *options;
-      args.type= table->objs[i].type;
-
-h5diffdebug2("busyTasks=%d\n", busyTasks);
-      /* if there are any outstanding print requests, let's handle one. */
-      if(busyTasks > 0)
+      
+      /* check to see if the print token was returned. */
+      if(!havePrintToken)
       {
-	  int incomingMessage;
-	  /* check if any tasks freed up, and didn't need to print. */
-	  MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_DONE, MPI_COMM_WORLD, &incomingMessage, &Status);
-
-	  /* first block*/
-	  if(incomingMessage)
-	  {
-	      workerTasks[Status.MPI_SOURCE-1] = 1;
-	      MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_DONE, MPI_COMM_WORLD, &Status);
-	      nfound += nFoundbyWorker.nfound;
-	      options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
-	      busyTasks--;
-	  }
-
-	  /* check to see if the print token was returned. */
-	  if(!havePrintToken)
-	  {
-	      /* If we don't have the token, someone is probably sending us output */
-	      print_incoming_data();
-
-	      /* check incoming queue for token */
-	      MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &incomingMessage, &Status);
-
-	      /* incoming token implies free task. */
-	      if(incomingMessage)
-	      {
-		  workerTasks[Status.MPI_SOURCE-1] = 1;
-		  MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
-		  nfound += nFoundbyWorker.nfound;
-		  options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
-		  busyTasks--;
-		  havePrintToken = 1;
-	      }
-	  }
-
-	  /* check to see if anyone needs the print token. */
-	  if(havePrintToken)
-	  {
-	      /* check incoming queue for print token requests */
-	      MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_REQUEST, MPI_COMM_WORLD, &incomingMessage, &Status);
-	      if(incomingMessage)
-	      {
-		  MPI_Recv(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_REQUEST, MPI_COMM_WORLD, &Status);
-		  MPI_Send(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_PRINT_TOK, MPI_COMM_WORLD);
-		  havePrintToken = 0;
-	      }
-	  }
+       /* If we don't have the token, someone is probably sending us output */
+       print_incoming_data();
+       
+       /* check incoming queue for token */
+       MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &incomingMessage, &Status);
+       
+       /* incoming token implies free task. */
+       if(incomingMessage)
+       {
+        workerTasks[Status.MPI_SOURCE-1] = 1;
+        MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
+        nfound += nFoundbyWorker.nfound;
+        options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
+        busyTasks--;
+        havePrintToken = 1;
+       }
       }
-
-      /* check array of tasks to see which ones are free.
-       * Manager task never does work, so freeTasks[0] is really
-       * worker task 0. */
-
-      for(n=1; (n<g_nTasks) && !workerFound; n++)
+      
+      /* check to see if anyone needs the print token. */
+      if(havePrintToken)
       {
-	  if(workerTasks[n-1])
-	  {
-	      /* send file id's and names to first free worker */
-	      MPI_Send(&args, sizeof(struct diff_args), MPI_BYTE, n, MPI_TAG_ARGS, MPI_COMM_WORLD);
-
-	      /* increment counter for total number of prints. */
-	      busyTasks++;
-
-	      /* mark worker as busy */
-	      workerTasks[n-1] = 0;
-	      workerFound = 1;
-	  }
-
+       /* check incoming queue for print token requests */
+       MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_REQUEST, MPI_COMM_WORLD, &incomingMessage, &Status);
+       if(incomingMessage)
+       {
+        MPI_Recv(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_REQUEST, MPI_COMM_WORLD, &Status);
+        MPI_Send(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_PRINT_TOK, MPI_COMM_WORLD);
+        havePrintToken = 0;
+       }
       }
-
-
- h5diffdebug2("workerfound is %d \n", workerFound);
-      if(!workerFound)
+     }
+     
+     /* check array of tasks to see which ones are free.
+     * Manager task never does work, so freeTasks[0] is really
+     * worker task 0. */
+     
+     for(n=1; (n<g_nTasks) && !workerFound; n++)
+     {
+      if(workerTasks[n-1])
       {
-	  /* if they were all busy, we've got to wait for one free up before we can move on.
-	   * if we don't have the token, some task is currently printing so we'll wait for that task to return it. */
-
-	  if(!havePrintToken)
-	  {
-	      while(!havePrintToken) {
-		  int incomingMessage;
-		  print_incoming_data();
-		  MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &incomingMessage, &Status);
-		  if(incomingMessage)
-		  {
-		      MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
-		      havePrintToken = 1;
-		      nfound += nFoundbyWorker.nfound;
-		      options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
-		      /* send this task the work unit. */
-		      MPI_Send(&args, sizeof(struct diff_args), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_ARGS, MPI_COMM_WORLD);
-		  }
-	      }
-	  }
-   /* if we do have the token, check for task to free up, or wait for a task to request it */
-	  else
-	  {
-	      /* But first print all the data in our incoming queue */
-	      print_incoming_data(); 
-	      MPI_Probe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &Status);
-	      if(Status.MPI_TAG == MPI_TAG_DONE)
-	      {
-		  MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_DONE, MPI_COMM_WORLD, &Status);
-		  nfound += nFoundbyWorker.nfound;
-		  options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
-		  MPI_Send(&args, sizeof(struct diff_args), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_ARGS, MPI_COMM_WORLD);
-	      }
-	      else if(Status.MPI_TAG == MPI_TAG_TOK_REQUEST)
-	      {
-		  int incomingMessage;
-		  MPI_Recv(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_REQUEST, MPI_COMM_WORLD, &Status);
-		  MPI_Send(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_PRINT_TOK, MPI_COMM_WORLD);
-
-		  do
-		  {
-		      MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &incomingMessage, &Status);
-
-		      print_incoming_data();
-		  }
-		  while(!incomingMessage);
-
-
-		  MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
-		  nfound += nFoundbyWorker.nfound;
-		  options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
-		  MPI_Send(&args, sizeof(struct diff_args), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_ARGS, MPI_COMM_WORLD);
-	      }
-	      else
-	      {
-		  printf("ERROR: Invalid tag (%d) received \n", Status.MPI_TAG);
-		  MPI_Abort(MPI_COMM_WORLD, 0);
-		  MPI_Finalize();
-	      }
-	  }
+       /* send file id's and names to first free worker */
+       MPI_Send(&args, sizeof(struct diff_args), MPI_BYTE, n, MPI_TAG_ARGS, MPI_COMM_WORLD);
+       
+       /* increment counter for total number of prints. */
+       busyTasks++;
+       
+       /* mark worker as busy */
+       workerTasks[n-1] = 0;
+       workerFound = 1;
+      }
+      
+     }
+     
+     
+     h5diffdebug2("workerfound is %d \n", workerFound);
+     if(!workerFound)
+     {
+     /* if they were all busy, we've got to wait for one free up before we can move on.
+      * if we don't have the token, some task is currently printing so we'll wait for that task to return it. */
+      
+      if(!havePrintToken)
+      {
+       while(!havePrintToken) {
+        int incomingMessage;
+        print_incoming_data();
+        MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &incomingMessage, &Status);
+        if(incomingMessage)
+        {
+         MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
+         havePrintToken = 1;
+         nfound += nFoundbyWorker.nfound;
+         options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
+         /* send this task the work unit. */
+         MPI_Send(&args, sizeof(struct diff_args), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_ARGS, MPI_COMM_WORLD);
+        }
+       }
+      }
+      /* if we do have the token, check for task to free up, or wait for a task to request it */
+      else
+      {
+       /* But first print all the data in our incoming queue */
+       print_incoming_data(); 
+       MPI_Probe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &Status);
+       if(Status.MPI_TAG == MPI_TAG_DONE)
+       {
+        MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_DONE, MPI_COMM_WORLD, &Status);
+        nfound += nFoundbyWorker.nfound;
+        options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
+        MPI_Send(&args, sizeof(struct diff_args), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_ARGS, MPI_COMM_WORLD);
+       }
+       else if(Status.MPI_TAG == MPI_TAG_TOK_REQUEST)
+       {
+        int incomingMessage;
+        MPI_Recv(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_REQUEST, MPI_COMM_WORLD, &Status);
+        MPI_Send(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_PRINT_TOK, MPI_COMM_WORLD);
+        
+        do
+        {
+         MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &incomingMessage, &Status);
+         
+         print_incoming_data();
+        }
+        while(!incomingMessage);
+        
+        
+        MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
+        nfound += nFoundbyWorker.nfound;
+        options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
+        MPI_Send(&args, sizeof(struct diff_args), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_ARGS, MPI_COMM_WORLD);
+       }
+       else
+       {
+        printf("ERROR: Invalid tag (%d) received \n", Status.MPI_TAG);
+        MPI_Abort(MPI_COMM_WORLD, 0);
+        MPI_Finalize();
+       }
       }
+     }
   }
 #endif /* H5_HAVE_PARALLEL */
      }
  }
  h5diffdebug("done with for loop\n");
-
+ 
 #ifdef H5_HAVE_PARALLEL
  if(g_Parallel)
  {
-     while(busyTasks > 0) /* make sure all tasks are done */
+  while(busyTasks > 0) /* make sure all tasks are done */
+  {
+   MPI_Probe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &Status);
+   if(Status.MPI_TAG == MPI_TAG_DONE)
+   {
+    MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_DONE, MPI_COMM_WORLD, &Status);
+    nfound += nFoundbyWorker.nfound;
+    options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
+    busyTasks--;
+   }
+   else if(Status.MPI_TAG == MPI_TAG_TOK_RETURN)
+   {
+    MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_DONE, MPI_COMM_WORLD, &Status);
+    nfound += nFoundbyWorker.nfound;
+    options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
+    busyTasks--;
+    havePrintToken = 1;
+   }
+   else if(Status.MPI_TAG == MPI_TAG_TOK_REQUEST)
+   {
+    MPI_Recv(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_REQUEST, MPI_COMM_WORLD, &Status);
+    if(havePrintToken)
+    {
+     int incomingMessage;
+     MPI_Send(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_PRINT_TOK, MPI_COMM_WORLD);
+     do
      {
-	 MPI_Probe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &Status);
-	 if(Status.MPI_TAG == MPI_TAG_DONE)
-	 {
-	     MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_DONE, MPI_COMM_WORLD, &Status);
-	     nfound += nFoundbyWorker.nfound;
-	     options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
-	     busyTasks--;
-	 }
-	 else if(Status.MPI_TAG == MPI_TAG_TOK_RETURN)
-	 {
-	     MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_DONE, MPI_COMM_WORLD, &Status);
-	     nfound += nFoundbyWorker.nfound;
-	     options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
-	     busyTasks--;
-	     havePrintToken = 1;
-	 }
-	 else if(Status.MPI_TAG == MPI_TAG_TOK_REQUEST)
-	 {
-	     MPI_Recv(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_REQUEST, MPI_COMM_WORLD, &Status);
-	     if(havePrintToken)
-	     {
-		 int incomingMessage;
-		 MPI_Send(NULL, 0, MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_PRINT_TOK, MPI_COMM_WORLD);
-		 do
-		 {
-		     MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &incomingMessage, &Status);
-
-		     print_incoming_data();
-		 }
-		 while(!incomingMessage);
-		 MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
-		 nfound += nFoundbyWorker.nfound;
-		 options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
-		 busyTasks--;
-	     }
-	     else /* someone else must have it...wait for them to return it, then give it to the task that just asked for it. */
-	     {
-		 int source = Status.MPI_SOURCE;
-		 int incomingMessage;
-		 do
-		 {
-		     MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &incomingMessage, &Status);
-
-		     print_incoming_data();
-		 }
-		 while(!incomingMessage);
-
-
-		 MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
-		 nfound += nFoundbyWorker.nfound;
-		 options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
-		 busyTasks--;
-		 MPI_Send(NULL, 0, MPI_BYTE, source, MPI_TAG_PRINT_TOK, MPI_COMM_WORLD);
-	     }
-	 }
-	 else if(Status.MPI_TAG == MPI_TAG_TOK_RETURN)
-	 {
-	     MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
-	     nfound += nFoundbyWorker.nfound;
-	     options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
-	     busyTasks--;
-	     havePrintToken = 1;
-	 }
-	 else if(Status.MPI_TAG == MPI_TAG_PRINT_DATA)
-	 {
-	     char  data[PRINT_DATA_MAX_SIZE+1];
-	     memset(data, 0, PRINT_DATA_MAX_SIZE+1);
-
-	     MPI_Recv(data, PRINT_DATA_MAX_SIZE, MPI_CHAR, Status.MPI_SOURCE, MPI_TAG_PRINT_DATA, MPI_COMM_WORLD, &Status);
-
-	     printf("%s", data);
-	 }
-	 else
-	 {
-	     printf("ph5diff-manager: ERROR!! Invalid tag (%d) received \n", Status.MPI_TAG);
-	     MPI_Abort(MPI_COMM_WORLD, 0);
-	 }
+      MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &incomingMessage, &Status);
+      
+      print_incoming_data();
      }
-
-     for(i=1; i<g_nTasks; i++)
-	 MPI_Send(NULL, 0, MPI_BYTE, i, MPI_TAG_END, MPI_COMM_WORLD);
-
-     /* Print any final data waiting in our queue */
-     print_incoming_data();
-
+     while(!incomingMessage);
+     MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
+     nfound += nFoundbyWorker.nfound;
+     options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
+     busyTasks--;
+    }
+    else /* someone else must have it...wait for them to return it, then give it to the task that just asked for it. */
+    {
+     int source = Status.MPI_SOURCE;
+     int incomingMessage;
+     do
+     {
+      MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &incomingMessage, &Status);
+      
+      print_incoming_data();
+     }
+     while(!incomingMessage);
+     
+     
+     MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
+     nfound += nFoundbyWorker.nfound;
+     options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
+     busyTasks--;
+     MPI_Send(NULL, 0, MPI_BYTE, source, MPI_TAG_PRINT_TOK, MPI_COMM_WORLD);
+    }
+   }
+   else if(Status.MPI_TAG == MPI_TAG_TOK_RETURN)
+   {
+    MPI_Recv(&nFoundbyWorker, sizeof(nFoundbyWorker), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &Status);
+    nfound += nFoundbyWorker.nfound;
+    options->not_cmp = options->not_cmp | nFoundbyWorker.not_cmp;
+    busyTasks--;
+    havePrintToken = 1;
+   }
+   else if(Status.MPI_TAG == MPI_TAG_PRINT_DATA)
+   {
+    char  data[PRINT_DATA_MAX_SIZE+1];
+    memset(data, 0, PRINT_DATA_MAX_SIZE+1);
+    
+    MPI_Recv(data, PRINT_DATA_MAX_SIZE, MPI_CHAR, Status.MPI_SOURCE, MPI_TAG_PRINT_DATA, MPI_COMM_WORLD, &Status);
+    
+    printf("%s", data);
+   }
+   else
+   {
+    printf("ph5diff-manager: ERROR!! Invalid tag (%d) received \n", Status.MPI_TAG);
+    MPI_Abort(MPI_COMM_WORLD, 0);
+   }
+  }
+  
+  for(i=1; i<g_nTasks; i++)
+   MPI_Send(NULL, 0, MPI_BYTE, i, MPI_TAG_END, MPI_COMM_WORLD);
+  
+  /* Print any final data waiting in our queue */
+  print_incoming_data();
+  
  }
-h5diffdebug("done with if block\n");
-
+ h5diffdebug("done with if block\n");
+ 
  free(workerTasks);
 #endif /* H5_HAVE_PARALLEL */
-    }
-    /* free table */
-    trav_table_free (table);
-
-
-    /*-------------------------------------------------------------------------
-     * do the diff for the root.
-     * this is a special case, we get an ID for the root group and call diff()
-     * with this ID; it compares only the root group attributes
-     *-------------------------------------------------------------------------
-     */
-
-    /* the manager can do this. */
-    nfound += diff (file1_id, "/", file2_id, "/", options, H5G_GROUP);
-
-    return nfound;
+ }
+    
+ /* free table */
+ trav_table_free (table);
+    
+ 
+/*-------------------------------------------------------------------------
+ * do the diff for the root.
+ * this is a special case, we get an ID for the root group and call diff()
+ * with this ID; it compares only the root group attributes
+ *-------------------------------------------------------------------------
+ */
+ 
+ /* the manager can do this. */
+ nfound += diff (file1_id, "/", file2_id, "/", options, H5G_GROUP);
+ 
+ return nfound;
 }
 
 
@@ -803,62 +802,62 @@ h5diffdebug("done with if block\n");
  *-------------------------------------------------------------------------
  */
 
-hsize_t
-diff_compare (hid_t file1_id,
- const char *file1_name,
- const char *obj1_name,
- int nobjects1,
- trav_info_t * info1,
- hid_t file2_id,
- const char *file2_name,
- const char *obj2_name,
- int nobjects2, trav_info_t * info2, diff_opt_t * options)
+hsize_t diff_compare (hid_t file1_id,
+                      const char *file1_name,
+                      const char *obj1_name,
+                      int nobjects1,
+                      trav_info_t * info1,
+                      hid_t file2_id,
+                      const char *file2_name,
+                      const char *obj2_name,
+                      int nobjects2, 
+                      trav_info_t * info2, 
+                      diff_opt_t * options)
 {
-
-    int f1 = 0, f2 = 0;
-    hsize_t nfound = 0;
-
-    int i = h5trav_getindex (obj1_name, nobjects1, info1);
-    int j = h5trav_getindex (obj2_name, nobjects2, info2);
-
-    if (i == -1)
-    {
- parallel_print ("Object <%s> could not be found in <%s>\n", obj1_name,
-  file1_name);
- f1 = 1;
-    }
-     if (j == -1)
-     {
+ int f1 = 0, f2 = 0;
+ hsize_t nfound = 0;
+ 
+ int i = h5trav_getindex (obj1_name, nobjects1, info1);
+ int j = h5trav_getindex (obj2_name, nobjects2, info2);
+ 
+ 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)
-     {
+ }
+ if (f1 || f2)
+ {
   options->err_stat = 1;
   return 0;
-     }
-
-     /* use the name with "/" first, as obtained by iterator function */
-     obj1_name = info1[i].name;
-  obj2_name = info2[j].name;
-
-  /* objects are not the same type */
-  if (info1[i].type != info2[j].type)
-    {
-      if (options->m_verbose)
- parallel_print
+ }
+ 
+ /* use the name with "/" first, as obtained by iterator function */
+ obj1_name = info1[i].name;
+ obj2_name = info2[j].name;
+ 
+ /* objects are not the same type */
+ if (info1[i].type != info2[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[i].type), obj2_name,
-    get_type (info2[j].type));
-    options->not_cmp=1;
-      return 0;
-    }
-
-  nfound =
-    diff (file1_id, obj1_name, file2_id, obj2_name, options, info1[i].type);
-
-  return nfound;
+   obj1_name, get_type (info1[i].type), obj2_name,
+   get_type (info2[j].type));
+  options->not_cmp=1;
+  return 0;
+ }
+ 
+ nfound =
+  diff (file1_id, obj1_name, file2_id, obj2_name, options, info1[i].type);
+ 
+ return nfound;
 }
 
 
@@ -881,219 +880,220 @@ diff_compare (hid_t file1_id,
  *-------------------------------------------------------------------------
  */
 
-hsize_t
-diff (hid_t file1_id,
-      const char *path1,
-      hid_t file2_id, const char *path2, diff_opt_t * options, H5G_obj_t type)
+hsize_t diff (hid_t file1_id,
+              const char *path1,
+              hid_t file2_id, 
+              const char *path2, 
+              diff_opt_t * options, 
+              H5G_obj_t type)
 {
-    hid_t       type1_id=(-1);
-    hid_t       type2_id=(-1);
-    hid_t       grp1_id=(-1);
-    hid_t       grp2_id=(-1);
-    int ret;
-    H5G_stat_t sb1;
-    H5G_stat_t sb2;
-    hsize_t nfound = 0;
-
-    switch (type)
+ hid_t       type1_id=(-1);
+ hid_t       type2_id=(-1);
+ hid_t       grp1_id=(-1);
+ hid_t       grp2_id=(-1);
+ int ret;
+ H5G_stat_t sb1;
+ H5G_stat_t sb2;
+ hsize_t nfound = 0;
+ 
+ switch (type)
+ {
+/*-------------------------------------------------------------------------
+ * H5G_DATASET
+ *-------------------------------------------------------------------------
+ */
+ case H5G_DATASET:
+  
+/*-------------------------------------------------------------------------
+ * verbose, always print name
+ *-------------------------------------------------------------------------
+ */
+  if (options->m_verbose)
+  {
+   if (print_objname (options, (hsize_t)1))
+    parallel_print("Dataset:     <%s> and <%s>\n", path1, path2);
+   nfound = diff_dataset (file1_id, file2_id, path1, path2, options);
+   /* always print the number of differences found */
+   print_found(nfound);
+  }
+ /*-------------------------------------------------------------------------
+  * non verbose, check first if we have differences
+  *-------------------------------------------------------------------------
+  */
+  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 (print_objname (options, nfound))
+      parallel_print("Dataset:     <%s> and <%s>\n", path1, path2);
+     nfound = diff_dataset (file1_id, file2_id, path1, path2, options);
+     /* print the number of differences found only when found
+     this is valid for the default mode and report mode */
+     print_found(nfound);
+    }  /*if nfound */
+   } /*if quiet */
+   
  /*-------------------------------------------------------------------------
-  * H5G_DATASET
+  * quiet mode, just count differences
   *-------------------------------------------------------------------------
   */
-    case H5G_DATASET:
-
+   else
+   {
+    nfound = diff_dataset (file1_id, file2_id, path1, path2, options);
+   }
+  }   /*else verbose */
+  
+  break;
+  
  /*-------------------------------------------------------------------------
-  * verbose, always print name
+  * H5G_TYPE
   *-------------------------------------------------------------------------
   */
-     if (options->m_verbose)
-     {
-      if (print_objname (options, (hsize_t)1))
-       parallel_print("Dataset:     <%s> and <%s>\n", path1, path2);
-      nfound = diff_dataset (file1_id, file2_id, path1, path2, options);
-      /* always print the number of differences found */
-      print_found(nfound);
-     }
+ case H5G_TYPE:
+  if ((type1_id = H5Topen (file1_id, path1)) < 0)
+   goto out;
+  if ((type2_id = H5Topen (file2_id, path2)) < 0)
+   goto out;
+  
+  if ((ret = H5Tequal (type1_id, type2_id)) < 0)
+   goto out;
+  
+  /* if H5Tequal is > 0 then the datatypes refer to the same datatype */
+  nfound = (ret > 0) ? 0 : 1;
+  
+  if (print_objname (options, nfound))
+   parallel_print("Datatype:    <%s> and <%s>\n", path1, path2);
+  
+  /* always print the number of differences found in verbose mode */
+  if (options->m_verbose)
+   print_found(nfound);
+  
  /*-------------------------------------------------------------------------
-  * non verbose, check first if we have differences
+  * compare attributes
+  * the if condition refers to cases when the dataset is a referenced object
   *-------------------------------------------------------------------------
   */
-     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 (print_objname (options, nfound))
-         parallel_print("Dataset:     <%s> and <%s>\n", path1, path2);
-        nfound = diff_dataset (file1_id, file2_id, path1, path2, options);
-        /* print the number of differences found only when found
-           this is valid for the default mode and report mode */
-        print_found(nfound);
-       }  /*if nfound */
-      }   /*if quiet */
-
+  if (path1)
+   diff_attr (type1_id, type2_id, path1, path2, options);
+  
+  if (H5Tclose (type1_id) < 0)
+   goto out;
+  if (H5Tclose (type2_id) < 0)
+   goto out;
+  
+  break;
+  
  /*-------------------------------------------------------------------------
-  * quiet mode, just count differences
+  * H5G_GROUP
   *-------------------------------------------------------------------------
   */
-      else
-      {
-       nfound = diff_dataset (file1_id, file2_id, path1, path2, options);
-      }
-     }   /*else verbose */
-
-     break;
-
-     /*-------------------------------------------------------------------------
-      * H5G_TYPE
-      *-------------------------------------------------------------------------
-      */
- case H5G_TYPE:
-     if ((type1_id = H5Topen (file1_id, path1)) < 0)
-  goto out;
-     if ((type2_id = H5Topen (file2_id, path2)) < 0)
-  goto out;
-
-     if ((ret = H5Tequal (type1_id, type2_id)) < 0)
-  goto out;
-
-     /* if H5Tequal is > 0 then the datatypes refer to the same datatype */
-     nfound = (ret > 0) ? 0 : 1;
-
-     if (print_objname (options, nfound))
-      parallel_print("Datatype:    <%s> and <%s>\n", path1, path2);
-
-     /* always print the number of differences found in verbose mode */
-     if (options->m_verbose)
-      print_found(nfound);
-
-     /*-------------------------------------------------------------------------
-      * compare attributes
-      * the if condition refers to cases when the dataset is a referenced object
-      *-------------------------------------------------------------------------
-      */
-         if (path1)
-    diff_attr (type1_id, type2_id, path1, path2, options);
-
-     if (H5Tclose (type1_id) < 0)
-  goto out;
-     if (H5Tclose (type2_id) < 0)
-  goto out;
-
-     break;
-
-     /*-------------------------------------------------------------------------
-      * H5G_GROUP
-      *-------------------------------------------------------------------------
-      */
  case H5G_GROUP:
-     if ((grp1_id = H5Gopen (file1_id, path1)) < 0)
-  goto out;
-     if ((grp2_id = H5Gopen (file2_id, path2)) < 0)
-  goto out;
-
-     ret = HDstrcmp (path1, path2);
-
-     /* if "path1" != "path2" then the groups are "different" */
-     nfound = (ret != 0) ? 1 : 0;
-
-     if (print_objname (options, nfound))
-      parallel_print("Group:       <%s> and <%s>\n", path1, path2);
-
-     /* always print the number of differences found in verbose mode */
-     if (options->m_verbose)
-      print_found(nfound);
-
-     /*-------------------------------------------------------------------------
-      * compare attributes
-      * the if condition refers to cases when the dataset is a referenced object
-      *-------------------------------------------------------------------------
-      */
-     if (path1)
-  diff_attr (grp1_id, grp2_id, path1, path2, options);
-
-     if (H5Gclose (grp1_id) < 0)
-  goto out;
-     if (H5Gclose (grp2_id) < 0)
-  goto out;
-
-     break;
-
-
-     /*-------------------------------------------------------------------------
-      * H5G_LINK
-      *-------------------------------------------------------------------------
-      */
+  if ((grp1_id = H5Gopen (file1_id, path1)) < 0)
+   goto out;
+  if ((grp2_id = H5Gopen (file2_id, path2)) < 0)
+   goto out;
+  
+  ret = HDstrcmp (path1, path2);
+  
+  /* if "path1" != "path2" then the groups are "different" */
+  nfound = (ret != 0) ? 1 : 0;
+  
+  if (print_objname (options, nfound))
+   parallel_print("Group:       <%s> and <%s>\n", path1, path2);
+  
+  /* always print the number of differences found in verbose mode */
+  if (options->m_verbose)
+   print_found(nfound);
+  
+ /*-------------------------------------------------------------------------
+  * compare attributes
+  * the if condition refers to cases when the dataset is a referenced object
+  *-------------------------------------------------------------------------
+  */
+  if (path1)
+   diff_attr (grp1_id, grp2_id, path1, path2, options);
+  
+  if (H5Gclose (grp1_id) < 0)
+   goto out;
+  if (H5Gclose (grp2_id) < 0)
+   goto out;
+  
+  break;
+  
+  
+ /*-------------------------------------------------------------------------
+  * H5G_LINK
+  *-------------------------------------------------------------------------
+  */
  case H5G_LINK:
- {
-    char *buf1 = NULL;
-    char *buf2 = NULL;
-
-    if (H5Gget_objinfo (file1_id, path1, FALSE, &sb1) < 0)
-        goto out;
-    if (H5Gget_objinfo (file1_id, path1, FALSE, &sb2) < 0)
-        goto out;
-
-     buf1 = HDmalloc (sb1.u.slink.linklen);
-     buf2 = HDmalloc (sb2.u.slink.linklen);
-
-     if (H5Gget_linkval (file1_id, path1, sb1.u.slink.linklen, buf1) < 0)
-        goto out;
-     if (H5Gget_linkval (file2_id, path2, sb1.u.slink.linklen, buf2) < 0)
-        goto out;
-
-     ret = HDstrcmp (buf1, buf2);
-
-     /* if "buf1" != "buf2" then the links are "different" */
-     nfound = (ret != 0) ? 1 : 0;
-
-     if (print_objname (options, nfound))
-      parallel_print("Soft Link:        <%s> and <%s>\n", path1, path2);
-
-     /* always print the number of differences found in verbose mode */
-     if (options->m_verbose)
-      print_found(nfound);
-
-      HDfree (buf1);
-      HDfree (buf2);
- }
-     break;
-
+  {
+   char *buf1 = NULL;
+   char *buf2 = NULL;
+   
+   if (H5Gget_objinfo (file1_id, path1, FALSE, &sb1) < 0)
+    goto out;
+   if (H5Gget_objinfo (file1_id, path1, FALSE, &sb2) < 0)
+    goto out;
+   
+   buf1 = HDmalloc (sb1.u.slink.linklen);
+   buf2 = HDmalloc (sb2.u.slink.linklen);
+   
+   if (H5Gget_linkval (file1_id, path1, sb1.u.slink.linklen, buf1) < 0)
+    goto out;
+   if (H5Gget_linkval (file2_id, path2, sb1.u.slink.linklen, buf2) < 0)
+    goto out;
+   
+   ret = HDstrcmp (buf1, buf2);
+   
+   /* if "buf1" != "buf2" then the links are "different" */
+   nfound = (ret != 0) ? 1 : 0;
+   
+   if (print_objname (options, nfound))
+    parallel_print("Soft Link:        <%s> and <%s>\n", path1, path2);
+   
+   /* always print the number of differences found in verbose mode */
+   if (options->m_verbose)
+    print_found(nfound);
+   
+   HDfree (buf1);
+   HDfree (buf2);
+  }
+  break;
+  
  default:
-     nfound = 0;
-     if (options->m_verbose)
-     {
-  parallel_print("Comparison not supported: <%s> and <%s> are of type %s\n",
-   path1, path2, get_type (type));
-  options->not_cmp=1;
-     }
-
-     break;
-    }
-
-
+  nfound = 0;
+  if (options->m_verbose)
+  {
+   parallel_print("Comparison not supported: <%s> and <%s> are of type %s\n",
+    path1, path2, get_type (type));
+   options->not_cmp=1;
+  }
+  
+  break;
+ } /* switch */
+    
+    
 out:
-
-    /* close */
-    /* disable error reporting */
-    H5E_BEGIN_TRY
-    {
- H5Tclose (type1_id);
- H5Tclose (type2_id);
- H5Gclose (grp1_id);
- H5Tclose (grp2_id);
- /* enable error reporting */
-    }
-    H5E_END_TRY;
-
-    return nfound;
+ 
+ /* close */
+ /* disable error reporting */
+ H5E_BEGIN_TRY
+ {
+  H5Tclose (type1_id);
+  H5Tclose (type2_id);
+  H5Gclose (grp1_id);
+  H5Tclose (grp2_id);
+  /* enable error reporting */
+ }
+ H5E_END_TRY;
+ return nfound;
 }
 
 
diff --git a/tools/lib/h5diff.h b/tools/lib/h5diff.h
index ffe7101..c8536b4 100644
--- a/tools/lib/h5diff.h
+++ b/tools/lib/h5diff.h
@@ -18,12 +18,6 @@
 #include "hdf5.h"
 #include "h5trav.h"
 
-
-#if 0
-#define H5DIFF_DEBUG
-#endif
-
-
 /*-------------------------------------------------------------------------
  * command line options
  *-------------------------------------------------------------------------
@@ -167,14 +161,6 @@ const char* get_sign(H5T_sign_t sign);
 void        print_dims( int r, hsize_t *d );
 int         print_objname(diff_opt_t *options, hsize_t nfound);
 
-
-#if defined (H5DIFF_DEBUG)
-void print_sizes( const char *obj1, const char *obj2,
- hid_t f_type1, hid_t f_type2,
- hid_t m_type1, hid_t m_type2 );
-#endif
-
-
 hsize_t diff_native_uchar(unsigned char *mem1,
                           unsigned char *mem2,
                           hsize_t       i,
diff --git a/tools/lib/h5diff_array.c b/tools/lib/h5diff_array.c
index 677072c..ed74fd3 100644
--- a/tools/lib/h5diff_array.c
+++ b/tools/lib/h5diff_array.c
@@ -35,13 +35,12 @@
 
 /* with -p option */
 #define F_FORMAT_P    "%-15.10g %-15.10g %-15.10g %-14.10g\n"
-#define I_FORMAT_P "%-15d %-15d %-15d %-14f\n"
-/*#define I_FORMAT_P    "%-15d %-15d %-15d %-14d\n"*/
-#define UI_FORMAT_P   "%-15u %-15u %-15u %-14u\n"
-#define LI_FORMAT_P   "%-15ld %-15ld %-15ld %-14ld\n"
-#define ULI_FORMAT_P  "%-15lu %-15lu %-15lu %-14lu\n"
-#define LLI_FORMAT_P  "%-15"H5_PRINTF_LL_WIDTH"d %-15"H5_PRINTF_LL_WIDTH"d %-15"H5_PRINTF_LL_WIDTH"d\n"
-#define ULLI_FORMAT_P "%-15"H5_PRINTF_LL_WIDTH"u %-15"H5_PRINTF_LL_WIDTH"u %-15"H5_PRINTF_LL_WIDTH"u\n"
+#define I_FORMAT_P    "%-15d %-15d %-15d %-14f\n"
+#define UI_FORMAT_P   "%-15u %-15u %-15u %-14f\n"
+#define LI_FORMAT_P   "%-15ld %-15ld %-15ld %-14f\n"
+#define ULI_FORMAT_P  "%-15lu %-15lu %-15lu %-14f\n"
+#define LLI_FORMAT_P  "%-15"H5_PRINTF_LL_WIDTH"d %-15"H5_PRINTF_LL_WIDTH"d %-15"H5_PRINTF_LL_WIDTH"d %-14"H5_PRINTF_LL_WIDTH"f\n"
+#define ULLI_FORMAT_P "%-15"H5_PRINTF_LL_WIDTH"u %-15"H5_PRINTF_LL_WIDTH"u %-15"H5_PRINTF_LL_WIDTH"d %-14"H5_PRINTF_LL_WIDTH"u\n"
 #define SPACES        "          "
 
 
@@ -129,22 +128,6 @@ void print_pos( int        *ph,       /* print header */
 }
 
 
-static 
-void print_schar( int *ph, diff_opt_t *options, hsize_t i, hsize_t *acc, hsize_t *pos, 
-                  int rank, const char *obj1, const char *obj2,
-                  char temp1_char, char temp2_char)
-{
- if ( print_data(options) )
- {
-  print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
-  parallel_print(SPACES);
-  parallel_print(I_FORMAT,temp1_char,temp2_char,abs(temp1_char-temp2_char));
- }
- 
-}
-
-
-
 /*-------------------------------------------------------------------------
  * Function: diff_array
  *
@@ -761,13 +744,16 @@ hsize_t diff_datum(void       *_mem1,
    /* !-d and -p */
    else if (!options->d && options->p)
    {
-    if ( temp1_char!=0 && abs(1-temp2_char/temp1_char) > options->percent )
+    PER(temp1_char,temp2_char);
+    if ( per > options->percent )
     {
      if ( print_data(options) )
      {
       print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
       parallel_print(SPACES);
-      parallel_print(I_FORMAT_P,temp1_char,temp2_char,abs(temp1_char-temp2_char),abs(1-temp2_char/temp1_char));
+      parallel_print(I_FORMAT_P,temp1_char,temp2_char,
+       abs(temp1_char-temp2_char),
+       per);
      }
      nfound++;
     }
@@ -775,14 +761,16 @@ hsize_t diff_datum(void       *_mem1,
    /* -d and -p */
    else if ( options->d && options->p)
    {
-    if ( temp1_char!=0 && abs(1-temp2_char/temp1_char) > options->percent &&
-     abs(temp1_char-temp2_char) > options->delta )
+    PER(temp1_char,temp2_char);
+    if ( per > options->percent && abs(temp1_char-temp2_char) > options->delta )
     {
      if ( print_data(options) )
      {
       print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
       parallel_print(SPACES);
-      parallel_print(I_FORMAT_P,temp1_char,temp2_char,abs(temp1_char-temp2_char), abs(1-temp2_char/temp1_char));
+      parallel_print(I_FORMAT_P,temp1_char,temp2_char,
+       abs(temp1_char-temp2_char),
+       per);
      }
      nfound++;
     }
@@ -829,13 +817,16 @@ hsize_t diff_datum(void       *_mem1,
    /* !-d and -p */
    else if (!options->d && options->p)
    {
-    if ( temp1_uchar!=0 && abs(1-temp2_uchar/temp1_uchar) > options->percent )
+    PER(temp1_uchar,temp2_uchar);
+    if ( per > options->percent )
     {
      if ( print_data(options) )
      {
       print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
       parallel_print(SPACES);
-      parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,abs(temp1_uchar-temp2_uchar), abs(1-temp2_uchar/temp1_uchar));
+      parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,
+       abs(temp1_uchar-temp2_uchar), 
+       per);
      }
      nfound++;
     }
@@ -843,14 +834,16 @@ hsize_t diff_datum(void       *_mem1,
    /* -d and -p */
    else if ( options->d && options->p)
    {
-    if ( temp1_uchar!=0 && abs(1-temp2_uchar/temp1_uchar) > options->percent &&
-     abs(temp1_uchar-temp2_uchar) > options->delta )
+    PER(temp1_uchar,temp2_uchar);
+    if ( per > options->percent && abs(temp1_uchar-temp2_uchar) > options->delta )
     {
      if ( print_data(options) )
      {
       print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
       parallel_print(SPACES);
-      parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,abs(temp1_uchar-temp2_uchar), abs(1-temp2_uchar/temp1_uchar));
+      parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,
+       abs(temp1_uchar-temp2_uchar), 
+       per);
      }
      nfound++;
     }
@@ -862,7 +855,6 @@ hsize_t diff_datum(void       *_mem1,
      print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
      parallel_print(SPACES);
      parallel_print(I_FORMAT,temp1_uchar,temp2_uchar,abs(temp1_uchar-temp2_uchar));
-     
     }
     nfound++;
    }
@@ -900,13 +892,16 @@ hsize_t diff_datum(void       *_mem1,
    /* !-d and -p */
    else if (!options->d && options->p)
    {
-    if ( temp1_short!=0 && abs(1-temp2_short/temp1_short) > options->percent )
+    PER(temp1_short,temp2_short);
+    if ( per > options->percent )
     {
      if ( print_data(options) )
      {
       print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
       parallel_print(SPACES);
-      parallel_print(I_FORMAT_P,temp1_short,temp2_short,abs(temp1_short-temp2_short),  abs(1-temp2_short/temp1_short));
+      parallel_print(I_FORMAT_P,temp1_short,temp2_short,
+       abs(temp1_short-temp2_short),
+       per);
      }
      nfound++;
     }
@@ -914,14 +909,16 @@ hsize_t diff_datum(void       *_mem1,
    /* -d and -p */
    else if ( options->d && options->p)
    {
-    if ( temp1_short!=0 && abs(1-temp2_short/temp1_short) > options->percent &&
-     abs(temp1_short-temp2_short) > options->delta )
+    PER(temp1_short,temp2_short);
+    if ( per > options->percent && abs(temp1_short-temp2_short) > options->delta )
     {
      if ( print_data(options) )
      {
       print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
       parallel_print(SPACES);
-      parallel_print(I_FORMAT_P,temp1_short,temp2_short,abs(temp1_short-temp2_short),  abs(1-temp2_short/temp1_short));
+      parallel_print(I_FORMAT_P,temp1_short,temp2_short,
+       abs(temp1_short-temp2_short),
+       per);
      }
      nfound++;
     }
@@ -971,15 +968,16 @@ hsize_t diff_datum(void       *_mem1,
    /* !-d and -p */
    else if (!options->d && options->p)
    {
-    if ( temp1_ushort!=0 && abs(1-temp2_ushort/temp1_ushort) > options->percent )
+    PER(temp1_ushort,temp2_ushort);
+    if ( per > options->percent )
     {
-     
      if ( print_data(options) )
      {
       print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
-      
       parallel_print(SPACES);
-      parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,abs(temp1_ushort-temp2_ushort),  abs(1-temp2_ushort/temp1_ushort));
+      parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,
+       abs(temp1_ushort-temp2_ushort),
+       per);
      }
      nfound++;
     }
@@ -987,23 +985,22 @@ hsize_t diff_datum(void       *_mem1,
    /* -d and -p */
    else if ( options->d && options->p)
    {
-    if ( temp1_ushort!=0 && abs(1-temp2_ushort/temp1_ushort) > options->percent &&
-     abs(temp1_ushort-temp2_ushort) > options->delta )
+    PER(temp1_ushort,temp2_ushort);
+    if ( per > options->percent && abs(temp1_ushort-temp2_ushort) > options->delta )
     {
-     
      if ( print_data(options) )
      {
       print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
-      
       parallel_print(SPACES);
-      parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,abs(temp1_ushort-temp2_ushort),  abs(1-temp2_ushort/temp1_ushort));
+      parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,
+       abs(temp1_ushort-temp2_ushort),
+       per);
      }
      nfound++;
     }
    }
    else if (temp1_ushort != temp2_ushort)
    {
-    
     if ( print_data(options) )
     {
      print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1012,8 +1009,6 @@ hsize_t diff_datum(void       *_mem1,
     }
     nfound++;
    }
-   
-   
   } /*H5T_NATIVE_USHORT*/
   
   
@@ -1035,7 +1030,6 @@ hsize_t diff_datum(void       *_mem1,
    {
     if (abs(temp1_int-temp2_int) > options->delta)
     {
-     
      if ( print_data(options) )
      {
       print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1048,7 +1042,6 @@ hsize_t diff_datum(void       *_mem1,
    /* !-d and -p */
    else if (!options->d && options->p)
    {
-    
     PER(temp1_int,temp2_int);
     if ( per > options->percent )
     {
@@ -1057,7 +1050,9 @@ hsize_t diff_datum(void       *_mem1,
       print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
       
       parallel_print(SPACES);
-      parallel_print(I_FORMAT_P,temp1_int,temp2_int,abs(temp1_int-temp2_int),per);
+      parallel_print(I_FORMAT_P,temp1_int,temp2_int,
+       abs(temp1_int-temp2_int),
+       per);
      }
      nfound++;
     }
@@ -1068,20 +1063,19 @@ hsize_t diff_datum(void       *_mem1,
     PER(temp1_int,temp2_int);
     if ( per > options->percent && abs(temp1_int-temp2_int) > options->delta )
     {
-     
      if ( print_data(options) )
      {
       print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
-      
       parallel_print(SPACES);
-      parallel_print(I_FORMAT_P,temp1_int,temp2_int,abs(temp1_int-temp2_int),  abs(1-temp2_int/temp1_int));
+      parallel_print(I_FORMAT_P,temp1_int,temp2_int,
+       abs(temp1_int-temp2_int),
+       per);
      }
      nfound++;
     }
    }
    else if (temp1_int != temp2_int)
    {
-    
     if ( print_data(options) )
     {
      print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1090,8 +1084,6 @@ hsize_t diff_datum(void       *_mem1,
     }
     nfound++;
    }
-   
-   
   } /*H5T_NATIVE_INT*/
   
   
@@ -1113,7 +1105,6 @@ hsize_t diff_datum(void       *_mem1,
    {
     if (abs((int)(temp1_uint-temp2_uint)) > options->delta)
     {
-     
      if ( print_data(options) )
      {
       print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1126,15 +1117,16 @@ hsize_t diff_datum(void       *_mem1,
    /* !-d and -p */
    else if (!options->d && options->p)
    {
-    if ( temp1_uint!=0 && abs((int)(1-temp2_uint/temp1_uint)) > options->percent )
+    PER(temp1_uint,temp2_uint);
+    if ( per > options->percent )
     {
-     
      if ( print_data(options) )
      {
       print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
-      
       parallel_print(SPACES);
-      parallel_print(I_FORMAT_P,temp1_uint,temp2_uint,abs((int)(temp1_uint-temp2_uint)),  abs((int)(1-temp2_uint/temp1_uint)));
+      parallel_print(I_FORMAT_P,temp1_uint,temp2_uint,
+       abs((int)(temp1_uint-temp2_uint)),
+       per);
      }
      nfound++;
     }
@@ -1142,27 +1134,25 @@ hsize_t diff_datum(void       *_mem1,
    /* -d and -p */
    else if ( options->d && options->p)
    {
-    if ( temp1_uint!=0 && abs((int)(1-temp2_uint/temp1_uint)) > options->percent &&
-     abs((int)(temp1_uint-temp2_uint)) > options->delta )
+    PER(temp1_uint,temp2_uint);
+    if ( per > options->percent && abs((int)(temp1_uint-temp2_uint)) > options->delta )
     {
-     
      if ( print_data(options) )
      {
       print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
-      
       parallel_print(SPACES);
-      parallel_print(I_FORMAT_P,temp1_uint,temp2_uint,abs((int)(temp1_uint-temp2_uint)),  abs((int)(1-temp2_uint/temp1_uint)));
+      parallel_print(I_FORMAT_P,temp1_uint,temp2_uint,
+       abs((int)(temp1_uint-temp2_uint)),
+       per);
      }
      nfound++;
     }
    }
    else if (temp1_uint != temp2_uint)
    {
-    
     if ( print_data(options) )
     {
      print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
-     
      parallel_print(SPACES);
      parallel_print(UI_FORMAT,temp1_uint,temp2_uint,abs((int)(temp1_uint-temp2_uint)));
     }
@@ -1189,7 +1179,6 @@ hsize_t diff_datum(void       *_mem1,
    {
     if (labs(temp1_long-temp2_long) > (long)options->delta)
     {
-     
      if ( print_data(options) )
      {
       print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1202,14 +1191,16 @@ hsize_t diff_datum(void       *_mem1,
    /* !-d and -p */
    else if (!options->d && options->p)
    {
-    if ( temp1_long!=0 && labs(1-temp2_long/temp1_long) > (long)options->percent )
+    PER(temp1_long,temp2_long);
+    if ( per > options->percent )
     {
-     
      if ( print_data(options) )
      {
       print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
       parallel_print(SPACES);
-      parallel_print(LI_FORMAT_P,temp1_long,temp2_long,labs(temp1_long-temp2_long), labs(1-temp2_long/temp1_long));
+      parallel_print(LI_FORMAT_P,temp1_long,temp2_long,
+       labs(temp1_long-temp2_long),
+       per);
      }
      nfound++;
     }
@@ -1217,22 +1208,22 @@ hsize_t diff_datum(void       *_mem1,
    /* -d and -p */
    else if ( options->d && options->p)
    {
-    if ( temp1_long!=0 && labs(1-temp2_long/temp1_long) > (long)options->percent &&
-     labs(temp1_long-temp2_long) > (long)options->delta )
+    PER(temp1_long,temp2_long);
+    if ( per > options->percent && labs(temp1_long-temp2_long) > (long)options->delta )
     {
-     
      if ( print_data(options) )
      {
       print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
       parallel_print(SPACES);
-      parallel_print(LI_FORMAT_P,temp1_long,temp2_long,labs(temp1_long-temp2_long), labs(1-temp2_long/temp1_long));
+      parallel_print(LI_FORMAT_P,temp1_long,temp2_long,
+       labs(temp1_long-temp2_long),
+       per);
      }
      nfound++;
     }
    }
    else if (temp1_long != temp2_long)
    {
-    
     if ( print_data(options) )
     {
      print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1241,9 +1232,6 @@ hsize_t diff_datum(void       *_mem1,
     }
     nfound++;
    }
-   
-   
-   
   } /*H5T_NATIVE_LONG*/
   
  /*-------------------------------------------------------------------------
@@ -1264,7 +1252,6 @@ hsize_t diff_datum(void       *_mem1,
    {
     if (labs((long)(temp1_ulong-temp2_ulong)) > (long)options->delta)
     {
-     
      if ( print_data(options) )
      {
       print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1277,14 +1264,16 @@ hsize_t diff_datum(void       *_mem1,
    /* !-d and -p */
    else if (!options->d && options->p)
    {
-    if ( temp1_ulong!=0 && labs((long)(1-temp2_ulong/temp1_ulong)) > (long)options->percent )
+    PER(temp1_ulong,temp2_ulong);
+    if ( per > options->percent )
     {
-     
      if ( print_data(options) )
      {
       print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
       parallel_print(SPACES);
-      parallel_print(ULI_FORMAT_P,temp1_ulong,temp2_ulong,labs((long)(temp1_ulong-temp2_ulong)), labs((long)(1-temp2_ulong/temp1_ulong)));
+      parallel_print(ULI_FORMAT_P,temp1_ulong,temp2_ulong,
+       labs((long)(temp1_ulong-temp2_ulong)),
+       per);
      }
      nfound++;
     }
@@ -1292,22 +1281,22 @@ hsize_t diff_datum(void       *_mem1,
    /* -d and -p */
    else if ( options->d && options->p)
    {
-    if ( temp1_ulong!=0 && labs((long)(1-temp2_ulong/temp1_ulong)) > (long)options->percent &&
-     labs((long)(temp1_ulong-temp2_ulong)) > (long)options->delta )
+    PER(temp1_ulong,temp2_ulong);
+    if ( per > options->percent && labs((long)(temp1_ulong-temp2_ulong)) > (long)options->delta )
     {
-     
      if ( print_data(options) )
      {
       print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
       parallel_print(SPACES);
-      parallel_print(ULI_FORMAT_P,temp1_ulong,temp2_ulong,labs((long)(temp1_ulong-temp2_ulong)), labs((long)(1-temp2_ulong/temp1_ulong)));
+      parallel_print(ULI_FORMAT_P,temp1_ulong,temp2_ulong,
+       labs((long)(temp1_ulong-temp2_ulong)),
+       per);
      }
      nfound++;
     }
    }
    else if (temp1_ulong != temp2_ulong)
    {
-    
     if ( print_data(options) )
     {
      print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1338,7 +1327,6 @@ hsize_t diff_datum(void       *_mem1,
    {
     if (labs((long)(temp1_llong-temp2_llong)) > (long)options->delta)
     {
-     
      if ( print_data(options) )
      {
       print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1352,16 +1340,16 @@ hsize_t diff_datum(void       *_mem1,
    /* !-d and -p */
    else if (!options->d && options->p)
    {
-    if ( temp1_llong!=0 && labs((long)(1-temp2_llong/temp1_llong)) > (long)options->percent )
+    PER(temp1_llong,temp2_llong);
+    if ( per > options->percent )
     {
-     
      if ( print_data(options) )
      {
       print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
       parallel_print(SPACES);
       parallel_print(LLI_FORMAT_P,temp1_llong,temp2_llong,
        (long_long)labs((long)(temp1_llong-temp2_llong)), 
-       (long_long)labs((long)(1-temp2_llong/temp1_llong)));
+       per);
      }
      nfound++;
     }
@@ -1369,36 +1357,32 @@ hsize_t diff_datum(void       *_mem1,
    /* -d and -p */
    else if ( options->d && options->p)
    {
-    if ( temp1_llong!=0 && labs((long)(1-temp2_llong/temp1_llong)) > (long)options->percent &&
-     labs((long)(temp1_llong-temp2_llong)) > (long)options->delta )
+    PER(temp1_llong,temp2_llong);
+    if ( per > options->percent  && labs((long)(temp1_llong-temp2_llong)) > (long)options->delta )
     {
-     
      if ( print_data(options) )
      {
       print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
       parallel_print(SPACES);
       parallel_print(LLI_FORMAT_P,temp1_llong,temp2_llong,
        (long_long)labs((long)(temp1_llong-temp2_llong)), 
-       (long_long)labs((long)(1-temp2_llong/temp1_llong)));
+       per);
      }
      nfound++;
     }
    }
    else if (temp1_llong != temp2_llong)
    {
-    
     if ( print_data(options) )
     {
      print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
-     
      parallel_print(SPACES);
      parallel_print(LLI_FORMAT,temp1_llong,temp2_llong,
       (long_long)labs((long)(temp1_llong-temp2_llong)));
     }
     nfound++;
    }
-   
-   
+ 
   } /*H5T_NATIVE_LLONG*/
   
  /*-------------------------------------------------------------------------
@@ -1419,7 +1403,6 @@ hsize_t diff_datum(void       *_mem1,
    {
     if (labs((long)(temp1_ullong-temp2_ullong)) > (long)options->delta)
     {
-     
      if ( print_data(options) )
      {
       print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1468,7 +1451,6 @@ hsize_t diff_datum(void       *_mem1,
    }
    else if (temp1_ullong != temp2_ullong)
    {
-    
     if ( print_data(options) )
     {
      print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1495,7 +1477,6 @@ hsize_t diff_datum(void       *_mem1,
    float       temp1_float;
    float       temp2_float;
    assert(type_size==sizeof(float));
-   
    memcpy(&temp1_float, mem1, sizeof(float));
    memcpy(&temp2_float, mem2, sizeof(float));
    
@@ -1504,7 +1485,6 @@ hsize_t diff_datum(void       *_mem1,
    {
     if (fabs(temp1_float-temp2_float) > options->delta)
     {
-     
      if ( print_data(options) )
      {
       print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1536,7 +1516,6 @@ hsize_t diff_datum(void       *_mem1,
     if ( temp1_float!=0 && fabs(1-temp2_float/temp1_float) > options->percent &&
      fabs(temp1_float-temp2_float) > options->delta )
     {
-     
      if ( print_data(options) )
      {
       print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
@@ -1580,7 +1559,6 @@ hsize_t diff_datum(void       *_mem1,
    {
     if (fabs(temp1_double-temp2_double) > options->delta)
     {
-     
      if ( print_data(options) )
      {
       print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -1595,7 +1573,6 @@ hsize_t diff_datum(void       *_mem1,
    {
     if ( temp1_double!=0 && fabs(1-temp2_double/temp1_double) > options->percent )
     {
-     
      if ( print_data(options) )
      {
       print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
@@ -1615,7 +1592,6 @@ hsize_t diff_datum(void       *_mem1,
      if ( print_data(options) )
      {
       print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
-      
       parallel_print(SPACES);
       parallel_print(F_FORMAT_P,temp1_double,temp2_double,fabs(temp1_double-temp2_double), fabs(1-temp2_double/temp1_double));
      }
@@ -1624,18 +1600,14 @@ hsize_t diff_datum(void       *_mem1,
    }
    else if (temp1_double != temp2_double)
    {
-    
     if ( print_data(options) )
     {
      print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
-     
      parallel_print(SPACES);
      parallel_print(F_FORMAT,temp1_double,temp2_double,fabs(temp1_double-temp2_double));
-     
     }
     nfound++;
    }
-   
   } /*H5T_NATIVE_DOUBLE*/
   
   
@@ -1760,12 +1732,8 @@ static int diff_region(hid_t region1_id,
  int       ndims1 = H5Sget_simple_extent_ndims(region1_id);
  int       ndims2 = H5Sget_simple_extent_ndims(region2_id);
  int       ret=0;
- 
-#if defined (H5DIFF_DEBUG)
- int i;
-#endif
- 
- /*
+
+/*
  * These two functions fail if the region does not have blocks or points,
  * respectively. They do not currently know how to translate from one to
  * the other.
@@ -1887,6 +1855,7 @@ hsize_t diff_native_uchar(unsigned char *mem1,
  hsize_t            nfound=0;  /* differences found */
  unsigned char      temp1_uchar;
  unsigned char      temp2_uchar;
+ float              per;
  
  memcpy(&temp1_uchar, mem1, sizeof(unsigned char));
  memcpy(&temp2_uchar, mem2, sizeof(unsigned char));
@@ -1909,13 +1878,16 @@ hsize_t diff_native_uchar(unsigned char *mem1,
  /* !-d and -p */
  else if (!options->d && options->p)
  {
-  if ( temp1_uchar!=0 && abs(1-temp2_uchar/temp1_uchar) > options->percent )
+  PER(temp1_uchar,temp2_uchar);
+  if ( per > options->percent )
   {
    if ( print_data(options) )
    {
     print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
     parallel_print(SPACES);
-    parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,abs(temp1_uchar-temp2_uchar), abs(1-temp2_uchar/temp1_uchar));
+    parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,
+     abs(temp1_uchar-temp2_uchar),
+     per);
    }
    nfound++;
   }
@@ -1923,14 +1895,16 @@ hsize_t diff_native_uchar(unsigned char *mem1,
  /* -d and -p */
  else if ( options->d && options->p)
  {
-  if ( temp1_uchar!=0 && abs(1-temp2_uchar/temp1_uchar) > options->percent &&
-   abs(temp1_uchar-temp2_uchar) > options->delta )
+  PER(temp1_uchar,temp2_uchar);
+  if ( per > options->percent && abs(temp1_uchar-temp2_uchar) > options->delta )
   {
    if ( print_data(options) )
    {
     print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
     parallel_print(SPACES);
-    parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,abs(temp1_uchar-temp2_uchar), abs(1-temp2_uchar/temp1_uchar));
+    parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,
+     abs(temp1_uchar-temp2_uchar),
+     per);
    }
    nfound++;
   }
@@ -1976,12 +1950,12 @@ hsize_t diff_float(unsigned char *mem1,
  float       temp1_float;
  float       temp2_float;
  hsize_t     i;
+ float       per;
  
  
  /* -d and !-p */
  if (options->d && !options->p)
  {
-  
   for ( i = 0; i < nelmts; i++)
   {
    memcpy(&temp1_float, mem1, sizeof(float));
@@ -2007,19 +1981,20 @@ hsize_t diff_float(unsigned char *mem1,
  /* !-d and -p */
  else if (!options->d && options->p)
  {
-  
   for ( i = 0; i < nelmts; i++)
   {
    memcpy(&temp1_float, mem1, sizeof(float));
    memcpy(&temp2_float, mem2, sizeof(float));
    
-   if ( temp1_float!=0 && fabs(1-temp2_float/temp1_float) > options->percent )
+   PER(temp1_float,temp2_float);
+   if ( per > options->percent )
    {
     if ( print_data(options) )
     {
      print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
      parallel_print(SPACES);
-     parallel_print(F_FORMAT_P,temp1_float,temp2_float,fabs(temp1_float-temp2_float),
+     parallel_print(F_FORMAT_P,temp1_float,temp2_float,
+      fabs(temp1_float-temp2_float),
       fabs(1-temp2_float/temp1_float));
     }
     nfound++;
@@ -2040,14 +2015,15 @@ hsize_t diff_float(unsigned char *mem1,
    memcpy(&temp1_float, mem1, sizeof(float));
    memcpy(&temp2_float, mem2, sizeof(float));
    
-   if ( temp1_float!=0 && fabs(1-temp2_float/temp1_float) > options->percent &&
-    fabs(temp1_float-temp2_float) > options->delta )
+   PER(temp1_float,temp2_float);
+   if ( per > options->percent && fabs(temp1_float-temp2_float) > options->delta )
    {
     if ( print_data(options) )
     {
      print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
      parallel_print(SPACES);
-     parallel_print(F_FORMAT_P,temp1_float,temp2_float,fabs(temp1_float-temp2_float),
+     parallel_print(F_FORMAT_P,temp1_float,temp2_float,
+      fabs(temp1_float-temp2_float),
       fabs(1-temp2_float/temp1_float));
     }
     nfound++;
@@ -2115,6 +2091,7 @@ hsize_t diff_double(unsigned char *mem1,
  double      temp1_double;
  double      temp2_double;
  hsize_t     i;
+ float       per;
  
  
  /* -d and !-p */
@@ -2128,7 +2105,6 @@ hsize_t diff_double(unsigned char *mem1,
    
    if (fabs(temp1_double-temp2_double) > options->delta)
    {
-    
     if ( print_data(options) )
     {
      print_pos(ph,0,i,acc,pos,rank,obj1,obj2);
@@ -2153,13 +2129,15 @@ hsize_t diff_double(unsigned char *mem1,
    memcpy(&temp1_double, mem1, sizeof(double));
    memcpy(&temp2_double, mem2, sizeof(double));
    
-   if ( temp1_double!=0 && fabs(1-temp2_double/temp1_double) > options->percent )
+   PER(temp1_double,temp2_double);
+   if ( per > options->percent )
    {
     if ( print_data(options) )
     {
      print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
      parallel_print(SPACES);
-     parallel_print(F_FORMAT_P,temp1_double,temp2_double,fabs(temp1_double-temp2_double),
+     parallel_print(F_FORMAT_P,temp1_double,temp2_double,
+      fabs(temp1_double-temp2_double),
       fabs(1-temp2_double/temp1_double));
     }
     nfound++;
@@ -2180,14 +2158,15 @@ hsize_t diff_double(unsigned char *mem1,
    memcpy(&temp1_double, mem1, sizeof(double));
    memcpy(&temp2_double, mem2, sizeof(double));
    
-   if ( temp1_double!=0 && fabs(1-temp2_double/temp1_double) > options->percent &&
-    fabs(temp1_double-temp2_double) > options->delta )
+   PER(temp1_double,temp2_double);
+   if ( per > options->percent && fabs(temp1_double-temp2_double) > options->delta )
    {
     if ( print_data(options) )
     {
      print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
      parallel_print(SPACES);
-     parallel_print(F_FORMAT_P,temp1_double,temp2_double,fabs(temp1_double-temp2_double),
+     parallel_print(F_FORMAT_P,temp1_double,temp2_double,
+      fabs(temp1_double-temp2_double),
       fabs(1-temp2_double/temp1_double));
     }
     nfound++;
@@ -2253,6 +2232,7 @@ hsize_t diff_schar(unsigned char *mem1,
  char        temp1_char;
  char        temp2_char;
  hsize_t     i;
+ float       per;
  
  
  /* -d and !-p */
@@ -2290,14 +2270,16 @@ hsize_t diff_schar(unsigned char *mem1,
    memcpy(&temp1_char, mem1, sizeof(char));
    memcpy(&temp2_char, mem2, sizeof(char));
    
-   if ( temp1_char!=0 && abs(1-temp2_char/temp1_char) > options->percent )
+   PER(temp1_char,temp2_char);
+   if ( per > options->percent )
    {
     if ( print_data(options) )
     {
      print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
      parallel_print(SPACES);
-     parallel_print(I_FORMAT_P,temp1_char,temp2_char,abs(temp1_char-temp2_char),
-      abs(1-temp2_char/temp1_char));
+     parallel_print(I_FORMAT_P,temp1_char,temp2_char,
+      abs(temp1_char-temp2_char),
+      per);
     }
     nfound++;
    }
@@ -2317,15 +2299,16 @@ hsize_t diff_schar(unsigned char *mem1,
    memcpy(&temp1_char, mem1, sizeof(char));
    memcpy(&temp2_char, mem2, sizeof(char));
    
-   if ( temp1_char!=0 && abs(1-temp2_char/temp1_char) > options->percent &&
-    abs(temp1_char-temp2_char) > options->delta )
+   PER(temp1_char,temp2_char);
+   if ( per > options->percent && abs(temp1_char-temp2_char) > options->delta )
    {
     if ( print_data(options) )
     {
      print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
      parallel_print(SPACES);
-     parallel_print(I_FORMAT_P,temp1_char,temp2_char,abs(temp1_char-temp2_char),
-      abs(1-temp2_char/temp1_char));
+     parallel_print(I_FORMAT_P,temp1_char,temp2_char,
+      abs(temp1_char-temp2_char),
+      per);
     }
     nfound++;
    }
@@ -2393,6 +2376,7 @@ hsize_t diff_uchar(unsigned char *mem1,
  unsigned char temp1_uchar;
  unsigned char temp2_uchar;
  hsize_t       i;
+ float         per;
  
  
  /* -d and !-p */
@@ -2431,14 +2415,16 @@ hsize_t diff_uchar(unsigned char *mem1,
    memcpy(&temp1_uchar, mem1, sizeof(unsigned char));
    memcpy(&temp2_uchar, mem2, sizeof(unsigned char));
    
-   if ( temp1_uchar!=0 && abs(1-temp2_uchar/temp1_uchar) > options->percent )
+   PER(temp1_uchar,temp2_uchar);
+   if ( per > options->percent )
    {
     if ( print_data(options) )
     {
      print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
      parallel_print(SPACES);
-     parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,abs(temp1_uchar-temp2_uchar),
-      abs(1-temp2_uchar/temp1_uchar));
+     parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,
+      abs(temp1_uchar-temp2_uchar),
+      per);
     }
     nfound++;
    }
@@ -2458,15 +2444,16 @@ hsize_t diff_uchar(unsigned char *mem1,
    memcpy(&temp1_uchar, mem1, sizeof(unsigned char));
    memcpy(&temp2_uchar, mem2, sizeof(unsigned char));
    
-   if ( temp1_uchar!=0 && abs(1-temp2_uchar/temp1_uchar) > options->percent &&
-    abs(temp1_uchar-temp2_uchar) > options->delta )
+   PER(temp1_uchar,temp2_uchar);
+   if ( per > options->percent && abs(temp1_uchar-temp2_uchar) > options->delta )
    {
     if ( print_data(options) )
     {
      print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
      parallel_print(SPACES);
-     parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,abs(temp1_uchar-temp2_uchar),
-      abs(1-temp2_uchar/temp1_uchar));
+     parallel_print(I_FORMAT_P,temp1_uchar,temp2_uchar,
+      abs(temp1_uchar-temp2_uchar),
+      per);
     }
     nfound++;
    }
@@ -2532,6 +2519,7 @@ hsize_t diff_short(unsigned char *mem1,
  short         temp1_short;
  short         temp2_short;
  hsize_t       i;
+ float         per;
  
  
  /* -d and !-p */
@@ -2570,14 +2558,16 @@ hsize_t diff_short(unsigned char *mem1,
    memcpy(&temp1_short, mem1, sizeof(short));
    memcpy(&temp2_short, mem2, sizeof(short));
    
-   if ( temp1_short!=0 && abs(1-temp2_short/temp1_short) > options->percent )
+   PER(temp1_short,temp2_short);
+   if ( per > options->percent )
    {
     if ( print_data(options) )
     {
      print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
      parallel_print(SPACES);
-     parallel_print(I_FORMAT_P,temp1_short,temp2_short,abs(temp1_short-temp2_short),
-      abs(1-temp2_short/temp1_short));
+     parallel_print(I_FORMAT_P,temp1_short,temp2_short,
+      abs(temp1_short-temp2_short),
+      per);
     }
     nfound++;
    }
@@ -2599,15 +2589,16 @@ hsize_t diff_short(unsigned char *mem1,
    memcpy(&temp1_short, mem1, sizeof(short));
    memcpy(&temp2_short, mem2, sizeof(short));
    
-   if ( temp1_short!=0 && abs(1-temp2_short/temp1_short) > options->percent &&
-    abs(temp1_short-temp2_short) > options->delta )
+   PER(temp1_short,temp2_short);
+   if ( per > options->percent && abs(temp1_short-temp2_short) > options->delta )
    {
     if ( print_data(options) )
     {
      print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
      parallel_print(SPACES);
-     parallel_print(I_FORMAT_P,temp1_short,temp2_short,abs(temp1_short-temp2_short),
-      abs(1-temp2_short/temp1_short));
+     parallel_print(I_FORMAT_P,temp1_short,temp2_short,
+      abs(temp1_short-temp2_short),
+      per);
     }
     nfound++;
    }
@@ -2674,6 +2665,7 @@ hsize_t diff_ushort(unsigned char *mem1,
  unsigned short temp1_ushort;
  unsigned short temp2_ushort;
  hsize_t        i;
+ float          per;
   
  /* -d and !-p */
  if (options->d && !options->p)
@@ -2711,14 +2703,16 @@ hsize_t diff_ushort(unsigned char *mem1,
    memcpy(&temp1_ushort, mem1, sizeof(unsigned short));
    memcpy(&temp2_ushort, mem2, sizeof(unsigned short));
    
-   if ( temp1_ushort!=0 && abs(1-temp2_ushort/temp1_ushort) > options->percent )
+   PER(temp1_ushort,temp2_ushort);
+   if ( per > options->percent )
    {
     if ( print_data(options) )
     {
      print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
      parallel_print(SPACES);
-     parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,abs(temp1_ushort-temp2_ushort),
-      abs(1-temp2_ushort/temp1_ushort));
+     parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,
+      abs(temp1_ushort-temp2_ushort),
+      per);
     }
     nfound++;
    }
@@ -2740,15 +2734,16 @@ hsize_t diff_ushort(unsigned char *mem1,
    memcpy(&temp1_ushort, mem1, sizeof(unsigned short));
    memcpy(&temp2_ushort, mem2, sizeof(unsigned short));
    
-   if ( temp1_ushort!=0 && abs(1-temp2_ushort/temp1_ushort) > options->percent &&
-    abs(temp1_ushort-temp2_ushort) > options->delta )
+   PER(temp1_ushort,temp2_ushort);
+   if ( per > options->percent && abs(temp1_ushort-temp2_ushort) > options->delta )
    {
     if ( print_data(options) )
     {
      print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
      parallel_print(SPACES);
-     parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,abs(temp1_ushort-temp2_ushort),
-      abs(1-temp2_ushort/temp1_ushort));
+     parallel_print(I_FORMAT_P,temp1_ushort,temp2_ushort,
+      abs(temp1_ushort-temp2_ushort),
+      per);
     }
     nfound++;
    }
@@ -2861,7 +2856,9 @@ hsize_t diff_int(unsigned char *mem1,
     {
      print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
      parallel_print(SPACES);
-     parallel_print(I_FORMAT_P,temp1_int,temp2_int,abs(temp1_int-temp2_int),per);
+     parallel_print(I_FORMAT_P,temp1_int,temp2_int,
+      abs(temp1_int-temp2_int),
+      per);
     }
     nfound++;
    }
@@ -2890,7 +2887,9 @@ hsize_t diff_int(unsigned char *mem1,
     {
      print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
      parallel_print(SPACES);
-     parallel_print(I_FORMAT_P,temp1_int,temp2_int,abs(temp1_int-temp2_int),per);
+     parallel_print(I_FORMAT_P,temp1_int,temp2_int,
+      abs(temp1_int-temp2_int),
+      per);
     }
     nfound++;
    }
@@ -2955,10 +2954,10 @@ hsize_t diff_uint(unsigned char *mem1,
                   
 {
  hsize_t        nfound=0;          /* number of differences found */
- unsigned int temp1_uint;
- unsigned int temp2_uint;
+ unsigned int   temp1_uint;
+ unsigned int   temp2_uint;
  hsize_t        i;
- 
+ float          per;
  
  /* -d and !-p */
  if (options->d && !options->p)
@@ -2969,7 +2968,7 @@ hsize_t diff_uint(unsigned char *mem1,
    memcpy(&temp1_uint, mem1, sizeof(unsigned int));
    memcpy(&temp2_uint, mem2, sizeof(unsigned int));
    
-   if (abs((int)(temp1_uint-temp2_uint)) > options->delta)
+   if (abs(temp1_uint-temp2_uint) > options->delta)
    {
     if ( print_data(options) )
     {
@@ -2996,14 +2995,16 @@ hsize_t diff_uint(unsigned char *mem1,
    memcpy(&temp1_uint, mem1, sizeof(unsigned int));
    memcpy(&temp2_uint, mem2, sizeof(unsigned int));
    
-   if ( temp1_uint!=0 && abs(1-temp2_uint/temp1_uint) > options->percent )
+   PER(temp1_uint,temp2_uint);
+   if ( per > options->percent )
    {
     if ( print_data(options) )
     {
      print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
      parallel_print(SPACES);
-     parallel_print(I_FORMAT_P,temp1_uint,temp2_uint,abs(temp1_uint-temp2_uint),
-      abs(1-temp2_uint/temp1_uint));
+     parallel_print(I_FORMAT_P,temp1_uint,temp2_uint,
+      abs(temp1_uint-temp2_uint),
+      per);
     }
     nfound++;
    }
@@ -3025,15 +3026,16 @@ hsize_t diff_uint(unsigned char *mem1,
    memcpy(&temp1_uint, mem1, sizeof(unsigned int));
    memcpy(&temp2_uint, mem2, sizeof(unsigned int));
    
-   if ( temp1_uint!=0 && abs(1-temp2_uint/temp1_uint) > options->percent &&
-    abs(temp1_uint-temp2_uint) > options->delta )
+   PER(temp1_uint,temp2_uint);
+   if ( per > options->percent && abs(temp1_uint-temp2_uint) > options->delta )
    {
     if ( print_data(options) )
     {
      print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
      parallel_print(SPACES);
-     parallel_print(I_FORMAT_P,temp1_uint,temp2_uint,abs(temp1_uint-temp2_uint),
-      abs(1-temp2_uint/temp1_uint));
+     parallel_print(I_FORMAT_P,temp1_uint,temp2_uint,
+      abs(temp1_uint-temp2_uint),
+      per);
     }
     nfound++;
    }
@@ -3101,6 +3103,7 @@ hsize_t diff_long(unsigned char *mem1,
  long          temp1_long;
  long          temp2_long;
  hsize_t       i;
+ float         per;
 
  /* -d and !-p */
  if (options->d && !options->p)
@@ -3129,9 +3132,7 @@ hsize_t diff_long(unsigned char *mem1,
     if (options->n && nfound>=options->count)
      return nfound;
    }
-   
   }
-  
  }
  
  /* !-d and -p */
@@ -3142,15 +3143,17 @@ hsize_t diff_long(unsigned char *mem1,
   {
    memcpy(&temp1_long, mem1, sizeof(long));
    memcpy(&temp2_long, mem2, sizeof(long));
-   
-   if ( temp1_long!=0 && labs(1-temp2_long/temp1_long) > options->percent )
+
+   PER(temp1_long,temp2_long);
+   if ( per > options->percent )
    {
     if ( print_data(options) )
     {
      print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
      parallel_print(SPACES);
-     parallel_print(LI_FORMAT_P,temp1_long,temp2_long,labs(temp1_long-temp2_long),
-      labs(1-temp2_long/temp1_long));
+     parallel_print(LI_FORMAT_P,temp1_long,temp2_long,
+      labs(temp1_long-temp2_long),
+      per);
     }
     nfound++;
    }
@@ -3172,15 +3175,16 @@ hsize_t diff_long(unsigned char *mem1,
    memcpy(&temp1_long, mem1, sizeof(long));
    memcpy(&temp2_long, mem2, sizeof(long));
    
-   if ( temp1_long!=0 && labs(1-temp2_long/temp1_long) > options->percent &&
-    labs(temp1_long-temp2_long) > options->delta )
+   PER(temp1_long,temp2_long);
+   if ( per > options->percent && labs(temp1_long-temp2_long) > options->delta )
    {
     if ( print_data(options) )
     {
      print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
      parallel_print(SPACES);
-     parallel_print(LI_FORMAT_P,temp1_long,temp2_long,labs(temp1_long-temp2_long),
-      labs(1-temp2_long/temp1_long));
+     parallel_print(LI_FORMAT_P,temp1_long,temp2_long,
+      labs(temp1_long-temp2_long),
+      per);
     }
     nfound++;
    }
@@ -3249,6 +3253,7 @@ hsize_t diff_ulong(unsigned char *mem1,
  unsigned long  temp1_ulong;
  unsigned long  temp2_ulong;
  hsize_t        i;
+ float          per;
  
  
  /* -d and !-p */
@@ -3292,14 +3297,16 @@ hsize_t diff_ulong(unsigned char *mem1,
    memcpy(&temp1_ulong, mem1, sizeof(unsigned long));
    memcpy(&temp2_ulong, mem2, sizeof(unsigned long));
    
-   if ( temp1_ulong!=0 && labs(1-temp2_ulong/temp1_ulong) > options->percent )
+   PER(temp1_ulong,temp2_ulong);
+   if ( per > options->percent )
    {
     if ( print_data(options) )
     {
      print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
      parallel_print(SPACES);
-     parallel_print(LI_FORMAT_P,temp1_ulong,temp2_ulong,labs(temp1_ulong-temp2_ulong),
-      labs(1-temp2_ulong/temp1_ulong));
+     parallel_print(LI_FORMAT_P,temp1_ulong,temp2_ulong,
+      labs(temp1_ulong-temp2_ulong),
+      per);
     }
     nfound++;
    }
@@ -3321,15 +3328,16 @@ hsize_t diff_ulong(unsigned char *mem1,
    memcpy(&temp1_ulong, mem1, sizeof(unsigned long));
    memcpy(&temp2_ulong, mem2, sizeof(unsigned long));
    
-   if ( temp1_ulong!=0 && labs(1-temp2_ulong/temp1_ulong) > options->percent &&
-    labs(temp1_ulong-temp2_ulong) > options->delta )
+   PER(temp1_ulong,temp2_ulong);
+   if ( per > options->percent && labs(temp1_ulong-temp2_ulong) > options->delta )
    {
     if ( print_data(options) )
     {
      print_pos(ph,1,i,acc,pos,rank,obj1,obj2);
      parallel_print(SPACES);
-     parallel_print(LI_FORMAT_P,temp1_ulong,temp2_ulong,labs(temp1_ulong-temp2_ulong),
-      labs(1-temp2_ulong/temp1_ulong));
+     parallel_print(LI_FORMAT_P,temp1_ulong,temp2_ulong,
+      labs(temp1_ulong-temp2_ulong),
+      per);
     }
     nfound++;
    }
@@ -3397,6 +3405,7 @@ hsize_t diff_llong(unsigned char *mem1,
  long_long     temp1_llong;
  long_long     temp2_llong;
  hsize_t       i;
+ float         per;
  
  /* -d and !-p */
  if (options->d && !options->p)
@@ -3435,7 +3444,8 @@ hsize_t diff_llong(unsigned char *mem1,
    memcpy(&temp1_llong, mem1, sizeof(long_long));
    memcpy(&temp2_llong, mem2, sizeof(long_long));
    
-   if ( temp1_llong!=0 && labs((long)(1-temp2_llong/temp1_llong)) > options->percent )
+   PER(temp1_llong,temp2_llong);
+   if ( per > options->percent )
    {
     if ( print_data(options) )
     {
@@ -3443,7 +3453,7 @@ hsize_t diff_llong(unsigned char *mem1,
      parallel_print(SPACES);
      parallel_print(LLI_FORMAT_P,temp1_llong,temp2_llong,
       (long_long)labs((long)(temp1_llong-temp2_llong)),
-      (long_long)labs((long)(1-temp2_llong/temp1_llong)));
+      per);
     }
     nfound++;
    }
@@ -3465,8 +3475,8 @@ hsize_t diff_llong(unsigned char *mem1,
    memcpy(&temp1_llong, mem1, sizeof(long_long));
    memcpy(&temp2_llong, mem2, sizeof(long_long));
    
-   if ( temp1_llong!=0 && labs((long)(1-temp2_llong/temp1_llong)) > options->percent &&
-    labs((long)(temp1_llong-temp2_llong)) > options->delta )
+    PER(temp1_llong,temp2_llong);
+    if ( per > options->percent && labs((long)(temp1_llong-temp2_llong)) > options->delta )
    {
     if ( print_data(options) )
     {
@@ -3474,7 +3484,7 @@ hsize_t diff_llong(unsigned char *mem1,
      parallel_print(SPACES);
      parallel_print(LLI_FORMAT_P,temp1_llong,temp2_llong,
       (long_long)labs((long)(temp1_llong-temp2_llong)),
-      (long_long)labs((long)(1-temp2_llong/temp1_llong)));
+      per);
     }
     nfound++;
    }
@@ -3665,3 +3675,4 @@ hsize_t diff_ullong(unsigned char *mem1,
 
 
 
+
diff --git a/tools/lib/h5diff_attr.c b/tools/lib/h5diff_attr.c
index 439bc9c..13acc28 100644
--- a/tools/lib/h5diff_attr.c
+++ b/tools/lib/h5diff_attr.c
@@ -16,7 +16,6 @@
 #include "h5diff.h"
 #include "H5private.h"
 
-
 /*-------------------------------------------------------------------------
  * Function: diff_attr
  *
@@ -37,227 +36,207 @@
  *-------------------------------------------------------------------------
  */
 
-int diff_attr(hid_t      loc1_id,
- hid_t      loc2_id,
- const char *path1,
- const char *path2,
- diff_opt_t *options
- )
+int diff_attr(hid_t loc1_id,
+              hid_t  loc2_id,
+              const char *path1,
+              const char *path2,
+              diff_opt_t *options)
 {
-    hid_t      attr1_id=-1;     /* attr ID */
-    hid_t      attr2_id=-1;     /* attr ID */
-    hid_t      space1_id=-1;    /* space ID */
-    hid_t      space2_id=-1;    /* space ID */
-    hid_t      ftype1_id=-1;    /* file data type ID */
-    hid_t      ftype2_id=-1;    /* file data type ID */
-    hid_t      mtype1_id=-1;    /* memory data type ID */
-    hid_t      mtype2_id=-1;    /* memory data type ID */
-    size_t     msize1;       /* memory size of memory type */
-    size_t     msize2;       /* memory size of memory type */
-    void       *buf1=NULL;   /* data buffer */
-    void       *buf2=NULL;   /* data buffer */
-    hsize_t    nelmts1;      /* number of elements in dataset */
-    int        rank1;        /* rank of dataset */
-    int        rank2;        /* rank of dataset */
-    hsize_t    dims1[H5S_MAX_RANK];/* dimensions of dataset */
-    hsize_t    dims2[H5S_MAX_RANK];/* dimensions of dataset */
-    char       name1[512];
-    char       name2[512];
-    char       np1[512];
-    char       np2[512];
-    int        n1, n2, i, j;
-    int        ret=0;
-    hsize_t    nfound;
-    int        cmp=1;
-
-    if ((n1 = H5Aget_num_attrs(loc1_id))<0)
- goto error;
-    if ((n2 = H5Aget_num_attrs(loc2_id))<0)
- goto error;
-
-    if (n1!=n2)
- return 1;
-
-    for ( i = 0; i < n1; i++)
-    {
-
- /* reset buffers for every attribute, we might goto out and call free */
- buf1=NULL;
- buf2=NULL;
-
- /*-------------------------------------------------------------------------
+ hid_t      attr1_id=-1;     /* attr ID */
+ hid_t      attr2_id=-1;     /* attr ID */
+ hid_t      space1_id=-1;    /* space ID */
+ hid_t      space2_id=-1;    /* space ID */
+ hid_t      ftype1_id=-1;    /* file data type ID */
+ hid_t      ftype2_id=-1;    /* file data type ID */
+ hid_t      mtype1_id=-1;    /* memory data type ID */
+ hid_t      mtype2_id=-1;    /* memory data type ID */
+ size_t     msize1;       /* memory size of memory type */
+ size_t     msize2;       /* memory size of memory type */
+ void       *buf1=NULL;   /* data buffer */
+ void       *buf2=NULL;   /* data buffer */
+ hsize_t    nelmts1;      /* number of elements in dataset */
+ int        rank1;        /* rank of dataset */
+ int        rank2;        /* rank of dataset */
+ hsize_t    dims1[H5S_MAX_RANK];/* dimensions of dataset */
+ hsize_t    dims2[H5S_MAX_RANK];/* dimensions of dataset */
+ char       name1[512];
+ char       name2[512];
+ char       np1[512];
+ char       np2[512];
+ int        n1, n2, i, j;
+ int        ret=0;
+ hsize_t    nfound;
+ int        cmp=1;
+ 
+ if ((n1 = H5Aget_num_attrs(loc1_id))<0)
+  goto error;
+ if ((n2 = H5Aget_num_attrs(loc2_id))<0)
+  goto error;
+ 
+ if (n1!=n2)
+  return 1;
+ 
+ for ( i = 0; i < n1; i++)
+ {
+  /* reset buffers for every attribute, we might goto out and call free */
+  buf1=NULL;
+  buf2=NULL;
+  
+  /*-------------------------------------------------------------------------
   * open
   *-------------------------------------------------------------------------
   */
- /* open attribute */
- if ((attr1_id = H5Aopen_idx(loc1_id, (unsigned)i))<0)
-     goto error;
- if ((attr2_id = H5Aopen_idx(loc2_id, (unsigned)i))<0)
-     goto error;
-
- /* get name */
- if (H5Aget_name( attr1_id, 255, name1 )<0)
-     goto error;
- if (H5Aget_name( attr2_id, 255, name2 )<0)
-     goto error;
-
- if (HDstrcmp(name1,name2)!=0)
- {
-     if (options->m_verbose)
-     {
-  parallel_print("Different name for attributes: <%s> and <%s>\n", name1, name2);
-     }
-     H5Aclose(attr1_id);
-     H5Aclose(attr2_id);
-     ret=1;
-     continue;
- }
-
- /* get the file datatype  */
- if ((ftype1_id = H5Aget_type( attr1_id )) < 0 )
-     goto error;
- if ((ftype2_id = H5Aget_type( attr2_id )) < 0 )
-     goto error;
-
- /* get the dataspace handle  */
- if ((space1_id = H5Aget_space( attr1_id )) < 0 )
-     goto error;
- if ((space2_id = H5Aget_space( attr2_id )) < 0 )
-     goto error;
-
- /* get dimensions  */
- if ( (rank1 = H5Sget_simple_extent_dims(space1_id, dims1, NULL)) < 0 )
-     goto error;
- if ( (rank2 = H5Sget_simple_extent_dims(space2_id, dims2, NULL)) < 0 )
-     goto error;
-
-
+  /* open attribute */
+  if ((attr1_id = H5Aopen_idx(loc1_id, (unsigned)i))<0)
+   goto error;
+  if ((attr2_id = H5Aopen_idx(loc2_id, (unsigned)i))<0)
+   goto error;
+  
+  /* get name */
+  if (H5Aget_name( attr1_id, 255, name1 )<0)
+   goto error;
+  if (H5Aget_name( attr2_id, 255, name2 )<0)
+   goto error;
+  
+  if (HDstrcmp(name1,name2)!=0)
+  {
+   if (options->m_verbose)
+   {
+    parallel_print("Different name for attributes: <%s> and <%s>\n", name1, name2);
+   }
+   H5Aclose(attr1_id);
+   H5Aclose(attr2_id);
+   ret=1;
+   continue;
+  }
+  
+  /* get the file datatype  */
+  if ((ftype1_id = H5Aget_type( attr1_id )) < 0 )
+   goto error;
+  if ((ftype2_id = H5Aget_type( attr2_id )) < 0 )
+   goto error;
+  
+  /* get the dataspace handle  */
+  if ((space1_id = H5Aget_space( attr1_id )) < 0 )
+   goto error;
+  if ((space2_id = H5Aget_space( attr2_id )) < 0 )
+   goto error;
+  
+  /* get dimensions  */
+  if ( (rank1 = H5Sget_simple_extent_dims(space1_id, dims1, NULL)) < 0 )
+   goto error;
+  if ( (rank2 = H5Sget_simple_extent_dims(space2_id, dims2, NULL)) < 0 )
+   goto error;
+   
  /*-------------------------------------------------------------------------
   * check for comparable TYPE and SPACE
   *-------------------------------------------------------------------------
   */
-
- if (diff_can_type(ftype1_id,
-      ftype2_id,
-      rank1,
-      rank2,
-      dims1,
-      dims2,
-      NULL,
-      NULL,
-      name1,
-      name2,
-      options)!=1)
- {
-     cmp=0;
-     options->not_cmp=1;
- }
+  
+  if (diff_can_type(ftype1_id,
+   ftype2_id,
+   rank1,
+   rank2,
+   dims1,
+   dims2,
+   NULL,
+   NULL,
+   name1,
+   name2,
+   options)!=1)
+  {
+   cmp=0;
+   options->not_cmp=1;
+  }
  /*-------------------------------------------------------------------------
   * only attempt to compare if possible
   *-------------------------------------------------------------------------
   */
- if (cmp)
- {
-
-     /*-------------------------------------------------------------------------
-      * read to memory
-      *-------------------------------------------------------------------------
-      */
-     nelmts1=1;
-     for (j=0; j<rank1; j++)
-      nelmts1*=dims1[j];
-
-     if ((mtype1_id=h5tools_get_native_type(ftype1_id))<0)
-  goto error;
-
-     if ((mtype2_id=h5tools_get_native_type(ftype2_id))<0)
-  goto error;
-
-     if ((msize1=H5Tget_size(mtype1_id))==0)
-  goto error;
-     if ((msize2=H5Tget_size(mtype2_id))==0)
-  goto error;
-
-     assert(msize1==msize2);
-
-     buf1=(void *) HDmalloc((unsigned)(nelmts1*msize1));
-     buf2=(void *) HDmalloc((unsigned)(nelmts1*msize2));
-     if ( buf1==NULL || buf2==NULL){
-  parallel_print( "cannot read into memory\n" );
-  goto error;
-     }
-     if (H5Aread(attr1_id,mtype1_id,buf1)<0)
-  goto error;
-     if (H5Aread(attr2_id,mtype2_id,buf2)<0)
-  goto error;
-
-     /* format output string */
-     sprintf(np1,"%s of <%s>",name1,path1);
-     sprintf(np2,"%s of <%s>",name2,path2);
-     
-    /*-------------------------------------------------------------------------
-     * array compare
-     *-------------------------------------------------------------------------
-     */
-
-     /* always print name */
-     if (options->m_verbose)
-     {
-  parallel_print( "Attribute:   <%s> and <%s>\n",np1,np2);
-  nfound = diff_array(buf1,
-   buf2,
-   nelmts1,
-   rank1,
-   dims1,
-   options,
-   np1,
-   np2,
-   mtype1_id,
-   attr1_id,
-   attr2_id);
-  print_found(nfound);
-
-     }
-     /* check first if we have differences */
-     else
-     {
-  if (options->m_quiet==0)
-  {
-      /* shut up temporarily */
-      options->m_quiet=1;
-      nfound = diff_array(buf1,
-       buf2,
-       nelmts1,
-       rank1,
-       dims1,
-       options,
-       np1,
-       np2,
-       mtype1_id,
-       attr1_id,
-       attr2_id);
-      /* print again */
-      options->m_quiet=0;
-      if (nfound)
-      {
-   parallel_print( "Attribute:   <%s> and <%s>\n",np1,np2);
-   nfound = diff_array(buf1,
-    buf2,
-    nelmts1,
-    rank1,
-    dims1,
-    options,
-    np1,
-    np2,
-    mtype1_id,
-    attr1_id,
-    attr2_id);
-   print_found(nfound);
-      } /*if*/
-  } /*if*/
-  /* in quiet mode, just count differences */
-  else
+  if (cmp)
   {
+   
+  /*-------------------------------------------------------------------------
+   * read to memory
+   *-------------------------------------------------------------------------
+   */
+   nelmts1=1;
+   for (j=0; j<rank1; j++)
+    nelmts1*=dims1[j];
+   
+   if ((mtype1_id=h5tools_get_native_type(ftype1_id))<0)
+    goto error;
+   
+   if ((mtype2_id=h5tools_get_native_type(ftype2_id))<0)
+    goto error;
+   
+   if ((msize1=H5Tget_size(mtype1_id))==0)
+    goto error;
+   if ((msize2=H5Tget_size(mtype2_id))==0)
+    goto error;
+   
+   assert(msize1==msize2);
+   
+   buf1=(void *) HDmalloc((unsigned)(nelmts1*msize1));
+   buf2=(void *) HDmalloc((unsigned)(nelmts1*msize2));
+   if ( buf1==NULL || buf2==NULL){
+    parallel_print( "cannot read into memory\n" );
+    goto error;
+   }
+   if (H5Aread(attr1_id,mtype1_id,buf1)<0)
+    goto error;
+   if (H5Aread(attr2_id,mtype2_id,buf2)<0)
+    goto error;
+   
+   /* format output string */
+   sprintf(np1,"%s of <%s>",name1,path1);
+   sprintf(np2,"%s of <%s>",name2,path2);
+   
+  /*-------------------------------------------------------------------------
+   * array compare
+   *-------------------------------------------------------------------------
+   */
+   
+   /* always print name */
+   if (options->m_verbose)
+   {
+    parallel_print( "Attribute:   <%s> and <%s>\n",np1,np2);
+    nfound = diff_array(buf1,
+     buf2,
+     nelmts1,
+     rank1,
+     dims1,
+     options,
+     np1,
+     np2,
+     mtype1_id,
+     attr1_id,
+     attr2_id);
+    print_found(nfound);
+    
+   }
+   /* check first if we have differences */
+   else
+   {
+    if (options->m_quiet==0)
+    {
+     /* shut up temporarily */
+     options->m_quiet=1;
+     nfound = diff_array(buf1,
+      buf2,
+      nelmts1,
+      rank1,
+      dims1,
+      options,
+      np1,
+      np2,
+      mtype1_id,
+      attr1_id,
+      attr2_id);
+     /* print again */
+     options->m_quiet=0;
+     if (nfound)
+     {
+      parallel_print( "Attribute:   <%s> and <%s>\n",np1,np2);
       nfound = diff_array(buf1,
        buf2,
        nelmts1,
@@ -269,51 +248,67 @@ int diff_attr(hid_t      loc1_id,
        mtype1_id,
        attr1_id,
        attr2_id);
-  } /*else quiet */
-     } /*else verbose */
+      print_found(nfound);
+     } /*if*/
+    } /*if*/
+    /* in quiet mode, just count differences */
+    else
+    {
+     nfound = diff_array(buf1,
+      buf2,
+      nelmts1,
+      rank1,
+      dims1,
+      options,
+      np1,
+      np2,
+      mtype1_id,
+      attr1_id,
+      attr2_id);
+    } /*else quiet */
+   } /*else verbose */
  }/*cmp*/
-
-
+ 
 
  /*-------------------------------------------------------------------------
   * close
   *-------------------------------------------------------------------------
   */
-
- if (H5Tclose(ftype1_id)<0) goto error;
- if (H5Tclose(ftype2_id)<0) goto error;
- if (H5Tclose(mtype1_id)<0) goto error;
- if (H5Tclose(mtype2_id)<0) goto error;
- if (H5Sclose(space1_id)<0) goto error;
- if (H5Sclose(space2_id)<0) goto error;
- if (H5Aclose(attr1_id)<0) goto error;
- if (H5Aclose(attr2_id)<0) goto error;
- if (buf1)
-     HDfree(buf1);
- if (buf2)
-     HDfree(buf2);
-    } /* i */
-
-    return ret;
-
+  
+  if (H5Tclose(ftype1_id)<0) goto error;
+  if (H5Tclose(ftype2_id)<0) goto error;
+  if (H5Tclose(mtype1_id)<0) goto error;
+  if (H5Tclose(mtype2_id)<0) goto error;
+  if (H5Sclose(space1_id)<0) goto error;
+  if (H5Sclose(space2_id)<0) goto error;
+  if (H5Aclose(attr1_id)<0) goto error;
+  if (H5Aclose(attr2_id)<0) goto error;
+  if (buf1)
+   HDfree(buf1);
+  if (buf2)
+   HDfree(buf2);
+ } /* i */
+ 
+ return ret;
+    
 error:
-    H5E_BEGIN_TRY {
- H5Tclose(ftype1_id);
- H5Tclose(ftype2_id);
- H5Tclose(mtype1_id);
- H5Tclose(mtype2_id);
- H5Sclose(space1_id);
- H5Sclose(space2_id);
- H5Aclose(attr1_id);
- H5Aclose(attr2_id);
- if (buf1)
-     HDfree(buf1);
- if (buf2)
-     HDfree(buf2);
-    } H5E_END_TRY;
-
-    options->err_stat=1;
-    return 0;
+ H5E_BEGIN_TRY {
+  H5Tclose(ftype1_id);
+  H5Tclose(ftype2_id);
+  H5Tclose(mtype1_id);
+  H5Tclose(mtype2_id);
+  H5Sclose(space1_id);
+  H5Sclose(space2_id);
+  H5Aclose(attr1_id);
+  H5Aclose(attr2_id);
+  if (buf1)
+   HDfree(buf1);
+  if (buf2)
+   HDfree(buf2);
+ } H5E_END_TRY;
+ 
+ options->err_stat=1;
+ return 0;
 }
 
 
diff --git a/tools/lib/h5diff_dset.c b/tools/lib/h5diff_dset.c
index 868eedf..8802067 100644
--- a/tools/lib/h5diff_dset.c
+++ b/tools/lib/h5diff_dset.c
@@ -17,6 +17,60 @@
 #include "H5private.h"
 #include "h5tools.h"
 
+
+/*-------------------------------------------------------------------------
+ * Function: print_sizes
+ *
+ * Purpose: Print datatype sizes
+ *
+ *-------------------------------------------------------------------------
+ */
+#if defined (H5DIFF_DEBUG)
+void print_sizes( const char *obj1, const char *obj2,
+                  hid_t f_type1, hid_t f_type2,
+                  hid_t m_type1, hid_t m_type2 )
+{
+ size_t  f_size1, f_size2;       /* size of type in file */
+ size_t  m_size1, m_size2;       /* size of type in memory */
+
+ f_size1 = H5Tget_size( f_type1 );
+ f_size2 = H5Tget_size( f_type2 );
+ m_size1 = H5Tget_size( m_type1 );
+ m_size2 = H5Tget_size( m_type2 );
+
+ printf("\n");
+ printf("------------------\n");
+ printf("sizeof(char)   %u\n", sizeof(char) );
+ printf("sizeof(short)  %u\n", sizeof(short) );
+ printf("sizeof(int)    %u\n", sizeof(int) );
+ printf("sizeof(long)   %u\n", sizeof(long) );
+ printf("<%s> ------------------\n", obj1);
+ printf("type on file   ");
+ print_type(f_type1);
+ printf("\n");
+ printf("size on file   %u\n", f_size1 );
+
+ printf("type on memory ");
+ print_type(m_type1);
+ printf("\n");
+ printf("size on memory %u\n", m_size1 );
+
+ printf("<%s> ------------------\n", obj2);
+ printf("type on file   ");
+ print_type(f_type2);
+ printf("\n");
+ printf("size on file   %u\n", f_size2 );
+
+ printf("type on memory ");
+ print_type(m_type2);
+ printf("\n");
+ printf("size on memory %u\n", m_size2 );
+ printf("\n");
+}
+#endif /* H5DIFF_DEBUG */
+
+
+
 /*-------------------------------------------------------------------------
  * Function: diff_dataset
  *
@@ -112,12 +166,8 @@ error:
  } H5E_END_TRY;
 
  return nfound;
-
 }
 
-
-
-
 /*-------------------------------------------------------------------------
  * Function: diff_datasetid
  *
diff --git a/tools/lib/h5diff_util.c b/tools/lib/h5diff_util.c
index 100057f..6334d8d 100644
--- a/tools/lib/h5diff_util.c
+++ b/tools/lib/h5diff_util.c
@@ -18,10 +18,10 @@
 
 /* global variables */
 int      g_nTasks = 1;
-unsigned char	 g_Parallel = 0;  /*0 for serial, 1 for parallel */
-char    outBuff[OUTBUFF_SIZE];
-int     outBuffOffset;
-FILE*	overflow_file	      = NULL;
+unsigned char  g_Parallel = 0;  /*0 for serial, 1 for parallel */
+char     outBuff[OUTBUFF_SIZE];
+int      outBuffOffset;
+FILE*    overflow_file = NULL;
 
 /*-------------------------------------------------------------------------
  * Function: parallel_print
@@ -36,57 +36,57 @@ FILE*	overflow_file	      = NULL;
  */
 void parallel_print(const char* format, ...)
 {
-    int 	bytes_written;
-    va_list	ap;
-
-    va_start(ap, format);
-
-    if(!g_Parallel)
-	vprintf(format, ap);
-    else
-    {
-
-	if(overflow_file == NULL) /*no overflow has occurred yet */
-	{
+ int  bytes_written;
+ va_list ap;
+ 
+ va_start(ap, format);
+ 
+ if(!g_Parallel)
+  vprintf(format, ap);
+ else
+ {
+  
+  if(overflow_file == NULL) /*no overflow has occurred yet */
+  {
 #if 0
-printf("calling HDvsnprintf: OUTBUFF_SIZE=%ld, outBuffOffset=%ld, ", (long)OUTBUFF_SIZE, (long)outBuffOffset);
+   printf("calling HDvsnprintf: OUTBUFF_SIZE=%ld, outBuffOffset=%ld, ", (long)OUTBUFF_SIZE, (long)outBuffOffset);
 #endif
-	    bytes_written = HDvsnprintf(outBuff+outBuffOffset, OUTBUFF_SIZE-outBuffOffset, format, ap);
+   bytes_written = HDvsnprintf(outBuff+outBuffOffset, OUTBUFF_SIZE-outBuffOffset, format, ap);
 #if 0
-printf("bytes_written=%ld\n", (long)bytes_written);
+   printf("bytes_written=%ld\n", (long)bytes_written);
 #endif
-            va_end(ap);
-	    va_start(ap, format);
-
+   va_end(ap);
+   va_start(ap, format);
+   
 #if 0
-printf("Result: bytes_written=%ld, OUTBUFF_SIZE-outBuffOffset=%ld\n", (long)bytes_written, (long)OUTBUFF_SIZE-outBuffOffset);
+   printf("Result: bytes_written=%ld, OUTBUFF_SIZE-outBuffOffset=%ld\n", (long)bytes_written, (long)OUTBUFF_SIZE-outBuffOffset);
 #endif
-
-	    if ((bytes_written < 0) ||
+   
+   if ((bytes_written < 0) ||
 #ifdef H5_VSNPRINTF_WORKS
-		(bytes_written >= (OUTBUFF_SIZE-outBuffOffset))
+    (bytes_written >= (OUTBUFF_SIZE-outBuffOffset))
 #else
-		((bytes_written+1) == (OUTBUFF_SIZE-outBuffOffset))
+    ((bytes_written+1) == (OUTBUFF_SIZE-outBuffOffset))
 #endif
-		)
-	    {
-		/* Terminate the outbuff at the end of the previous output */
-		outBuff[outBuffOffset] = '\0';
-
-		overflow_file = HDtmpfile();
-		if(overflow_file == NULL)
-		    fprintf(stderr, "Warning: Could not create overflow file.  Output may be truncated.\n");
-		else
-		    bytes_written = HDvfprintf(overflow_file, format, ap);
-	    }
-	    else
-		outBuffOffset += bytes_written;
-	}
-	else
-	    bytes_written = HDvfprintf(overflow_file, format, ap);
-
-    }
-    va_end(ap);
+    )
+   {
+    /* Terminate the outbuff at the end of the previous output */
+    outBuff[outBuffOffset] = '\0';
+    
+    overflow_file = HDtmpfile();
+    if(overflow_file == NULL)
+     fprintf(stderr, "Warning: Could not create overflow file.  Output may be truncated.\n");
+    else
+     bytes_written = HDvfprintf(overflow_file, format, ap);
+   }
+   else
+    outBuffOffset += bytes_written;
+  }
+  else
+   bytes_written = HDvfprintf(overflow_file, format, ap);
+  
+ }
+ va_end(ap);
 }
 
 
@@ -214,8 +214,6 @@ void print_type(hid_t type)
  }/*switch*/
 }
 
-
-
 /*-------------------------------------------------------------------------
  * Function: diff_basename
  *
@@ -356,62 +354,11 @@ get_class(H5T_class_t tclass)
  */
 void print_found(hsize_t nfound)
 {
-    if(g_Parallel)
-	parallel_print("%"H5_PRINTF_LL_WIDTH"u differences found\n", (unsigned long_long)nfound);
-    else
-	HDfprintf(stdout,"%Hu differences found\n",nfound);
+ if(g_Parallel)
+  parallel_print("%"H5_PRINTF_LL_WIDTH"u differences found\n", (unsigned long_long)nfound);
+ else
+  HDfprintf(stdout,"%Hu differences found\n",nfound);
 }
 
 
-/*-------------------------------------------------------------------------
- * Function: print_sizes
- *
- * Purpose: Print datatype sizes
- *
- *-------------------------------------------------------------------------
- */
-#if defined (H5DIFF_DEBUG)
-void print_sizes( const char *obj1, const char *obj2,
-                  hid_t f_type1, hid_t f_type2,
-                  hid_t m_type1, hid_t m_type2 )
-{
- size_t  f_size1, f_size2;       /* size of type in file */
- size_t  m_size1, m_size2;       /* size of type in memory */
-
- f_size1 = H5Tget_size( f_type1 );
- f_size2 = H5Tget_size( f_type2 );
- m_size1 = H5Tget_size( m_type1 );
- m_size2 = H5Tget_size( m_type2 );
-
- printf("\n");
- printf("------------------\n");
- printf("sizeof(char)   %u\n", sizeof(char) );
- printf("sizeof(short)  %u\n", sizeof(short) );
- printf("sizeof(int)    %u\n", sizeof(int) );
- printf("sizeof(long)   %u\n", sizeof(long) );
- printf("<%s> ------------------\n", obj1);
- printf("type on file   ");
- print_type(f_type1);
- printf("\n");
- printf("size on file   %u\n", f_size1 );
-
- printf("type on memory ");
- print_type(m_type1);
- printf("\n");
- printf("size on memory %u\n", m_size1 );
-
- printf("<%s> ------------------\n", obj2);
- printf("type on file   ");
- print_type(f_type2);
- printf("\n");
- printf("size on file   %u\n", f_size2 );
-
- printf("type on memory ");
- print_type(m_type2);
- printf("\n");
- printf("size on memory %u\n", m_size2 );
- printf("\n");
-}
-#endif /* H5DIFF_DEBUG */
-