[svn-r12440] Purpose:

    Code cleanup

Description:
    Trim trailing whitespace in Makefile.am and C/C++ source files to make
diffing changes easier.

Platforms tested:
    None necessary, whitespace only change

1 files changed, 132 insertions, 132 deletions

diff --git a/tools/lib/h5diff.c b/tools/lib/h5diff.c
index b4c9022..e8c546e 100644
--- a/tools/lib/h5diff.c
+++ b/tools/lib/h5diff.c
@@ -91,19 +91,19 @@ void print_manager_output(void)
  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;
@@ -134,7 +134,7 @@ 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);
@@ -142,7 +142,7 @@ static void print_incoming_data(void)
   {
    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);
@@ -176,9 +176,9 @@ hsize_t h5diff(const char *fname1,
  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))
  {
@@ -186,12 +186,12 @@ hsize_t h5diff(const char *fname1,
   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
  {
@@ -200,7 +200,7 @@ hsize_t h5diff(const char *fname1,
   {
    printf ("h5diff: <%s>: unable to open file\n", fname1);
    options->err_stat = 1;
-   
+
 #ifdef H5_HAVE_PARALLEL
    if(g_Parallel)
    {
@@ -208,14 +208,14 @@ hsize_t h5diff(const char *fname1,
     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;
-   
+
 #ifdef H5_HAVE_PARALLEL
    if(g_Parallel)
    {
@@ -223,20 +223,20 @@ hsize_t h5diff(const char *fname1,
     phdiff_dismiss_workers();
    }
 #endif
-   
+
    goto out;
   }
   /* 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");
@@ -250,12 +250,12 @@ hsize_t h5diff(const char *fname1,
 #endif
   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)
@@ -273,18 +273,18 @@ hsize_t h5diff(const char *fname1,
 #endif
   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)
   {
@@ -298,31 +298,31 @@ hsize_t h5diff(const char *fname1,
    file2_id, fname2, objname2, nobjects2, info2,
    options);
  }
- 
+
 /*-------------------------------------------------------------------------
  * compare all
  *-------------------------------------------------------------------------
  */
- 
+
  else
  {
-  
+
 #ifdef H5_HAVE_PARALLEL
   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);
    }
-   
+
    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);
   }
@@ -330,10 +330,10 @@ hsize_t h5diff(const char *fname1,
   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
@@ -342,7 +342,7 @@ out:
   H5Fclose (file2_id);
  }
  H5E_END_TRY;
- 
+
  return nfound;
 }
 
@@ -366,12 +366,12 @@ out:
  *
  *-------------------------------------------------------------------------
  */
-hsize_t diff_match (hid_t file1_id, 
+hsize_t diff_match (hid_t file1_id,
                     int nobjects1,
                     trav_info_t * info1,
                     hid_t file2_id,
-                    int nobjects2, 
-                    trav_info_t * info2, 
+                    int nobjects2,
+                    trav_info_t * info2,
                     diff_opt_t * options)
 {
  int more_names_exist = (nobjects1 > 0 && nobjects2 > 0) ? 1 : 0;
@@ -383,13 +383,13 @@ hsize_t diff_match (hid_t file1_id,
  char c1, c2;
  hsize_t nfound = 0;
  int i;
- 
+
 /*-------------------------------------------------------------------------
  * build the list
  *-------------------------------------------------------------------------
  */
  trav_table_init (&table);
- 
+
  while (more_names_exist)
  {
   /* criteria is string compare */
@@ -400,7 +400,7 @@ hsize_t diff_match (hid_t file1_id,
    infile[1] = 1;
    trav_table_addflags (infile, info1[curr1].name, info1[curr1].type,
     table);
-   
+
    curr1++;
    curr2++;
   }
@@ -420,12 +420,12 @@ hsize_t diff_match (hid_t file1_id,
     table);
    curr2++;
   }
-  
+
   more_names_exist = (curr1 < nobjects1 && curr2 < nobjects2) ? 1 : 0;
-  
-  
+
+
  }    /* end while */
- 
+
  /* list1 did not end */
  if (curr1 < nobjects1)
  {
@@ -438,7 +438,7 @@ hsize_t diff_match (hid_t file1_id,
    curr1++;
   }
  }
- 
+
  /* list2 did not end */
  if (curr2 < nobjects2)
  {
@@ -451,12 +451,12 @@ hsize_t diff_match (hid_t file1_id,
    curr2++;
   }
  }
- 
+
 /*-------------------------------------------------------------------------
  * print the list
  *-------------------------------------------------------------------------
  */
- 
+
  if (options->m_verbose)
  {
   printf ("\n");
@@ -470,8 +470,8 @@ hsize_t diff_match (hid_t file1_id,
   }
   printf ("\n");
  }
- 
- 
+
+
 /*-------------------------------------------------------------------------
  * do the diff for common objects
  *-------------------------------------------------------------------------
@@ -485,11 +485,11 @@ hsize_t diff_match (hid_t file1_id,
   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])
@@ -516,18 +516,18 @@ hsize_t diff_match (hid_t file1_id,
      * 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)
@@ -535,7 +535,7 @@ hsize_t diff_match (hid_t file1_id,
       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)
       {
@@ -545,16 +545,16 @@ hsize_t diff_match (hid_t file1_id,
        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)
        {
@@ -566,7 +566,7 @@ hsize_t diff_match (hid_t file1_id,
         havePrintToken = 1;
        }
       }
-      
+
       /* check to see if anyone needs the print token. */
       if(havePrintToken)
       {
@@ -580,35 +580,35 @@ hsize_t diff_match (hid_t file1_id,
        }
       }
      }
-     
+
      /* 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])
       {
        /* 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) {
@@ -630,7 +630,7 @@ hsize_t diff_match (hid_t file1_id,
       else
       {
        /* But first print all the data in our incoming queue */
-       print_incoming_data(); 
+       print_incoming_data();
        MPI_Probe(MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &Status);
        if(Status.MPI_TAG == MPI_TAG_DONE)
        {
@@ -644,16 +644,16 @@ hsize_t diff_match (hid_t file1_id,
         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;
@@ -672,7 +672,7 @@ hsize_t diff_match (hid_t file1_id,
      }
  }
  h5diffdebug("done with for loop\n");
- 
+
 #ifdef H5_HAVE_PARALLEL
  if(g_Parallel)
  {
@@ -704,7 +704,7 @@ hsize_t diff_match (hid_t file1_id,
      do
      {
       MPI_Iprobe(MPI_ANY_SOURCE, MPI_TAG_TOK_RETURN, MPI_COMM_WORLD, &incomingMessage, &Status);
-      
+
       print_incoming_data();
      }
      while(!incomingMessage);
@@ -720,12 +720,12 @@ hsize_t diff_match (hid_t file1_id,
      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;
@@ -745,9 +745,9 @@ hsize_t diff_match (hid_t file1_id,
    {
     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
@@ -756,34 +756,34 @@ hsize_t diff_match (hid_t file1_id,
     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");
- 
+
  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;
 }
 
@@ -810,16 +810,16 @@ hsize_t diff_compare (hid_t file1_id,
                       hid_t file2_id,
                       const char *file2_name,
                       const char *obj2_name,
-                      int nobjects2, 
-                      trav_info_t * info2, 
+                      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,
@@ -837,11 +837,11 @@ hsize_t diff_compare (hid_t file1_id,
   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)
  {
@@ -853,10 +853,10 @@ hsize_t diff_compare (hid_t file1_id,
   options->not_cmp=1;
   return 0;
  }
- 
+
  nfound =
   diff (file1_id, obj1_name, file2_id, obj2_name, options, info1[i].type);
- 
+
  return nfound;
 }
 
@@ -882,9 +882,9 @@ hsize_t 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, 
+              hid_t file2_id,
+              const char *path2,
+              diff_opt_t * options,
               H5G_obj_t type)
 {
  hid_t       type1_id=(-1);
@@ -895,7 +895,7 @@ hsize_t diff (hid_t file1_id,
  H5G_stat_t sb1;
  H5G_stat_t sb2;
  hsize_t nfound = 0;
- 
+
  switch (type)
  {
 /*-------------------------------------------------------------------------
@@ -903,7 +903,7 @@ hsize_t diff (hid_t file1_id,
  *-------------------------------------------------------------------------
  */
  case H5G_DATASET:
-  
+
 /*-------------------------------------------------------------------------
  * verbose, always print name
  *-------------------------------------------------------------------------
@@ -939,7 +939,7 @@ hsize_t diff (hid_t file1_id,
      print_found(nfound);
     }  /*if nfound */
    } /*if quiet */
-   
+
  /*-------------------------------------------------------------------------
   * quiet mode, just count differences
   *-------------------------------------------------------------------------
@@ -949,9 +949,9 @@ hsize_t diff (hid_t file1_id,
     nfound = diff_dataset (file1_id, file2_id, path1, path2, options);
    }
   }   /*else verbose */
-  
+
   break;
-  
+
  /*-------------------------------------------------------------------------
   * H5G_TYPE
   *-------------------------------------------------------------------------
@@ -961,20 +961,20 @@ hsize_t diff (hid_t file1_id,
    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
@@ -982,14 +982,14 @@ hsize_t diff (hid_t file1_id,
   */
   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
   *-------------------------------------------------------------------------
@@ -999,19 +999,19 @@ hsize_t diff (hid_t file1_id,
    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
@@ -1019,15 +1019,15 @@ hsize_t diff (hid_t file1_id,
   */
   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
   *-------------------------------------------------------------------------
@@ -1036,37 +1036,37 @@ hsize_t diff (hid_t file1_id,
   {
    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.linklen);
    buf2 = HDmalloc (sb2.linklen);
-   
+
    if (H5Gget_linkval (file1_id, path1, sb1.linklen, buf1) < 0)
     goto out;
    if (H5Gget_linkval (file2_id, path2, sb1.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)
@@ -1075,13 +1075,13 @@ hsize_t diff (hid_t file1_id,
     path1, path2, get_type (type));
    options->not_cmp=1;
   }
-  
+
   break;
  } /* switch */
-    
-    
+
+
 out:
- 
+
  /* close */
  /* disable error reporting */
  H5E_BEGIN_TRY