HDFFV-10297 add h5copy test and fix h5diff errors

7 files changed, 673 insertions, 679 deletions

diff --git a/tools/lib/h5diff.c b/tools/lib/h5diff.c
index a584bf2..ab5d125 100644
--- a/tools/lib/h5diff.c
+++ b/tools/lib/h5diff.c
@@ -27,9 +27,9 @@
  *-------------------------------------------------------------------------
  */
 H5_ATTR_PURE int
-print_objname (diff_opt_t * options, hsize_t nfound)
+print_objname (diff_opt_t * opts, hsize_t nfound)
 {
-    return ((options->m_verbose || nfound) && !options->m_quiet) ? 1 : 0;
+    return ((opts->m_verbose || nfound) && !opts->m_quiet) ? 1 : 0;
 }
 
 /*-------------------------------------------------------------------------
@@ -72,9 +72,9 @@ do_print_attrname (const char *attr, const char *path1, const char *path2)
  *-------------------------------------------------------------------------
  */
 static int
-print_warn(diff_opt_t *options)
+print_warn(diff_opt_t *opts)
 {
-    return ((options->m_verbose)) ? 1: 0;
+    return ((opts->m_verbose)) ? 1: 0;
 }
 
 
@@ -135,23 +135,23 @@ print_incoming_data(void)
  *           0 : Not valid
  *------------------------------------------------------------------------*/
 static int
-is_valid_options(diff_opt_t *options)
+is_valid_options(diff_opt_t *opts)
 {
     int ret_value = 1; /* init to valid */
 
     /*-----------------------------------------------
      * no -q(quiet) with -v (verbose) or -r (report) */
-    if(options->m_quiet && (options->m_verbose || options->m_report)) {
+    if(opts->m_quiet && (opts->m_verbose || opts->m_report)) {
         parallel_print("Error: -q (quiet mode) cannot be added to verbose or report modes\n");
-        options->err_stat = 1;
+        opts->err_stat = 1;
         HGOTO_DONE(0);
     }
 
     /* -------------------------------------------------------
      * only allow --no-dangling-links along with --follow-symlinks */
-    if(options->no_dangle_links && !options->follow_links) {
+    if(opts->no_dangle_links && !opts->follow_links) {
         parallel_print("Error: --no-dangling-links must be used along with --follow-symlinks option.\n");
-        options->err_stat = 1;
+        opts->err_stat = 1;
         HGOTO_DONE(0);
     }
 
@@ -170,18 +170,18 @@ done:
  *           0 - not excluded path
  *------------------------------------------------------------------------*/
 static int
-is_exclude_path (char * path, h5trav_type_t type, diff_opt_t *options)
+is_exclude_path (char * path, h5trav_type_t type, diff_opt_t *opts)
 {
     struct exclude_path_list * exclude_path_ptr;
     int   ret_cmp;
     int   ret_value = 0;
 
     /* check if exclude path option is given */
-    if (!options->exclude_path)
+    if (!opts->exclude_path)
         HGOTO_DONE(0);
 
     /* assign to local exclude list pointer */
-    exclude_path_ptr = options->exclude;
+    exclude_path_ptr = opts->exclude;
 
     /* search objects in exclude list */
     while (NULL != exclude_path_ptr) {
@@ -232,9 +232,9 @@ done:
  * Purpose:  free exclude object list from diff options
  *------------------------------------------------------------------------*/
 static void
-free_exclude_path_list(diff_opt_t *options)
+free_exclude_path_list(diff_opt_t *opts)
 {
-    struct exclude_path_list *curr = options->exclude;
+    struct exclude_path_list *curr = opts->exclude;
     struct exclude_path_list *next;
 
     while (NULL != curr) {
@@ -260,7 +260,7 @@ free_exclude_path_list(diff_opt_t *options)
  *------------------------------------------------------------------------*/
 static void
 build_match_list (const char *objname1, trav_info_t *info1, const char *objname2, trav_info_t *info2,
-        trav_table_t ** table_out, diff_opt_t *options)
+        trav_table_t ** table_out, diff_opt_t *opts)
 {
     size_t   curr1 = 0;
     size_t   curr2 = 0;
@@ -306,7 +306,7 @@ build_match_list (const char *objname1, trav_info_t *info1, const char *objname2
         /* criteria is string compare */
         cmp = HDstrcmp(path1_lp, path2_lp);
         if(cmp == 0) {
-            if(!is_exclude_path(path1_lp, type1_l, options)) {
+            if(!is_exclude_path(path1_lp, type1_l, opts)) {
                 infile[0] = 1;
                 infile[1] = 1;
                 trav_table_addflags(infile, path1_lp, info1->paths[curr1].type, table);
@@ -322,7 +322,7 @@ build_match_list (const char *objname1, trav_info_t *info1, const char *objname2
             curr2++;
         } /* end if */
         else if(cmp < 0) {
-            if(!is_exclude_path(path1_lp, type1_l, options)) {
+            if(!is_exclude_path(path1_lp, type1_l, opts)) {
                 infile[0] = 1;
                 infile[1] = 0;
                 trav_table_addflags(infile, path1_lp, info1->paths[curr1].type, table);
@@ -330,7 +330,7 @@ build_match_list (const char *objname1, trav_info_t *info1, const char *objname2
             curr1++;
         } /* end else-if */
         else {
-            if (!is_exclude_path(path2_lp, type2_l, options)) {
+            if (!is_exclude_path(path2_lp, type2_l, opts)) {
                 infile[0] = 0;
                 infile[1] = 1;
                 trav_table_addflags(infile, path2_lp, info2->paths[curr2].type, table);
@@ -346,7 +346,7 @@ build_match_list (const char *objname1, trav_info_t *info1, const char *objname2
         path1_lp = (info1->paths[curr1].path) + path1_offset;
         type1_l = info1->paths[curr1].type;
 
-        if(!is_exclude_path(path1_lp, type1_l, options)) {
+        if(!is_exclude_path(path1_lp, type1_l, opts)) {
             trav_table_addflags(infile, path1_lp, info1->paths[curr1].type, table);
         }
         curr1++;
@@ -359,13 +359,13 @@ build_match_list (const char *objname1, trav_info_t *info1, const char *objname2
         path2_lp = (info2->paths[curr2].path) + path2_offset;
         type2_l = info2->paths[curr2].type;
 
-        if (!is_exclude_path(path2_lp, type2_l, options)) {
+        if (!is_exclude_path(path2_lp, type2_l, opts)) {
             trav_table_addflags(infile, path2_lp, info2->paths[curr2].type, table);
         }
         curr2++;
     } /* end while */
 
-    free_exclude_path_list (options);
+    free_exclude_path_list (opts);
 
     *table_out = table;
     h5difftrace("build_match_list finish\n");
@@ -764,7 +764,7 @@ h5diff(const char *fname1,
                 if (l_ret1 != 0 ||  l_ret2 != 0) {
                     nfound++;
                     print_found(nfound);
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5tools_get_symlink_info error");
+                    HGOTO_DONE(0);
                 }
             }
         }
@@ -804,10 +804,10 @@ h5diff(const char *fname1,
             else {
                 if(opts->m_verbose)
                     parallel_print("obj2 <%s> is a dangling link.\n", obj2fullname);
-                if (l_ret1 != 0 ||  l_ret2 != 0) {
+                if (l_ret1 != 0 || l_ret2 != 0) {
                     nfound++;
                     print_found(nfound);
-                    HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5tools_get_symlink_info error");
+                    HGOTO_DONE(0);
                 }
             }
         }
@@ -842,7 +842,7 @@ h5diff(const char *fname1,
         /* if no danglink links */
         if (l_ret1 > 0 && l_ret2 > 0)
             if (h5tools_is_obj_same(file1_id, obj1fullname, file2_id, obj2fullname)!=0)
-                HGOTO_ERROR(opts->err_stat, H5E_tools_min_id_g, "Same object");
+                HGOTO_DONE(0);
     }
 
     both_objs_grp = (obj1type == H5TRAV_TYPE_GROUP && obj2type == H5TRAV_TYPE_GROUP);
@@ -903,8 +903,7 @@ h5diff(const char *fname1,
         /*------------------------------------------------------
          * print the list
          */
-         if(opts->m_verbose)
-         {
+         if(opts->m_verbose) {
              unsigned u;
 
              parallel_print("\n");
@@ -927,7 +926,7 @@ h5diff(const char *fname1,
                         file2_id, obj2fullname, info2_lp,
                         match_list, opts);
 
-    opts->err_stat = 1; /* success status */
+    opts->err_stat = 0; /* success status */
 
 done:
 #ifdef H5_HAVE_PARALLEL
@@ -991,7 +990,7 @@ done:
 hsize_t
 diff_match(hid_t file1_id, const char *grp1, trav_info_t *info1,
                    hid_t file2_id, const char *grp2, trav_info_t *info2,
-                   trav_table_t *table, diff_opt_t *options)
+                   trav_table_t *table, diff_opt_t *opts)
 {
     hsize_t      nfound = 0;
     unsigned     i;
@@ -1023,17 +1022,17 @@ diff_match(hid_t file1_id, const char *grp1, trav_info_t *info1,
      */
 
     /* not valid compare used when --exclude-path option is used */
-    if (!options->exclude_path) {
+    if (!opts->exclude_path) {
         /* number of different objects */
         if (info1->nused != info2->nused) {
-            options->contents = 0;
+            opts->contents = 0;
         }
     }
 
     /* objects in one file and not the other */
     for(i = 0; i < table->nobjs; i++) {
         if(table->objs[i].flags[0] != table->objs[i].flags[1]) {
-            options->contents = 0;
+            opts->contents = 0;
             break;
         }
     }
@@ -1073,6 +1072,7 @@ diff_match(hid_t file1_id, const char *grp1, trav_info_t *info1,
                 HDstrcat(obj1_fullpath, table->objs[i].name);
             }
 #endif /* H5_HAVE_ASPRINTF */
+            h5diffdebug2("diff_match path1 - %s\n", obj1_fullpath);
 
             /* make full path for obj2 */
 #ifdef H5_HAVE_ASPRINTF
@@ -1089,6 +1089,7 @@ diff_match(hid_t file1_id, const char *grp1, trav_info_t *info1,
                 HDstrcat(obj2_fullpath, table->objs[i].name);
             }
 #endif /* H5_HAVE_ASPRINTF */
+            h5diffdebug2("diff_match path2 - %s\n", obj2_fullpath);
 
             /* get index to figure out type of the object in file1 */
             while(info1->paths[idx1].path && (HDstrcmp(obj1_fullpath, info1->paths[idx1].path) != 0))
@@ -1102,11 +1103,11 @@ diff_match(hid_t file1_id, const char *grp1, trav_info_t *info1,
             argdata.type[1] = info2->paths[idx2].type;
             argdata.is_same_trgobj = table->objs[i].is_same_trgobj;
 
-            options->cmn_objs = 1;
+            opts->cmn_objs = 1;
             if(!g_Parallel) {
                 nfound += diff(file1_id, obj1_fullpath,
                                file2_id, obj2_fullpath,
-                               options, &argdata);
+                            opts, &argdata);
             } /* end if */
 #ifdef H5_HAVE_PARALLEL
             else {
@@ -1131,7 +1132,7 @@ diff_match(hid_t file1_id, const char *grp1, trav_info_t *info1,
                 /* set args struct to pass */
                 HDstrcpy(args.name1, obj1_fullpath);
                 HDstrcpy(args.name2, obj2_fullpath);
-                args.options = *options;
+                args.opts = *opts;
                 args.argdata.type[0] = info1->paths[idx1].type;
                 args.argdata.type[1] = info2->paths[idx2].type;
                 args.argdata.is_same_trgobj = table->objs[i].is_same_trgobj;
@@ -1148,7 +1149,7 @@ diff_match(hid_t file1_id, const char *grp1, trav_info_t *info1,
                         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;
+                        opts->not_cmp = opts->not_cmp | nFoundbyWorker.not_cmp;
                         busyTasks--;
                     } /* end if */
 
@@ -1165,7 +1166,7 @@ diff_match(hid_t file1_id, const char *grp1, trav_info_t *info1,
                             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;
+                            opts->not_cmp = opts->not_cmp | nFoundbyWorker.not_cmp;
                             busyTasks--;
                             havePrintToken = 1;
                         } /* end if */
@@ -1217,7 +1218,7 @@ diff_match(hid_t file1_id, const char *grp1, trav_info_t *info1,
                                 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;
+                                opts->not_cmp = opts->not_cmp | nFoundbyWorker.not_cmp;
                                 /* send this task the work unit. */
                                 MPI_Send(&args, sizeof(args), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_ARGS, MPI_COMM_WORLD);
                             } /* end if */
@@ -1231,7 +1232,7 @@ diff_match(hid_t file1_id, const char *grp1, trav_info_t *info1,
                         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;
+                            opts->not_cmp = opts->not_cmp | nFoundbyWorker.not_cmp;
                             MPI_Send(&args, sizeof(args), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_ARGS, MPI_COMM_WORLD);
                         } /* end if */
                         else if(Status.MPI_TAG == MPI_TAG_TOK_REQUEST) {
@@ -1248,7 +1249,7 @@ diff_match(hid_t file1_id, const char *grp1, trav_info_t *info1,
 
                             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;
+                            opts->not_cmp = opts->not_cmp | nFoundbyWorker.not_cmp;
                             MPI_Send(&args, sizeof(args), MPI_BYTE, Status.MPI_SOURCE, MPI_TAG_ARGS, MPI_COMM_WORLD);
                         } /* end else-if */
                         else {
@@ -1276,7 +1277,7 @@ diff_match(hid_t file1_id, const char *grp1, trav_info_t *info1,
             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;
+                opts->not_cmp = opts->not_cmp | nFoundbyWorker.not_cmp;
                 busyTasks--;
             } /* end if */
             else if(Status.MPI_TAG == MPI_TAG_TOK_REQUEST) {
@@ -1294,7 +1295,7 @@ diff_match(hid_t file1_id, const char *grp1, trav_info_t *info1,
 
                     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;
+                    opts->not_cmp = opts->not_cmp | nFoundbyWorker.not_cmp;
                     busyTasks--;
                 } /* end if */
                 /* someone else must have it...wait for them to return it, then give it to the task that just asked for it. */
@@ -1311,7 +1312,7 @@ diff_match(hid_t file1_id, const char *grp1, trav_info_t *info1,
 
                     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;
+                    opts->not_cmp = opts->not_cmp | nFoundbyWorker.not_cmp;
                     busyTasks--;
                     MPI_Send(NULL, 0, MPI_BYTE, source, MPI_TAG_PRINT_TOK, MPI_COMM_WORLD);
                 } /* end else */
@@ -1319,7 +1320,7 @@ diff_match(hid_t file1_id, const char *grp1, trav_info_t *info1,
             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;
+                opts->not_cmp = opts->not_cmp | nFoundbyWorker.not_cmp;
                 busyTasks--;
                 havePrintToken = 1;
             } /* end else-if */
@@ -1353,7 +1354,7 @@ out:
     /* free table */
     if (table)
         trav_table_free(table);
-    h5difftrace("diff_match finish\n");
+    h5diffdebug2("diff_match finish:%d\n", nfound);
 
     return nfound;
 }
@@ -1377,7 +1378,7 @@ diff(hid_t file1_id,
               const char *path1,
               hid_t file2_id,
               const char *path2,
-              diff_opt_t * options,
+              diff_opt_t * opts,
               diff_args_t *argdata)
 {
     int           ret_value = 0;
@@ -1400,14 +1401,14 @@ diff(hid_t file1_id,
     h5difftrace("diff start\n");
 
     /*init error status */
-    options->err_stat = 1;
+    opts->err_stat = 1;
 
     /*init link info struct */
     HDmemset(&linkinfo1, 0, sizeof(h5tool_link_info_t));
     HDmemset(&linkinfo2, 0, sizeof(h5tool_link_info_t));
 
     /* pass how to handle printing warnings to linkinfo option */
-    if(print_warn(options))
+    if(print_warn(opts))
         linkinfo1.opt.msg_mode = linkinfo2.opt.msg_mode = 1;
 
     /* for symbolic links, take care follow symlink and no dangling link
@@ -1421,14 +1422,14 @@ diff(hid_t file1_id,
          */
 
         /* target object1 - get type and name */
-        if ((ret_value = H5tools_get_symlink_info(file1_id, path1, &linkinfo1, options->follow_links)) < 0)
+        if ((ret_value = H5tools_get_symlink_info(file1_id, path1, &linkinfo1, opts->follow_links)) < 0)
             HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5tools_get_symlink_info failed");
 
         /* dangling link */
         if (ret_value == 0) {
-            if (options->no_dangle_links) {
+            if (opts->no_dangle_links) {
                 /* dangling link is error */
-                if(options->m_verbose)
+                if(opts->m_verbose)
                     parallel_print("Warning: <%s> is a dangling link.\n", path1);
                 HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "dangling link is error");
             }
@@ -1437,13 +1438,13 @@ diff(hid_t file1_id,
         }
 
         /* target object2 - get type and name */
-        if ((ret_value = H5tools_get_symlink_info(file2_id, path2, &linkinfo2, options->follow_links)) < 0)
+        if ((ret_value = H5tools_get_symlink_info(file2_id, path2, &linkinfo2, opts->follow_links)) < 0)
             HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5tools_get_symlink_info failed");
         /* dangling link */
         if (ret_value == 0) {
-            if (options->no_dangle_links) {
+            if (opts->no_dangle_links) {
                 /* dangling link is error */
-                if(options->m_verbose)
+                if(opts->m_verbose)
                     parallel_print("Warning: <%s> is a dangling link.\n", path2);
                 HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "dangling link is error");
             }
@@ -1453,12 +1454,12 @@ diff(hid_t file1_id,
 
         /* found dangling link */
         if (is_dangle_link1 || is_dangle_link2) {
-            options->err_stat = 0;
+            opts->err_stat = 0;
             HGOTO_DONE(0);
         }
 
         /* follow symbolic link option */
-        if (options->follow_links) {
+        if (opts->follow_links) {
             if (linkinfo1.linfo.type == H5L_TYPE_SOFT ||
                     linkinfo1.linfo.type == H5L_TYPE_EXTERNAL)
                 argdata->type[0] = (h5trav_type_t)linkinfo1.trg_type;
@@ -1469,16 +1470,16 @@ diff(hid_t file1_id,
     }
     /* if objects are not the same type */
     if (argdata->type[0] != argdata->type[1]) {
-        if (options->m_verbose||options->m_list_not_cmp) {
+        if (opts->m_verbose||opts->m_list_not_cmp) {
             parallel_print("Not comparable: <%s> is of type %s and <%s> is of type %s\n",
             path1, get_type(argdata->type[0]),
             path2, get_type(argdata->type[1]));
         }
-        options->not_cmp = 1;
+        opts->not_cmp = 1;
         /* TODO: will need to update non-comparable is different
-         * options->contents = 0;
+         * opts->contents = 0;
          */
-        options->err_stat = 0;
+        opts->err_stat = 0;
         HGOTO_DONE(0);
     }
     else /* now both object types are same */
@@ -1497,41 +1498,41 @@ diff(hid_t file1_id,
         is_hard_link = (object_type == H5TRAV_TYPE_DATASET ||
                         object_type == H5TRAV_TYPE_NAMED_DATATYPE ||
                         object_type == H5TRAV_TYPE_GROUP);
-        if (options->follow_links || is_hard_link) {
+        if (opts->follow_links || is_hard_link) {
             /* print information is only verbose option is used */
-            if(options->m_verbose || options->m_report) {
+            if(opts->m_verbose || opts->m_report) {
                 switch(object_type) {
                     case H5TRAV_TYPE_DATASET:
-                        do_print_objname("dataset", path1, path2, options);
+                        do_print_objname("dataset", path1, path2, opts);
                         break;
                     case H5TRAV_TYPE_NAMED_DATATYPE:
-                        do_print_objname("datatype", path1, path2, options);
+                        do_print_objname("datatype", path1, path2, opts);
                         break;
                     case H5TRAV_TYPE_GROUP:
-                        do_print_objname("group", path1, path2, options);
+                        do_print_objname("group", path1, path2, opts);
                         break;
                     case H5TRAV_TYPE_LINK:
-                        do_print_objname("link", path1, path2, options);
+                        do_print_objname("link", path1, path2, opts);
                         break;
                     case H5TRAV_TYPE_UDLINK:
                         if(linkinfo1.linfo.type == H5L_TYPE_EXTERNAL && linkinfo2.linfo.type == H5L_TYPE_EXTERNAL)
-                            do_print_objname("external link", path1, path2, options);
+                            do_print_objname("external link", path1, path2, opts);
                         else
-                            do_print_objname ("user defined link", path1, path2, options);
+                            do_print_objname ("user defined link", path1, path2, opts);
                         break;
                     case H5TRAV_TYPE_UNKNOWN:
                     default:
                         parallel_print("Comparison not supported: <%s> and <%s> are of type %s\n",
                             path1, path2, get_type(object_type) );
-                        options->not_cmp = 1;
+                        opts->not_cmp = 1;
                         break;
                 } /* switch(type)*/
 
                 print_found(nfound);
-            } /* if(options->m_verbose || options->m_report) */
+            } /* if(opts->m_verbose || opts->m_report) */
 
             /* exact same, so comparison is done */
-            options->err_stat = 0;
+            opts->err_stat = 0;
             HGOTO_DONE(0);
         }
     }
@@ -1547,24 +1548,25 @@ diff(hid_t file1_id,
             if((dset2_id = H5Dopen2(file2_id, path2, H5P_DEFAULT)) < 0)
                 HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Dopen2 failed");
             /* verbose (-v) and report (-r) mode */
-            if(options->m_verbose || options->m_report) {
-                do_print_objname("dataset", path1, path2, options);
-                nfound = diff_dataset(file1_id, file2_id, path1, path2, options);
+            if(opts->m_verbose || opts->m_report) {
+                do_print_objname("dataset", path1, path2, opts);
+                nfound = diff_dataset(file1_id, file2_id, path1, path2, opts);
                 print_found(nfound);
             }
             /* quiet mode (-q), just count differences */
-            else if(options->m_quiet) {
-                nfound = diff_dataset(file1_id, file2_id, path1, path2, options);
+            else if(opts->m_quiet) {
+                nfound = diff_dataset(file1_id, file2_id, path1, path2, opts);
             }
             /* the rest (-c, none, ...) */
             else {
-                nfound = diff_dataset(file1_id, file2_id, path1, path2, options);
+                nfound = diff_dataset(file1_id, file2_id, path1, path2, opts);
                 /* print info if difference found  */
                 if (nfound) {
-                    do_print_objname("dataset", path1, path2, options);
+                    do_print_objname("dataset", path1, path2, opts);
                     print_found(nfound);
                 }
             }
+            h5diffdebug2("diff after dataset:%d\n", nfound);
 
             /*---------------------------------------------------------
              * compare attributes
@@ -1573,7 +1575,7 @@ diff(hid_t file1_id,
              *---------------------------------------------------------
              */
             if(path1)
-                nfound += diff_attr(dset1_id, dset2_id, path1, path2, options);
+                nfound += diff_attr(dset1_id, dset2_id, path1, path2, opts);
 
 
             if(H5Dclose(dset1_id) < 0)
@@ -1598,11 +1600,11 @@ diff(hid_t file1_id,
             /* if H5Tequal is > 0 then the datatypes refer to the same datatype */
             nfound = (ret_value > 0) ? 0 : 1;
 
-            if(print_objname(options,nfound))
-                do_print_objname("datatype", path1, path2, options);
+            if(print_objname(opts, nfound))
+                do_print_objname("datatype", path1, path2, opts);
 
             /* always print the number of differences found in verbose mode */
-            if(options->m_verbose)
+            if(opts->m_verbose)
                 print_found(nfound);
 
             /*-----------------------------------------------------------------
@@ -1612,7 +1614,7 @@ diff(hid_t file1_id,
              *-----------------------------------------------------------------
              */
             if(path1)
-                nfound += diff_attr(type1_id, type2_id, path1, path2, options);
+                nfound += diff_attr(type1_id, type2_id, path1, path2, opts);
 
             if(H5Tclose(type1_id) < 0)
                 HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose failed");
@@ -1625,11 +1627,11 @@ diff(hid_t file1_id,
         *----------------------------------------------------------------------
         */
         case H5TRAV_TYPE_GROUP:
-            if(print_objname(options, nfound))
-                do_print_objname("group", path1, path2, options);
+            if(print_objname(opts, nfound))
+                do_print_objname("group", path1, path2, opts);
 
             /* always print the number of differences found in verbose mode */
-            if(options->m_verbose)
+            if(opts->m_verbose)
                 print_found(nfound);
 
             if((grp1_id = H5Gopen2(file1_id, path1, H5P_DEFAULT)) < 0)
@@ -1644,7 +1646,7 @@ diff(hid_t file1_id,
              *-----------------------------------------------------------------
              */
             if(path1)
-                nfound += diff_attr(grp1_id, grp2_id, path1, path2, options);
+                nfound += diff_attr(grp1_id, grp2_id, path1, path2, opts);
 
             if(H5Gclose(grp1_id) < 0)
                 HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Gclose failed");
@@ -1664,11 +1666,11 @@ diff(hid_t file1_id,
                 /* if the target link name is not same then the links are "different" */
                 nfound = (ret_value != 0) ? 1 : 0;
 
-                if(print_objname(options, nfound))
-                    do_print_objname("link", path1, path2, options);
+                if(print_objname(opts, nfound))
+                    do_print_objname("link", path1, path2, opts);
 
                 /* always print the number of differences found in verbose mode */
-                if(options->m_verbose)
+                if(opts->m_verbose)
                     print_found(nfound);
 
                 }
@@ -1695,8 +1697,8 @@ diff(hid_t file1_id,
                      */
                     nfound = (ret_value != 0) ? 1 : 0;
 
-                    if(print_objname(options, nfound))
-                        do_print_objname("external link", path1, path2, options);
+                    if(print_objname(opts, nfound))
+                        do_print_objname("external link", path1, path2, opts);
 
                 } /* end if */
                 else {
@@ -1713,26 +1715,26 @@ diff(hid_t file1_id,
                     else
                         nfound = 0;
 
-                    if (print_objname (options, nfound))
-                        do_print_objname ("user defined link", path1, path2, options);
+                    if (print_objname (opts, nfound))
+                        do_print_objname ("user defined link", path1, path2, opts);
                 } /* end else */
 
                 /* always print the number of differences found in verbose mode */
-                if(options->m_verbose)
+                if(opts->m_verbose)
                     print_found(nfound);
             }
             break;
 
         case H5TRAV_TYPE_UNKNOWN:
         default:
-            if(options->m_verbose)
+            if(opts->m_verbose)
                 parallel_print("Comparison not supported: <%s> and <%s> are of type %s\n",
                     path1, path2, get_type(object_type) );
-            options->not_cmp = 1;
+            opts->not_cmp = 1;
             break;
      }
 
-    options->err_stat = 0;
+    opts->err_stat = 0;
 
 done:
     /*-----------------------------------
@@ -1740,25 +1742,25 @@ done:
      */
     /* both path1 and path2 are dangling links */
     if(is_dangle_link1 && is_dangle_link2) {
-        if(print_objname(options, nfound)) {
-            do_print_objname("dangling link", path1, path2, options);
+        if(print_objname(opts, nfound)) {
+            do_print_objname("dangling link", path1, path2, opts);
             print_found(nfound);
         }
     }
     /* path1 is dangling link */
     else if (is_dangle_link1) {
-        if(options->m_verbose)
+        if(opts->m_verbose)
            parallel_print("obj1 <%s> is a dangling link.\n", path1);
         nfound++;
-        if(print_objname(options, nfound))
+        if(print_objname(opts, nfound))
             print_found(nfound);
     }
     /* path2 is dangling link */
     else if (is_dangle_link2) {
-        if(options->m_verbose)
+        if(opts->m_verbose)
             parallel_print("obj2 <%s> is a dangling link.\n", path2);
         nfound++;
-        if(print_objname(options, nfound))
+        if(print_objname(opts, nfound))
             print_found(nfound);
     }
 
@@ -1780,7 +1782,7 @@ done:
         /* enable error reporting */
     } H5E_END_TRY;
 
-    h5difftrace("diff finish\n");
+    h5diffdebug2("diff finish:%d\n", nfound);
 
     return nfound;
 }
diff --git a/tools/lib/h5diff.h b/tools/lib/h5diff.h
index 0226e83..26bcd95 100644
--- a/tools/lib/h5diff.h
+++ b/tools/lib/h5diff.h
@@ -38,7 +38,7 @@
 
 /*-------------------------------------------------------------------------
  * This is used to pass multiple args into diff().
- * Passing this instead of several each arg provides smoother extensibility 
+ * Passing this instead of several each arg provides smoother extensibility
  * through its members along with MPI code for ph5diff
  * as it doesn't require interface change.
  *------------------------------------------------------------------------*/
@@ -95,13 +95,13 @@ H5TOOLS_DLL hsize_t  h5diff(const char *fname1,
                 const char *fname2,
                 const char *objname1,
                 const char *objname2,
-                diff_opt_t *options);
+                diff_opt_t *opts);
 
 H5TOOLS_DLL hsize_t diff( hid_t      file1_id,
               const char *path1,
               hid_t      file2_id,
               const char *path2,
-              diff_opt_t *options,
+              diff_opt_t *opts,
               diff_args_t *argdata);
 
 #ifdef H5_HAVE_PARALLEL
@@ -125,18 +125,18 @@ hsize_t diff_dataset( hid_t file1_id,
                       hid_t file2_id,
                       const char *obj1_name,
                       const char *obj2_name,
-                      diff_opt_t *options);
+                      diff_opt_t *opts);
 
 hsize_t diff_datasetid( hid_t dset1_id,
                         hid_t dset2_id,
                         const char *obj1_name,
                         const char *obj2_name,
-                        diff_opt_t *options);
+                        diff_opt_t *opts);
 
 
 hsize_t diff_match( hid_t file1_id, const char *grp1, trav_info_t *info1,
                     hid_t file2_id, const char *grp2, trav_info_t *info2,
-                    trav_table_t *table, diff_opt_t *options );
+                    trav_table_t *table, diff_opt_t *opts );
 
 hsize_t diff_array( void *_mem1,
                     void *_mem2,
@@ -144,7 +144,7 @@ hsize_t diff_array( void *_mem1,
                     hsize_t hyper_start,
                     int rank,
                     hsize_t *dims,
-                    diff_opt_t *options,
+                    diff_opt_t *opts,
                     const char *name1,
                     const char *name2,
                     hid_t m_type,
@@ -162,7 +162,7 @@ int diff_can_type( hid_t       f_type1, /* file data type */
                    hsize_t     *maxdim2,
                    const char  *obj1_name,
                    const char  *obj2_name,
-                   diff_opt_t  *options,
+                   diff_opt_t  *opts,
                    int         is_compound);
 
 
@@ -170,7 +170,7 @@ hsize_t diff_attr(hid_t loc1_id,
                   hid_t loc2_id,
                   const char *path1,
                   const char *path2,
-                  diff_opt_t *options);
+                  diff_opt_t *opts);
 
 
 /*-------------------------------------------------------------------------
@@ -187,10 +187,10 @@ const char* get_class(H5T_class_t tclass);
 const char* get_sign(H5T_sign_t sign);
 void        print_dimensions (int rank, hsize_t *dims);
 herr_t      match_up_memsize (hid_t f_tid1_id, hid_t f_tid2_id,
-                              hid_t *m_tid1, hid_t *m_tid2, 
+                              hid_t *m_tid1, hid_t *m_tid2,
                               size_t *m_size1, size_t  *m_size2);
 /* in h5diff.c */
-int         print_objname(diff_opt_t *options, hsize_t nfound);
+int         print_objname(diff_opt_t *opts, hsize_t nfound);
 void        do_print_objname (const char *OBJ, const char *path1, const char *path2, diff_opt_t * opts);
 void        do_print_attrname (const char *attr, const char *path1, const char *path2);
 
diff --git a/tools/lib/h5diff_array.c b/tools/lib/h5diff_array.c
index 58a5e09..5d77de3 100644
--- a/tools/lib/h5diff_array.c
+++ b/tools/lib/h5diff_array.c
@@ -131,21 +131,21 @@ typedef struct mcomp_t {
  *-------------------------------------------------------------------------
  */
 static hsize_t diff_region(hid_t obj1_id, hid_t obj2_id, hid_t region1_id,
-        hid_t region2_id, diff_opt_t *options);
+        hid_t region2_id, diff_opt_t *opts);
 static hbool_t all_zero(const void *_mem, size_t size);
 static int ull2float(unsigned long long ull_value, float *f_value);
 static hsize_t character_compare(char *mem1, char *mem2, hsize_t i, size_t u,
         int rank, hsize_t *dims, hsize_t *acc, hsize_t *pos,
-        diff_opt_t *options, const char *obj1, const char *obj2, int *ph);
+        diff_opt_t *opts, const char *obj1, const char *obj2, int *ph);
 static hsize_t character_compare_opt(unsigned char *mem1, unsigned char *mem2,
         hsize_t i, int rank, hsize_t *dims, hsize_t *acc, hsize_t *pos,
-        diff_opt_t *options, const char *obj1, const char *obj2, int *ph);
-static hbool_t equal_float(float value, float expected, diff_opt_t *options);
-static hbool_t equal_double(double value, double expected, diff_opt_t *options);
+        diff_opt_t *opts, const char *obj1, const char *obj2, int *ph);
+static hbool_t equal_float(float value, float expected, diff_opt_t *opts);
+static hbool_t equal_double(double value, double expected, diff_opt_t *opts);
 #if H5_SIZEOF_LONG_DOUBLE !=0
-static hbool_t equal_ldouble(long double value, long double expected, diff_opt_t *options);
+static hbool_t equal_ldouble(long double value, long double expected, diff_opt_t *opts);
 #endif
-static int print_data(diff_opt_t *options);
+static int print_data(diff_opt_t *opts);
 static void print_pos(int *ph, int pp, hsize_t curr_pos, hsize_t *acc,
         hsize_t *pos, int rank, hsize_t *dims, const char *obj1,
         const char *obj2);
@@ -155,17 +155,17 @@ static void print_char_pos(int *ph, int pp, hsize_t curr_pos, size_t u,
 static void h5diff_print_char(char ch);
 static hsize_t diff_datum(void *_mem1, void *_mem2, hid_t m_type, hsize_t index,
         int rank, hsize_t *dims, hsize_t *acc, hsize_t *pos,
-        diff_opt_t *options, const char *obj1, const char *obj2,
+        diff_opt_t *opts, const char *obj1, const char *obj2,
         hid_t container1_id, hid_t container2_id, /*where the reference came from*/
         int *ph, /*print header */
         mcomp_t *members); /*compound members */
 static hsize_t diff_float(unsigned char *mem1, unsigned char *mem2,
         hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
-        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1,
         const char *obj2, int *ph);
 static hsize_t diff_double(unsigned char *mem1, unsigned char *mem2,
         hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
-        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1,
         const char *obj2, int *ph);
 #if H5_SIZEOF_LONG_DOUBLE !=0
 static hsize_t diff_ldouble(unsigned char *mem1,
@@ -176,50 +176,50 @@ static hsize_t diff_ldouble(unsigned char *mem1,
         hsize_t *dims,
         hsize_t *acc,
         hsize_t *pos,
-        diff_opt_t *options,
+        diff_opt_t *opts,
         const char *obj1,
         const char *obj2,
         int *ph);
 #endif
 static hsize_t diff_schar(unsigned char *mem1, unsigned char *mem2,
         hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
-        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1,
         const char *obj2, int *ph);
 static hsize_t diff_uchar(unsigned char *mem1, unsigned char *mem2,
         hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
-        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1,
         const char *obj2, int *ph);
 static hsize_t diff_short(unsigned char *mem1, unsigned char *mem2,
         hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
-        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1,
         const char *obj2, int *ph);
 static hsize_t diff_ushort(unsigned char *mem1, unsigned char *mem2,
         hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
-        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1,
         const char *obj2, int *ph);
 static hsize_t diff_int(unsigned char *mem1, unsigned char *mem2,
         hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
-        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1,
         const char *obj2, int *ph);
 static hsize_t diff_uint(unsigned char *mem1, unsigned char *mem2,
         hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
-        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1,
         const char *obj2, int *ph);
 static hsize_t diff_long(unsigned char *mem1, unsigned char *mem2,
         hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
-        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1,
         const char *obj2, int *ph);
 static hsize_t diff_ulong(unsigned char *mem1, unsigned char *mem2,
         hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
-        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1,
         const char *obj2, int *ph);
 static hsize_t diff_llong(unsigned char *mem1, unsigned char *mem2,
         hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
-        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1,
         const char *obj2, int *ph);
 static hsize_t diff_ullong(unsigned char *mem1, unsigned char *mem2,
         hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
-        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1,
         const char *obj2, int *ph);
 
 /*-------------------------------------------------------------------------
@@ -266,7 +266,7 @@ hsize_t diff_array(
         hsize_t hyper_start,
         int rank,
         hsize_t *dims,
-        diff_opt_t *options,
+        diff_opt_t *opts,
         const char *name1,
         const char *name2,
         hid_t m_type,
@@ -324,36 +324,36 @@ hsize_t diff_array(
      */
     case H5T_FLOAT:
         if (H5Tequal(m_type, H5T_NATIVE_FLOAT))
-            nfound = diff_float(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
+            nfound = diff_float(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, opts, name1, name2, &ph);
         else if (H5Tequal(m_type, H5T_NATIVE_DOUBLE))
-            nfound = diff_double(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
+            nfound = diff_double(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, opts, name1, name2, &ph);
 #if H5_SIZEOF_LONG_DOUBLE != 0
         else if (H5Tequal(m_type, H5T_NATIVE_LDOUBLE))
-        nfound = diff_ldouble(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
+        nfound = diff_ldouble(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, opts, name1, name2, &ph);
 #endif
         break;
 
     case H5T_INTEGER:
         if (H5Tequal(m_type, H5T_NATIVE_SCHAR))
-            nfound = diff_schar(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
+            nfound = diff_schar(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, opts, name1, name2, &ph);
         else if (H5Tequal(m_type, H5T_NATIVE_UCHAR))
-            nfound = diff_uchar(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
+            nfound = diff_uchar(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, opts, name1, name2, &ph);
         else if (H5Tequal(m_type, H5T_NATIVE_SHORT))
-            nfound = diff_short(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
+            nfound = diff_short(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, opts, name1, name2, &ph);
         else if (H5Tequal(m_type, H5T_NATIVE_USHORT))
-            nfound = diff_ushort(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
+            nfound = diff_ushort(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, opts, name1, name2, &ph);
         else if (H5Tequal(m_type, H5T_NATIVE_INT))
-            nfound = diff_int(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
+            nfound = diff_int(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, opts, name1, name2, &ph);
         else if (H5Tequal(m_type, H5T_NATIVE_UINT))
-            nfound = diff_uint(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
+            nfound = diff_uint(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, opts, name1, name2, &ph);
         else if (H5Tequal(m_type, H5T_NATIVE_LONG))
-            nfound = diff_long(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
+            nfound = diff_long(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, opts, name1, name2, &ph);
         else if (H5Tequal(m_type, H5T_NATIVE_ULONG))
-            nfound = diff_ulong(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
+            nfound = diff_ulong(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, opts, name1, name2, &ph);
         else if (H5Tequal(m_type, H5T_NATIVE_LLONG))
-            nfound = diff_llong(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
+            nfound = diff_llong(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, opts, name1, name2, &ph);
         else if (H5Tequal(m_type, H5T_NATIVE_ULLONG))
-            nfound = diff_ullong(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, options, name1, name2, &ph);
+            nfound = diff_ullong(mem1, mem2, nelmts, hyper_start, rank, dims, acc, pos, opts, name1, name2, &ph);
         break;
 
     /*-------------------------------------------------------------------------
@@ -371,14 +371,14 @@ hsize_t diff_array(
         HDmemset(&members, 0, sizeof(mcomp_t));
         get_member_types(m_type, &members);
         for (i = 0; i < nelmts; i++) {
-            nfound += diff_datum(mem1 + i * size, mem2 + i * size, m_type, i, rank, dims, acc, pos, options,
+            nfound += diff_datum(mem1 + i * size, mem2 + i * size, m_type, i, rank, dims, acc, pos, opts,
                     name1, name2, container1_id, container2_id, &ph, &members);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 break;
         } /* i */
         close_member_types(&members);
     } /* switch */
-    h5difftrace("diff_array finish\n");
+    h5diffdebug2("diff_array finish:%d\n", nfound);
 
     return nfound;
 }
@@ -425,7 +425,7 @@ static hsize_t diff_datum(
         hsize_t *dims,
         hsize_t *acc,
         hsize_t *pos,
-        diff_opt_t *options,
+        diff_opt_t *opts,
         const char *obj1,
         const char *obj2,
         hid_t container1_id,
@@ -447,11 +447,14 @@ static hsize_t diff_datum(
     hbool_t         iszero1;
     hbool_t         iszero2;
     hsize_t         nfound = 0;    /* differences found */
-    hsize_t         ret_value = 0; /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
+    hsize_t         ret_value = 0;
     double          per;
     hbool_t         both_zero;
 
     h5difftrace("diff_datum start\n");
+    /* default error sttaus */
+    opts->err_stat = 1;
+
     type_size = H5Tget_size(m_type);
     type_class = H5Tget_class(m_type);
 
@@ -489,7 +492,7 @@ static hsize_t diff_datum(
                 memb_type = members->ids[j];
 
                 nfound += diff_datum(mem1 + offset, mem2 + offset, memb_type, index,
-                        rank, dims, acc, pos, options, obj1, obj2, container1_id, container2_id, ph, members->m[j]);
+                        rank, dims, acc, pos, opts, obj1, obj2, container1_id, container2_id, ph, members->m[j]);
             }
         }
         break;
@@ -590,13 +593,13 @@ static hsize_t diff_datum(
                 /* try fast compare first */
                 if (HDmemcmp(s, sx, size) == 0) {
                     if (size1 != size2)
-                        if (print_data(options))
+                        if (print_data(opts))
                             for (u = size; u < sizex; u++)
-                                character_compare(s + u, sx + u, index, u, rank, dims, acc, pos, options, obj1, obj2, ph);
+                                character_compare(s + u, sx + u, index, u, rank, dims, acc, pos, opts, obj1, obj2, ph);
                 }
                 else
                     for (u = 0; u < size; u++)
-                        nfound += character_compare(s + u, sx + u, index, u, rank, dims, acc, pos, options, obj1, obj2, ph);
+                        nfound += character_compare(s + u, sx + u, index, u, rank, dims, acc, pos, opts, obj1, obj2, ph);
             } /* end check for NULL pointer for string */
         }
         break;
@@ -609,7 +612,7 @@ static hsize_t diff_datum(
         h5difftrace("diff_datum H5T_BITFIELD\n");
         /* byte-by-byte comparison */
         for (u = 0; u < type_size; u++)
-            nfound += character_compare_opt(mem1 + u, mem2 + u, index, rank, dims, acc, pos, options, obj1, obj2, ph);
+            nfound += character_compare_opt(mem1 + u, mem2 + u, index, rank, dims, acc, pos, opts, obj1, obj2, ph);
         break;
 
     /*-------------------------------------------------------------------------
@@ -620,7 +623,7 @@ static hsize_t diff_datum(
         h5difftrace("diff_datum H5T_OPAQUE\n");
         /* byte-by-byte comparison */
         for (u = 0; u < type_size; u++)
-            nfound += character_compare_opt(mem1 + u, mem2 + u, index, rank, dims, acc, pos, options, obj1, obj2, ph);
+            nfound += character_compare_opt(mem1 + u, mem2 + u, index, rank, dims, acc, pos, opts, obj1, obj2, ph);
         break;
 
     /*-------------------------------------------------------------------------
@@ -660,7 +663,7 @@ static hsize_t diff_datum(
                      * don't attempt to convert them - just report errors.
                      */
                     nfound += 1;
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(S_FORMAT, enum_name1, enum_name2);
@@ -670,7 +673,7 @@ static hsize_t diff_datum(
                     /* Both enum values were valid */
                     if (HDstrcmp(enum_name1, enum_name2) != 0) {
                         nfound = 1;
-                        if (print_data(options)) {
+                        if (print_data(opts)) {
                             print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
                             parallel_print(S_FORMAT, enum_name1, enum_name2);
@@ -678,7 +681,7 @@ static hsize_t diff_datum(
                     }
                     else {
                         for (u = 0; u < type_size; u++)
-                            nfound += character_compare_opt(mem1 + u, mem2 + u, index, rank, dims, acc, pos, options, obj1, obj2, ph);
+                            nfound += character_compare_opt(mem1 + u, mem2 + u, index, rank, dims, acc, pos, opts, obj1, obj2, ph);
                     }
                 }
                 /* enable error reporting */
@@ -708,7 +711,7 @@ static hsize_t diff_datum(
                 nelmts *= adims[u];
             for (u = 0; u < nelmts; u++) {
                 nfound += diff_datum(mem1 + u * size, mem2 + u * size, memb_type, index,
-                        rank, dims, acc, pos, options, obj1, obj2, container1_id, container2_id, ph, members);
+                        rank, dims, acc, pos, opts, obj1, obj2, container1_id, container2_id, ph, members);
             }
             H5Tclose(memb_type);
         }
@@ -746,18 +749,12 @@ static hsize_t diff_datum(
                 if ((region2_id = H5Rget_region(container2_id, H5R_DATASET_REGION, _mem2)) < 0)
                     HERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Rget_region object 2 failed");
 
-                if (ret_value >= 0)
-                    nfound = diff_region(obj1_id, obj2_id, region1_id, region2_id, options);
+                nfound = diff_region(obj1_id, obj2_id, region1_id, region2_id, opts);
 
                 H5Oclose(obj1_id);
                 H5Oclose(obj2_id);
                 H5Sclose(region1_id);
                 H5Sclose(region2_id);
-
-                if (ret_value == -1) {
-                    options->err_stat = 1;
-                    HGOTO_DONE(0);
-                }
             }/*dataset reference*/
 
             /*-------------------------------------------------------------------------
@@ -778,7 +775,7 @@ static hsize_t diff_datum(
                 if (ret_value >= 0)
                     if (obj1_type != obj2_type) {
                         parallel_print("Different object types referenced: <%s> and <%s>", obj1, obj2);
-                        options->not_cmp = 1;
+                        opts->not_cmp = 1;
                         HGOTO_DONE (0);
                     }
 
@@ -788,25 +785,18 @@ static hsize_t diff_datum(
                     HERROR(H5E_tools_g, H5E_tools_min_id_g, "H5Rdereference2 object 2 failed");
 
                 /* compare */
-                if (ret_value >= 0) {
-                    if (obj1_type == H5O_TYPE_DATASET)
-                        nfound = diff_datasetid(obj1_id, obj2_id, NULL, NULL, options);
-                    else {
-                        if (options->m_verbose)
-                            parallel_print(
-                                    "Warning: Comparison not possible of object types referenced: <%s> and <%s>\n",
-                                    obj1, obj2);
-                        options->not_cmp = 1;
-                    }
+                if (obj1_type == H5O_TYPE_DATASET)
+                    nfound = diff_datasetid(obj1_id, obj2_id, NULL, NULL, opts);
+                else {
+                    if (opts->m_verbose)
+                        parallel_print(
+                                "Warning: Comparison not possible of object types referenced: <%s> and <%s>\n",
+                                obj1, obj2);
+                    opts->not_cmp = 1;
                 }
 
                 H5Oclose(obj1_id);
                 H5Oclose(obj2_id);
-
-                if (ret_value == -1) {
-                    options->err_stat = 1;
-                    HGOTO_DONE(0);
-                }
             }/*object reference*/
         }/*is zero*/
         break;
@@ -828,7 +818,7 @@ static hsize_t diff_datum(
 
             for (j = 0; j < nelmts; j++)
                 nfound += diff_datum(((char *) (((hvl_t *) mem1)->p)) + j * size, ((char *) (((hvl_t *) mem2)->p)) + j * size, memb_type, index,
-                        rank, dims, acc, pos, options, obj1, obj2, container1_id, container2_id, ph, members);
+                        rank, dims, acc, pos, opts, obj1, obj2, container1_id, container2_id, ph, members);
 
             H5Tclose(memb_type);
         }
@@ -853,9 +843,9 @@ static hsize_t diff_datum(
             HDmemcpy(&temp1_char, mem1, sizeof(char));
             HDmemcpy(&temp2_char, mem2, sizeof(char));
             /* -d and !-p */
-            if (options->d && !options->p) {
-                if (ABS(temp1_char-temp2_char) > options->delta) {
-                    if (print_data(options)) {
+            if (opts->d && !opts->p) {
+                if (ABS(temp1_char-temp2_char) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT, temp1_char, temp2_char, ABS(temp1_char - temp2_char));
@@ -864,19 +854,19 @@ static hsize_t diff_datum(
                 }
             }
             /* !-d and -p */
-            else if (!options->d && options->p) {
+            else if (!opts->d && opts->p) {
                 PER(temp1_char, temp2_char);
 
                 if (not_comparable && !both_zero) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT_P_NOTCOMP, temp1_char, temp2_char, ABS(temp1_char - temp2_char));
                     }
                     nfound++;
                 }
-                else if (per > options->percent) {
-                    if (print_data(options)) {
+                else if (per > opts->percent) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT_P, temp1_char, temp2_char, ABS(temp1_char - temp2_char), per);
@@ -885,19 +875,19 @@ static hsize_t diff_datum(
                 }
             }
             /* -d and -p */
-            else if (options->d && options->p) {
+            else if (opts->d && opts->p) {
                 PER(temp1_char, temp2_char);
 
                 if (not_comparable && !both_zero) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT_P_NOTCOMP, temp1_char, temp2_char, ABS(temp1_char - temp2_char));
                     }
                     nfound++;
                 }
-                else if (per > options->percent && ABS(temp1_char - temp2_char) > options->delta) {
-                    if (print_data(options)) {
+                else if (per > opts->percent && ABS(temp1_char - temp2_char) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT_P, temp1_char, temp2_char, ABS(temp1_char - temp2_char), per);
@@ -906,7 +896,7 @@ static hsize_t diff_datum(
                 }
             }
             else if (temp1_char != temp2_char) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT, temp1_char, temp2_char, ABS(temp1_char - temp2_char));
@@ -929,9 +919,9 @@ static hsize_t diff_datum(
             HDmemcpy(&temp1_uchar, mem1, sizeof(unsigned char));
             HDmemcpy(&temp2_uchar, mem2, sizeof(unsigned char));
             /* -d and !-p */
-            if (options->d && !options->p) {
-                if (PDIFF(temp1_uchar, temp2_uchar) > options->delta) {
-                    if (print_data(options)) {
+            if (opts->d && !opts->p) {
+                if (PDIFF(temp1_uchar, temp2_uchar) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar));
@@ -940,19 +930,19 @@ static hsize_t diff_datum(
                 }
             }
             /* !-d and -p */
-            else if (!options->d && options->p) {
+            else if (!opts->d && opts->p) {
                 PER_UNSIGN(signed char, temp1_uchar, temp2_uchar);
 
                 if (not_comparable && !both_zero) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT_P_NOTCOMP, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar));
                     }
                     nfound++;
                 }
-                else if (per > options->percent) {
-                    if (print_data(options)) {
+                else if (per > opts->percent) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT_P, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar), per);
@@ -961,19 +951,19 @@ static hsize_t diff_datum(
                 }
             }
             /* -d and -p */
-            else if (options->d && options->p) {
+            else if (opts->d && opts->p) {
                 PER_UNSIGN(signed char, temp1_uchar, temp2_uchar);
 
                 if (not_comparable && !both_zero) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT_P_NOTCOMP, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar));
                     }
                     nfound++;
                 }
-                else if (per > options->percent && PDIFF(temp1_uchar, temp2_uchar) > options->delta) {
-                    if (print_data(options)) {
+                else if (per > opts->percent && PDIFF(temp1_uchar, temp2_uchar) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT_P, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar), per);
@@ -982,7 +972,7 @@ static hsize_t diff_datum(
                 }
             }
             else if (temp1_uchar != temp2_uchar) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar));
@@ -1005,9 +995,9 @@ static hsize_t diff_datum(
             HDmemcpy(&temp1_short, mem1, sizeof(short));
             HDmemcpy(&temp2_short, mem2, sizeof(short));
             /* -d and !-p */
-            if (options->d && !options->p) {
-                if (ABS(temp1_short - temp2_short) > options->delta) {
-                    if (print_data(options)) {
+            if (opts->d && !opts->p) {
+                if (ABS(temp1_short - temp2_short) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT, temp1_short, temp2_short, ABS(temp1_short - temp2_short));
@@ -1016,19 +1006,19 @@ static hsize_t diff_datum(
                 }
             }
             /* !-d and -p */
-            else if (!options->d && options->p) {
+            else if (!opts->d && opts->p) {
                 PER(temp1_short, temp2_short);
 
                 if (not_comparable && !both_zero) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT_P_NOTCOMP, temp1_short, temp2_short, ABS(temp1_short - temp2_short));
                     }
                     nfound++;
                 }
-                else if (per > options->percent) {
-                    if (print_data(options)) {
+                else if (per > opts->percent) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT_P, temp1_short, temp2_short, ABS(temp1_short - temp2_short), per);
@@ -1037,19 +1027,19 @@ static hsize_t diff_datum(
                 }
             }
             /* -d and -p */
-            else if (options->d && options->p) {
+            else if (opts->d && opts->p) {
                 PER(temp1_short, temp2_short);
 
                 if (not_comparable && !both_zero) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT_P_NOTCOMP, temp1_short, temp2_short, ABS(temp1_short - temp2_short));
                     }
                     nfound++;
                 }
-                else if (per > options->percent && ABS(temp1_short - temp2_short) > options->delta) {
-                    if (print_data(options)) {
+                else if (per > opts->percent && ABS(temp1_short - temp2_short) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT_P, temp1_short, temp2_short, ABS(temp1_short - temp2_short), per);
@@ -1058,7 +1048,7 @@ static hsize_t diff_datum(
                 }
             }
             else if (temp1_short != temp2_short) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT, temp1_short, temp2_short, ABS(temp1_short - temp2_short));
@@ -1081,9 +1071,9 @@ static hsize_t diff_datum(
             HDmemcpy(&temp1_ushort, mem1, sizeof(unsigned short));
             HDmemcpy(&temp2_ushort, mem2, sizeof(unsigned short));
             /* -d and !-p */
-            if (options->d && !options->p) {
-                if (PDIFF(temp1_ushort, temp2_ushort) > options->delta) {
-                    if (print_data(options)) {
+            if (opts->d && !opts->p) {
+                if (PDIFF(temp1_ushort, temp2_ushort) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort));
@@ -1092,19 +1082,19 @@ static hsize_t diff_datum(
                 }
             }
             /* !-d and -p */
-            else if (!options->d && options->p) {
+            else if (!opts->d && opts->p) {
                 PER_UNSIGN(signed short, temp1_ushort, temp2_ushort);
 
                 if (not_comparable && !both_zero) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT_P_NOTCOMP, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort));
                     }
                     nfound++;
                 }
-                else if (per > options->percent) {
-                    if (print_data(options)) {
+                else if (per > opts->percent) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT_P, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort), per);
@@ -1113,19 +1103,19 @@ static hsize_t diff_datum(
                 }
             }
             /* -d and -p */
-            else if (options->d && options->p) {
+            else if (opts->d && opts->p) {
                 PER_UNSIGN(signed short, temp1_ushort, temp2_ushort);
 
                 if (not_comparable && !both_zero) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT_P_NOTCOMP, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort));
                     }
                     nfound++;
                 }
-                else if (per > options->percent && PDIFF(temp1_ushort, temp2_ushort) > options->delta) {
-                    if (print_data(options)) {
+                else if (per > opts->percent && PDIFF(temp1_ushort, temp2_ushort) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT_P, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort), per);
@@ -1134,7 +1124,7 @@ static hsize_t diff_datum(
                 }
             }
             else if (temp1_ushort != temp2_ushort) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort));
@@ -1157,9 +1147,9 @@ static hsize_t diff_datum(
             HDmemcpy(&temp1_int, mem1, sizeof(int));
             HDmemcpy(&temp2_int, mem2, sizeof(int));
             /* -d and !-p */
-            if (options->d && !options->p) {
-                if (ABS(temp1_int-temp2_int) > options->delta) {
-                    if (print_data(options)) {
+            if (opts->d && !opts->p) {
+                if (ABS(temp1_int-temp2_int) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT, temp1_int, temp2_int, ABS(temp1_int - temp2_int));
@@ -1168,19 +1158,19 @@ static hsize_t diff_datum(
                 }
             }
             /* !-d and -p */
-            else if (!options->d && options->p) {
+            else if (!opts->d && opts->p) {
                 PER(temp1_int, temp2_int);
 
                 if (not_comparable && !both_zero) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT_P_NOTCOMP, temp1_int, temp2_int, ABS(temp1_int - temp2_int));
                     }
                     nfound++;
                 }
-                else if (per > options->percent) {
-                    if (print_data(options)) {
+                else if (per > opts->percent) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT_P, temp1_int, temp2_int, ABS(temp1_int - temp2_int), per);
@@ -1189,19 +1179,19 @@ static hsize_t diff_datum(
                 }
             }
             /* -d and -p */
-            else if (options->d && options->p) {
+            else if (opts->d && opts->p) {
                 PER(temp1_int, temp2_int);
 
                 if (not_comparable && !both_zero) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT_P_NOTCOMP, temp1_int, temp2_int, ABS(temp1_int - temp2_int));
                     }
                     nfound++;
                 }
-                else if (per > options->percent && ABS(temp1_int - temp2_int) > options->delta) {
-                    if (print_data(options)) {
+                else if (per > opts->percent && ABS(temp1_int - temp2_int) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(I_FORMAT_P, temp1_int, temp2_int, ABS(temp1_int - temp2_int), per);
@@ -1210,7 +1200,7 @@ static hsize_t diff_datum(
                 }
             }
             else if (temp1_int != temp2_int) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT, temp1_int, temp2_int, ABS(temp1_int - temp2_int));
@@ -1233,9 +1223,9 @@ static hsize_t diff_datum(
             HDmemcpy(&temp1_uint, mem1, sizeof(unsigned int));
             HDmemcpy(&temp2_uint, mem2, sizeof(unsigned int));
             /* -d and !-p */
-            if (options->d && !options->p) {
-                if (PDIFF(temp1_uint, temp2_uint) > options->delta) {
-                    if (print_data(options)) {
+            if (opts->d && !opts->p) {
+                if (PDIFF(temp1_uint, temp2_uint) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(UI_FORMAT, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint));
@@ -1244,19 +1234,19 @@ static hsize_t diff_datum(
                 }
             }
             /* !-d and -p */
-            else if (!options->d && options->p) {
+            else if (!opts->d && opts->p) {
                 PER_UNSIGN(signed int, temp1_uint, temp2_uint);
 
                 if (not_comparable && !both_zero) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(UI_FORMAT_P_NOTCOMP, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint));
                     }
                     nfound++;
                 }
-                else if (per > options->percent) {
-                    if (print_data(options)) {
+                else if (per > opts->percent) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(UI_FORMAT_P, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint), per);
@@ -1265,19 +1255,19 @@ static hsize_t diff_datum(
                 }
             }
             /* -d and -p */
-            else if (options->d && options->p) {
+            else if (opts->d && opts->p) {
                 PER_UNSIGN(signed int, temp1_uint, temp2_uint);
 
                 if (not_comparable && !both_zero) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(UI_FORMAT_P_NOTCOMP, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint));
                     }
                     nfound++;
                 }
-                else if (per > options->percent && PDIFF(temp1_uint,temp2_uint) > options->delta) {
-                    if (print_data(options)) {
+                else if (per > opts->percent && PDIFF(temp1_uint,temp2_uint) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(UI_FORMAT_P, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint), per);
@@ -1286,7 +1276,7 @@ static hsize_t diff_datum(
                 }
             }
             else if (temp1_uint != temp2_uint) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(UI_FORMAT, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint));
@@ -1309,9 +1299,9 @@ static hsize_t diff_datum(
             HDmemcpy(&temp1_long, mem1, sizeof(long));
             HDmemcpy(&temp2_long, mem2, sizeof(long));
             /* -d and !-p */
-            if (options->d && !options->p) {
-                if (ABS(temp1_long-temp2_long) > options->delta) {
-                    if (print_data(options)) {
+            if (opts->d && !opts->p) {
+                if (ABS(temp1_long-temp2_long) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(LI_FORMAT, temp1_long, temp2_long, ABS(temp1_long - temp2_long));
@@ -1320,19 +1310,19 @@ static hsize_t diff_datum(
                 }
             }
             /* !-d and -p */
-            else if (!options->d && options->p) {
+            else if (!opts->d && opts->p) {
                 PER(temp1_long, temp2_long);
 
                 if (not_comparable && !both_zero) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(LI_FORMAT_P_NOTCOMP, temp1_long, temp2_long, ABS(temp1_long - temp2_long));
                     }
                     nfound++;
                 }
-                else if (per > options->percent) {
-                    if (print_data(options)) {
+                else if (per > opts->percent) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(LI_FORMAT_P, temp1_long, temp2_long, ABS(temp1_long - temp2_long), per);
@@ -1341,19 +1331,19 @@ static hsize_t diff_datum(
                 }
             }
             /* -d and -p */
-            else if (options->d && options->p) {
+            else if (opts->d && opts->p) {
                 PER(temp1_long, temp2_long);
 
                 if (not_comparable && !both_zero) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(LI_FORMAT_P_NOTCOMP, temp1_long, temp2_long, ABS(temp1_long - temp2_long));
                     }
                     nfound++;
                 }
-                else if (per > options->percent && ABS(temp1_long-temp2_long) > options->delta) {
-                    if (print_data(options)) {
+                else if (per > opts->percent && ABS(temp1_long-temp2_long) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(LI_FORMAT_P, temp1_long, temp2_long, ABS(temp1_long - temp2_long), per);
@@ -1362,7 +1352,7 @@ static hsize_t diff_datum(
                 }
             }
             else if (temp1_long != temp2_long) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(LI_FORMAT, temp1_long, temp2_long, ABS(temp1_long - temp2_long));
@@ -1385,9 +1375,9 @@ static hsize_t diff_datum(
             HDmemcpy(&temp1_ulong, mem1, sizeof(unsigned long));
             HDmemcpy(&temp2_ulong, mem2, sizeof(unsigned long));
             /* -d and !-p */
-            if (options->d && !options->p) {
-                if (PDIFF(temp1_ulong, temp2_ulong) > options->delta) {
-                    if (print_data(options)) {
+            if (opts->d && !opts->p) {
+                if (PDIFF(temp1_ulong, temp2_ulong) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(ULI_FORMAT, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong));
@@ -1396,19 +1386,19 @@ static hsize_t diff_datum(
                 }
             }
             /* !-d and -p */
-            else if (!options->d && options->p) {
+            else if (!opts->d && opts->p) {
                 PER_UNSIGN(signed long, temp1_ulong, temp2_ulong);
 
                 if (not_comparable && !both_zero) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(ULI_FORMAT_P_NOTCOMP, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong));
                     }
                     nfound++;
                 }
-                else if (per > options->percent) {
-                    if (print_data(options)) {
+                else if (per > opts->percent) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(ULI_FORMAT_P, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong), per);
@@ -1417,19 +1407,19 @@ static hsize_t diff_datum(
                 }
             }
             /* -d and -p */
-            else if (options->d && options->p) {
+            else if (opts->d && opts->p) {
                 PER_UNSIGN(signed long, temp1_ulong, temp2_ulong);
 
                 if (not_comparable && !both_zero) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(ULI_FORMAT_P_NOTCOMP, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong));
                     }
                     nfound++;
                 }
-                else if (per > options->percent && PDIFF(temp1_ulong,temp2_ulong) > options->delta) {
-                    if (print_data(options)) {
+                else if (per > opts->percent && PDIFF(temp1_ulong,temp2_ulong) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(ULI_FORMAT_P, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong), per);
@@ -1438,7 +1428,7 @@ static hsize_t diff_datum(
                 }
             }
             else if (temp1_ulong != temp2_ulong) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(ULI_FORMAT, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong));
@@ -1469,26 +1459,26 @@ static hsize_t diff_datum(
             HDmemcpy(&temp1_float, mem1, sizeof(float));
             HDmemcpy(&temp2_float, mem2, sizeof(float));
 
-            /* logic for detecting NaNs is different with options -d, -p and no options */
+            /* logic for detecting NaNs is different with opts -d, -p and no opts */
 
             /*-------------------------------------------------------------------------
              * -d and !-p
              *-------------------------------------------------------------------------
              */
-            if (options->d && !options->p) {
+            if (opts->d && !opts->p) {
                 /*-------------------------------------------------------------------------
                  * detect NaNs
                  *-------------------------------------------------------------------------
                  */
-                if (options->do_nans) {
+                if (opts->do_nans) {
                     isnan1 = my_isnan(FLT_FLOAT, &temp1_float);
                     isnan2 = my_isnan(FLT_FLOAT, &temp2_float);
                 }
 
                 /* both not NaN, do the comparison */
                 if (!isnan1 && !isnan2) {
-                    if (ABS(temp1_float-temp2_float) > (float) options->delta) {
-                        if (print_data(options)) {
+                    if (ABS(temp1_float-temp2_float) > (float) opts->delta) {
+                        if (print_data(opts)) {
                             print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
                             parallel_print(F_FORMAT, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
@@ -1498,7 +1488,7 @@ static hsize_t diff_datum(
                 }
                 /* only one is NaN, assume difference */
                 else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
@@ -1510,12 +1500,12 @@ static hsize_t diff_datum(
              * !-d and -p
              *-------------------------------------------------------------------------
              */
-            else if (!options->d && options->p) {
+            else if (!opts->d && opts->p) {
                 /*-------------------------------------------------------------------------
                  * detect NaNs
                  *-------------------------------------------------------------------------
                  */
-                if (options->do_nans) {
+                if (opts->do_nans) {
                     isnan1 = my_isnan(FLT_FLOAT, &temp1_float);
                     isnan2 = my_isnan(FLT_FLOAT, &temp2_float);
                 }
@@ -1525,15 +1515,15 @@ static hsize_t diff_datum(
                     PER(temp1_float, temp2_float);
 
                     if (not_comparable && !both_zero) {
-                        if (print_data(options)) {
+                        if (print_data(opts)) {
                             print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
                             parallel_print(F_FORMAT_P_NOTCOMP, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
                         }
                         nfound++;
                     }
-                    else if (per > options->percent && (double) ABS(temp1_float - temp2_float) > options->delta) {
-                        if (print_data(options)) {
+                    else if (per > opts->percent && (double) ABS(temp1_float - temp2_float) > opts->delta) {
+                        if (print_data(opts)) {
                             print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
                             parallel_print(F_FORMAT_P, (double) temp1_float, (double) temp2_float,
@@ -1544,7 +1534,7 @@ static hsize_t diff_datum(
                 }
                 /* only one is NaN, assume difference */
                 else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
@@ -1556,12 +1546,12 @@ static hsize_t diff_datum(
              * -d and -p
              *-------------------------------------------------------------------------
              */
-            else if (options->d && options->p) {
+            else if (opts->d && opts->p) {
                 /*-------------------------------------------------------------------------
                  * detect NaNs
                  *-------------------------------------------------------------------------
                  */
-                if (options->do_nans) {
+                if (opts->do_nans) {
                     isnan1 = my_isnan(FLT_FLOAT, &temp1_float);
                     isnan2 = my_isnan(FLT_FLOAT, &temp2_float);
                 }
@@ -1571,15 +1561,15 @@ static hsize_t diff_datum(
                     PER(temp1_float, temp2_float);
 
                     if (not_comparable && !both_zero) {
-                        if (print_data(options)) {
+                        if (print_data(opts)) {
                             print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
                             parallel_print(F_FORMAT_P_NOTCOMP, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
                         }
                         nfound++;
                     }
-                    else if (per > options->percent) {
-                        if (print_data(options)) {
+                    else if (per > opts->percent) {
+                        if (print_data(opts)) {
                             print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
                             parallel_print(F_FORMAT_P, (double) temp1_float, (double) temp2_float,
@@ -1590,7 +1580,7 @@ static hsize_t diff_datum(
                 }
                 /* only one is NaN, assume difference */
                 else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
@@ -1602,8 +1592,8 @@ static hsize_t diff_datum(
              * no -d and -p
              *-------------------------------------------------------------------------
              */
-            else if (equal_float(temp1_float, temp2_float, options) == FALSE) {
-                if (print_data(options)) {
+            else if (equal_float(temp1_float, temp2_float, opts) == FALSE) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(F_FORMAT, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
@@ -1628,25 +1618,25 @@ static hsize_t diff_datum(
             HDmemcpy(&temp1_double, mem1, sizeof(double));
             HDmemcpy(&temp2_double, mem2, sizeof(double));
 
-            /* logic for detecting NaNs is different with options -d, -p and no options */
+            /* logic for detecting NaNs is different with opts -d, -p and no opts */
             /*-------------------------------------------------------------------------
              * -d and !-p
              *-------------------------------------------------------------------------
              */
-            if (options->d && !options->p) {
+            if (opts->d && !opts->p) {
                 /*-------------------------------------------------------------------------
                  * detect NaNs
                  *-------------------------------------------------------------------------
                  */
-                if (options->do_nans) {
+                if (opts->do_nans) {
                     isnan1 = my_isnan(FLT_DOUBLE, &temp1_double);
                     isnan2 = my_isnan(FLT_DOUBLE, &temp2_double);
                 }
 
                 /* both not NaN, do the comparison */
                 if (!isnan1 && !isnan2) {
-                    if (ABS(temp1_double-temp2_double) > options->delta) {
-                        if (print_data(options)) {
+                    if (ABS(temp1_double-temp2_double) > opts->delta) {
+                        if (print_data(opts)) {
                             print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
                             parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
@@ -1656,24 +1646,24 @@ static hsize_t diff_datum(
                 }
                 /* only one is NaN, assume difference */
                 else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                     }
                     nfound++;
                 }
-            } /* options->d && !options->p */
+            } /* opts->d && !opts->p */
             /*-------------------------------------------------------------------------
              * !-d and -p
              *-------------------------------------------------------------------------
              */
-            else if (!options->d && options->p) {
+            else if (!opts->d && opts->p) {
                 /*-------------------------------------------------------------------------
                  * detect NaNs
                  *-------------------------------------------------------------------------
                  */
-                if (options->do_nans) {
+                if (opts->do_nans) {
                     isnan1 = my_isnan(FLT_DOUBLE, &temp1_double);
                     isnan2 = my_isnan(FLT_DOUBLE, &temp2_double);
                 }
@@ -1683,15 +1673,15 @@ static hsize_t diff_datum(
                     PER(temp1_double, temp2_double);
 
                     if (not_comparable && !both_zero) {
-                        if (print_data(options)) {
+                        if (print_data(opts)) {
                             print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
                             parallel_print(F_FORMAT_P_NOTCOMP, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                         }
                         nfound++;
                     }
-                    else if (per > options->percent) {
-                        if (print_data(options)) {
+                    else if (per > opts->percent) {
+                        if (print_data(opts)) {
                             print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
                             parallel_print(F_FORMAT_P, temp1_double, temp2_double, ABS(temp1_double - temp2_double), ABS(1 - temp2_double / temp1_double));
@@ -1701,7 +1691,7 @@ static hsize_t diff_datum(
                 }
                 /* only one is NaN, assume difference */
                 else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
@@ -1713,12 +1703,12 @@ static hsize_t diff_datum(
              * -d and -p
              *-------------------------------------------------------------------------
              */
-            else if (options->d && options->p) {
+            else if (opts->d && opts->p) {
                 /*-------------------------------------------------------------------------
                 * detect NaNs
                 *-------------------------------------------------------------------------
                 */
-                if (options->do_nans) {
+                if (opts->do_nans) {
                     isnan1 = my_isnan(FLT_DOUBLE, &temp1_double);
                     isnan2 = my_isnan(FLT_DOUBLE, &temp2_double);
                 }
@@ -1728,16 +1718,16 @@ static hsize_t diff_datum(
                     PER(temp1_double, temp2_double);
 
                     if (not_comparable && !both_zero) {
-                        if (print_data(options)) {
+                        if (print_data(opts)) {
                             print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
                             parallel_print(F_FORMAT_P_NOTCOMP, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                         }
                         nfound++;
                     }
-                    else if (per > options->percent &&
-                    ABS(temp1_double-temp2_double) > options->delta) {
-                        if (print_data(options)) {
+                    else if (per > opts->percent &&
+                    ABS(temp1_double-temp2_double) > opts->delta) {
+                        if (print_data(opts)) {
                             print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
                             parallel_print(F_FORMAT_P, temp1_double, temp2_double, ABS(temp1_double - temp2_double), ABS(1 - temp2_double / temp1_double));
@@ -1747,7 +1737,7 @@ static hsize_t diff_datum(
                 }
                 /* only one is NaN, assume difference */
                 else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
@@ -1759,8 +1749,8 @@ static hsize_t diff_datum(
              * no -d and -p
              *-------------------------------------------------------------------------
              */
-            else if (equal_double(temp1_double, temp2_double, options) == FALSE) {
-                if (print_data(options)) {
+            else if (equal_double(temp1_double, temp2_double, opts) == FALSE) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
@@ -1793,20 +1783,20 @@ static hsize_t diff_datum(
              * -d and !-p
              *-------------------------------------------------------------------------
              */
-            if (options->d && !options->p) {
+            if (opts->d && !opts->p) {
                 /*-------------------------------------------------------------------------
                  * detect NaNs
                  *-------------------------------------------------------------------------
                  */
-                if (options->do_nans) {
+                if (opts->do_nans) {
                     isnan1 = my_isnan(FLT_LDOUBLE,&temp1_double);
                     isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
                 }
 
                 /* both not NaN, do the comparison */
                 if (!isnan1 && !isnan2) {
-                    if (ABS(temp1_double-temp2_double) > options->delta) {
-                        if (print_data(options)) {
+                    if (ABS(temp1_double-temp2_double) > opts->delta) {
+                        if (print_data(opts)) {
                             print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
                             parallel_print(LD_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
@@ -1816,7 +1806,7 @@ static hsize_t diff_datum(
                 } /* NaN */
                 /* only one is NaN, assume difference */
                 else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
@@ -1828,12 +1818,12 @@ static hsize_t diff_datum(
              * !-d and -p
              *-------------------------------------------------------------------------
              */
-            else if (!options->d && options->p) {
+            else if (!opts->d && opts->p) {
                 /*-------------------------------------------------------------------------
                  * detect NaNs
                  *-------------------------------------------------------------------------
                  */
-                if (options->do_nans) {
+                if (opts->do_nans) {
                     isnan1 = my_isnan(FLT_LDOUBLE, &temp1_double);
                     isnan2 = my_isnan(FLT_LDOUBLE, &temp2_double);
                 }
@@ -1843,15 +1833,15 @@ static hsize_t diff_datum(
                     PER(temp1_double,temp2_double);
 
                     if (not_comparable && !both_zero) {
-                        if (print_data(options)) {
+                        if (print_data(opts)) {
                             print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
                             parallel_print(LD_FORMAT_P_NOTCOMP, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                         }
                         nfound++;
                     }
-                    else if (per > options->percent) {
-                        if (print_data(options)) {
+                    else if (per > opts->percent) {
+                        if (print_data(opts)) {
                             print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
                             parallel_print(LD_FORMAT_P, temp1_double, temp2_double, ABS(temp1_double - temp2_double), ABS(1 - temp2_double / temp1_double));
@@ -1861,7 +1851,7 @@ static hsize_t diff_datum(
                 } /* NaN */
                 /* only one is NaN, assume difference */
                 else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
@@ -1873,12 +1863,12 @@ static hsize_t diff_datum(
              * -d and -p
              *-------------------------------------------------------------------------
              */
-            else if (options->d && options->p) {
+            else if (opts->d && opts->p) {
                 /*-------------------------------------------------------------------------
                  * detect NaNs
                  *-------------------------------------------------------------------------
                  */
-                if (options->do_nans) {
+                if (opts->do_nans) {
                     isnan1 = my_isnan(FLT_LDOUBLE, &temp1_double);
                     isnan2 = my_isnan(FLT_LDOUBLE, &temp2_double);
                 }
@@ -1888,15 +1878,15 @@ static hsize_t diff_datum(
                     PER(temp1_double,temp2_double);
 
                     if (not_comparable && !both_zero) {
-                        if (print_data(options)) {
+                        if (print_data(opts)) {
                             print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
                             parallel_print(LD_FORMAT_P_NOTCOMP, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                         }
                         nfound++;
                     }
-                    else if (per > options->percent && ABS(temp1_double-temp2_double) > options->delta) {
-                        if (print_data(options)) {
+                    else if (per > opts->percent && ABS(temp1_double-temp2_double) > opts->delta) {
+                        if (print_data(opts)) {
                             print_pos(ph, 1, index, acc, pos, rank, dims, obj1, obj2);
                             parallel_print(SPACES);
                             parallel_print(LD_FORMAT_P, temp1_double, temp2_double, ABS(temp1_double - temp2_double), ABS(1 - temp2_double / temp1_double));
@@ -1906,7 +1896,7 @@ static hsize_t diff_datum(
                 } /* NaN */
                 /* only one is NaN, assume difference */
                 else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
@@ -1918,8 +1908,8 @@ static hsize_t diff_datum(
              * no -d and -p
              *-------------------------------------------------------------------------
              */
-            else if (equal_ldouble(temp1_double, temp2_double, options) == FALSE) {
-                if (print_data(options)) {
+            else if (equal_ldouble(temp1_double, temp2_double, opts) == FALSE) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, index, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(LD_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
@@ -1932,9 +1922,10 @@ static hsize_t diff_datum(
         break; /* H5T_FLOAT class */
 
     } /* switch */
+    opts->err_stat = 0;
 
 done:
-    h5difftrace("diff_datum finish\n");
+    h5diffdebug2("diff_datum finish:%d\n", nfound);
 
     return nfound;
 }
@@ -2009,7 +2000,7 @@ void print_points(int i, hsize_t *ptdata, int ndims) {
  *-------------------------------------------------------------------------
  */
 
-static hsize_t diff_region(hid_t obj1_id, hid_t obj2_id, hid_t region1_id, hid_t region2_id, diff_opt_t *options)
+static hsize_t diff_region(hid_t obj1_id, hid_t obj2_id, hid_t region1_id, hid_t region2_id, diff_opt_t *opts)
 
 {
     hsize_t  ret_value = 0; /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
@@ -2041,7 +2032,7 @@ static hsize_t diff_region(hid_t obj1_id, hid_t obj2_id, hid_t region1_id, hid_t
     } H5E_END_TRY;
 
     if (nblocks1 != nblocks2 || npoints1 != npoints2 || ndims1 != ndims2) {
-        options->not_cmp = 1;
+        opts->not_cmp = 1;
         HGOTO_DONE (0);
     }
 
@@ -2083,7 +2074,7 @@ static hsize_t diff_region(hid_t obj1_id, hid_t obj2_id, hid_t region1_id, hid_t
                 }
 
                 /* print differences if found */
-                if (nfound_b && options->m_verbose) {
+                if (nfound_b && opts->m_verbose) {
                     H5O_info_t oi1, oi2;
 
                     H5Oget_info(obj1_id, &oi1);
@@ -2140,7 +2131,7 @@ static hsize_t diff_region(hid_t obj1_id, hid_t obj2_id, hid_t region1_id, hid_t
                     }
                 }
 
-                if (nfound_p && options->m_verbose) {
+                if (nfound_p && opts->m_verbose) {
                     parallel_print("Region points\n");
                     for (i = 0; i < npoints1; i++) {
                         hsize_t pt1, pt2;
@@ -2167,8 +2158,6 @@ static hsize_t diff_region(hid_t obj1_id, hid_t obj2_id, hid_t region1_id, hid_t
 
 #if defined (H5DIFF_DEBUG)
             for (i = 0; i < npoints1; i++) {
-                int j;
-
                 parallel_print("%sPt%lu: " , i ? "," : "", (unsigned long)i);
 
                 for (j = 0; j < ndims1; j++)
@@ -2201,7 +2190,7 @@ done:
  */
 
 static hsize_t character_compare(char *mem1, char *mem2, hsize_t i, size_t u,
-        int rank, hsize_t *dims, hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1, const char *obj2, int *ph)
+        int rank, hsize_t *dims, hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1, const char *obj2, int *ph)
 {
     hsize_t nfound = 0; /* differences found */
     char    temp1_uchar;
@@ -2212,7 +2201,7 @@ static hsize_t character_compare(char *mem1, char *mem2, hsize_t i, size_t u,
     h5diffdebug3("character_compare start %d=%d\n",temp1_uchar,temp2_uchar);
 
     if (temp1_uchar != temp2_uchar) {
-        if (print_data(options)) {
+        if (print_data(opts)) {
             print_char_pos(ph, 0, i, u, acc, pos, rank, dims, obj1, obj2);
             parallel_print("            ");
             h5diff_print_char(temp1_uchar);
@@ -2237,7 +2226,7 @@ static hsize_t character_compare(char *mem1, char *mem2, hsize_t i, size_t u,
  */
 
 static hsize_t character_compare_opt(unsigned char *mem1, unsigned char *mem2,
-        hsize_t i, int rank, hsize_t *dims, hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1, const char *obj2, int *ph)
+        hsize_t i, int rank, hsize_t *dims, hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1, const char *obj2, int *ph)
 {
     hsize_t       nfound = 0; /* differences found */
     unsigned char temp1_uchar;
@@ -2251,9 +2240,9 @@ static hsize_t character_compare_opt(unsigned char *mem1, unsigned char *mem2,
     h5difftrace("character_compare_opt start\n");
     /* -d and !-p */
 
-    if (options->d && !options->p) {
-        if (PDIFF(temp1_uchar,temp2_uchar) > options->delta) {
-            if (print_data(options)) {
+    if (opts->d && !opts->p) {
+        if (PDIFF(temp1_uchar,temp2_uchar) > opts->delta) {
+            if (print_data(opts)) {
                 print_pos(ph, 0, i, acc, pos, rank, dims, obj1, obj2);
                 parallel_print(SPACES);
                 parallel_print(I_FORMAT, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar));
@@ -2262,10 +2251,10 @@ static hsize_t character_compare_opt(unsigned char *mem1, unsigned char *mem2,
         }
     }
     /* !-d and -p */
-    else if (!options->d && options->p) {
+    else if (!opts->d && opts->p) {
         PER_UNSIGN(signed char, temp1_uchar, temp2_uchar);
-        if (per > options->percent) {
-            if (print_data(options)) {
+        if (per > opts->percent) {
+            if (print_data(opts)) {
                 print_pos(ph, 1, i, acc, pos, rank, dims, obj1, obj2);
                 parallel_print(SPACES);
                 parallel_print(I_FORMAT_P, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar), per);
@@ -2274,10 +2263,10 @@ static hsize_t character_compare_opt(unsigned char *mem1, unsigned char *mem2,
         }
     }
     /* -d and -p */
-    else if (options->d && options->p) {
+    else if (opts->d && opts->p) {
         PER_UNSIGN(signed char, temp1_uchar, temp2_uchar);
-        if (per > options->percent && PDIFF(temp1_uchar,temp2_uchar) > options->delta) {
-            if (print_data(options)) {
+        if (per > opts->percent && PDIFF(temp1_uchar,temp2_uchar) > opts->delta) {
+            if (print_data(opts)) {
                 print_pos(ph, 1, i, acc, pos, rank, dims, obj1, obj2);
                 parallel_print(SPACES);
                 parallel_print(I_FORMAT_P, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar), per);
@@ -2286,7 +2275,7 @@ static hsize_t character_compare_opt(unsigned char *mem1, unsigned char *mem2,
         }
     }
     else if (temp1_uchar != temp2_uchar) {
-        if (print_data(options)) {
+        if (print_data(opts)) {
             print_pos(ph, 0, i, acc, pos, rank, dims, obj1, obj2);
             parallel_print(SPACES);
             parallel_print(I_FORMAT, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar));
@@ -2307,7 +2296,7 @@ static hsize_t character_compare_opt(unsigned char *mem1, unsigned char *mem2,
  *-------------------------------------------------------------------------
  */
 static hsize_t diff_float(unsigned char *mem1, unsigned char *mem2,
-        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims, hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims, hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1,
         const char *obj2, int *ph)
 
 {
@@ -2327,7 +2316,7 @@ static hsize_t diff_float(unsigned char *mem1, unsigned char *mem2,
      *-------------------------------------------------------------------------
      */
 
-    if (options->d && !options->p) {
+    if (opts->d && !opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_float, mem1, sizeof(float));
             HDmemcpy(&temp2_float, mem2, sizeof(float));
@@ -2336,15 +2325,15 @@ static hsize_t diff_float(unsigned char *mem1, unsigned char *mem2,
              * detect NaNs
              *-------------------------------------------------------------------------
              */
-            if (options->do_nans) {
+            if (opts->do_nans) {
                 isnan1 = my_isnan(FLT_FLOAT, &temp1_float);
                 isnan2 = my_isnan(FLT_FLOAT, &temp2_float);
             }
 
             /* both not NaN, do the comparison */
             if (!isnan1 && !isnan2) {
-                if ((double) ABS(temp1_float - temp2_float) > options->delta) {
-                    if (print_data(options)) {
+                if ((double) ABS(temp1_float - temp2_float) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
@@ -2354,7 +2343,7 @@ static hsize_t diff_float(unsigned char *mem1, unsigned char *mem2,
             }
             /* only one is NaN, assume difference */
             else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(F_FORMAT, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
@@ -2364,7 +2353,7 @@ static hsize_t diff_float(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(float);
             mem2 += sizeof(float);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         } /* i */
     }
@@ -2372,7 +2361,7 @@ static hsize_t diff_float(unsigned char *mem1, unsigned char *mem2,
      * !-d and -p
      *-------------------------------------------------------------------------
      */
-    else if (!options->d && options->p) {
+    else if (!opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_float, mem1, sizeof(float));
             HDmemcpy(&temp2_float, mem2, sizeof(float));
@@ -2381,7 +2370,7 @@ static hsize_t diff_float(unsigned char *mem1, unsigned char *mem2,
              * detect NaNs
              *-------------------------------------------------------------------------
              */
-            if (options->do_nans) {
+            if (opts->do_nans) {
                 isnan1 = my_isnan(FLT_FLOAT, &temp1_float);
                 isnan2 = my_isnan(FLT_FLOAT, &temp2_float);
             }
@@ -2390,15 +2379,15 @@ static hsize_t diff_float(unsigned char *mem1, unsigned char *mem2,
                 PER(temp1_float, temp2_float);
 
                 if (not_comparable && !both_zero) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT_P_NOTCOMP, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
                     }
                     nfound++;
                 }
-                else if (per > options->percent) {
-                    if (print_data(options)) {
+                else if (per > opts->percent) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT_P, (double) temp1_float, (double) temp2_float,
@@ -2409,7 +2398,7 @@ static hsize_t diff_float(unsigned char *mem1, unsigned char *mem2,
             }
             /* only one is NaN, assume difference */
             else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(F_FORMAT, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
@@ -2419,7 +2408,7 @@ static hsize_t diff_float(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(float);
             mem2 += sizeof(float);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         } /* i */
     }
@@ -2427,7 +2416,7 @@ static hsize_t diff_float(unsigned char *mem1, unsigned char *mem2,
      * -d and -p
      *-------------------------------------------------------------------------
      */
-    else if (options->d && options->p) {
+    else if (opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_float, mem1, sizeof(float));
             HDmemcpy(&temp2_float, mem2, sizeof(float));
@@ -2436,7 +2425,7 @@ static hsize_t diff_float(unsigned char *mem1, unsigned char *mem2,
              * detect NaNs
              *-------------------------------------------------------------------------
              */
-            if (options->do_nans) {
+            if (opts->do_nans) {
                 isnan1 = my_isnan(FLT_FLOAT, &temp1_float);
                 isnan2 = my_isnan(FLT_FLOAT, &temp2_float);
             }
@@ -2446,15 +2435,15 @@ static hsize_t diff_float(unsigned char *mem1, unsigned char *mem2,
                 PER(temp1_float, temp2_float);
 
                 if (not_comparable && !both_zero) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT_P_NOTCOMP, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
                     }
                     nfound++;
                 }
-                else if (per > options->percent && (double) ABS(temp1_float - temp2_float) > options->delta) {
-                    if (print_data(options)) {
+                else if (per > opts->percent && (double) ABS(temp1_float - temp2_float) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT_P, (double) temp1_float, (double) temp2_float,
@@ -2466,7 +2455,7 @@ static hsize_t diff_float(unsigned char *mem1, unsigned char *mem2,
             }
             /* only one is NaN, assume difference */
             else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(F_FORMAT, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
@@ -2476,7 +2465,7 @@ static hsize_t diff_float(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(float);
             mem2 += sizeof(float);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         } /* i */
     }
@@ -2490,8 +2479,8 @@ static hsize_t diff_float(unsigned char *mem1, unsigned char *mem2,
             HDmemcpy(&temp1_float, mem1, sizeof(float));
             HDmemcpy(&temp2_float, mem2, sizeof(float));
 
-            if (equal_float(temp1_float, temp2_float, options) == FALSE) {
-                if (print_data(options)) {
+            if (equal_float(temp1_float, temp2_float, opts) == FALSE) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(F_FORMAT, (double) temp1_float, (double) temp2_float, (double) ABS(temp1_float - temp2_float));
@@ -2501,7 +2490,7 @@ static hsize_t diff_float(unsigned char *mem1, unsigned char *mem2,
 
             mem1 += sizeof(float);
             mem2 += sizeof(float);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         } /* nelmts */
     }
@@ -2520,7 +2509,7 @@ static hsize_t diff_float(unsigned char *mem1, unsigned char *mem2,
  */
 static hsize_t diff_double(unsigned char *mem1, unsigned char *mem2,
         hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
-        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1,
         const char *obj2, int *ph)
 
 {
@@ -2539,7 +2528,7 @@ static hsize_t diff_double(unsigned char *mem1, unsigned char *mem2,
      *-------------------------------------------------------------------------
      */
 
-    if (options->d && !options->p) {
+    if (opts->d && !opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_double, mem1, sizeof(double));
             HDmemcpy(&temp2_double, mem2, sizeof(double));
@@ -2548,15 +2537,15 @@ static hsize_t diff_double(unsigned char *mem1, unsigned char *mem2,
              * detect NaNs
              *-------------------------------------------------------------------------
              */
-            if (options->do_nans) {
+            if (opts->do_nans) {
                 isnan1 = my_isnan(FLT_DOUBLE, &temp1_double);
                 isnan2 = my_isnan(FLT_DOUBLE, &temp2_double);
             }
 
             /* both not NaN, do the comparison */
             if (!isnan1 && !isnan2) {
-                if (ABS(temp1_double-temp2_double) > options->delta) {
-                    if (print_data(options)) {
+                if (ABS(temp1_double-temp2_double) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
@@ -2566,7 +2555,7 @@ static hsize_t diff_double(unsigned char *mem1, unsigned char *mem2,
             }
             /* only one is NaN, assume difference */
             else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
@@ -2576,7 +2565,7 @@ static hsize_t diff_double(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(double);
             mem2 += sizeof(double);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         } /* i */
     }
@@ -2585,7 +2574,7 @@ static hsize_t diff_double(unsigned char *mem1, unsigned char *mem2,
      * !-d and -p
      *-------------------------------------------------------------------------
      */
-    else if (!options->d && options->p) {
+    else if (!opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_double, mem1, sizeof(double));
             HDmemcpy(&temp2_double, mem2, sizeof(double));
@@ -2594,7 +2583,7 @@ static hsize_t diff_double(unsigned char *mem1, unsigned char *mem2,
              * detect NaNs
              *-------------------------------------------------------------------------
              */
-            if (options->do_nans) {
+            if (opts->do_nans) {
                 isnan1 = my_isnan(FLT_DOUBLE, &temp1_double);
                 isnan2 = my_isnan(FLT_DOUBLE, &temp2_double);
             }
@@ -2603,15 +2592,15 @@ static hsize_t diff_double(unsigned char *mem1, unsigned char *mem2,
                 PER(temp1_double, temp2_double);
 
                 if (not_comparable && !both_zero) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT_P_NOTCOMP, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                     }
                     nfound++;
                 }
-                else if (per > options->percent) {
-                    if (print_data(options)) {
+                else if (per > opts->percent) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT_P, temp1_double, temp2_double,
@@ -2622,7 +2611,7 @@ static hsize_t diff_double(unsigned char *mem1, unsigned char *mem2,
             }
             /* only one is NaN, assume difference */
             else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
@@ -2632,7 +2621,7 @@ static hsize_t diff_double(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(double);
             mem2 += sizeof(double);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         } /* i */
     }
@@ -2640,7 +2629,7 @@ static hsize_t diff_double(unsigned char *mem1, unsigned char *mem2,
      * -d and -p
      *-------------------------------------------------------------------------
      */
-    else if (options->d && options->p) {
+    else if (opts->d && opts->p) {
 
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_double, mem1, sizeof(double));
@@ -2650,7 +2639,7 @@ static hsize_t diff_double(unsigned char *mem1, unsigned char *mem2,
              * detect NaNs
              *-------------------------------------------------------------------------
              */
-            if (options->do_nans) {
+            if (opts->do_nans) {
                 isnan1 = my_isnan(FLT_DOUBLE, &temp1_double);
                 isnan2 = my_isnan(FLT_DOUBLE, &temp2_double);
             }
@@ -2660,15 +2649,15 @@ static hsize_t diff_double(unsigned char *mem1, unsigned char *mem2,
                 PER(temp1_double, temp2_double);
 
                 if (not_comparable && !both_zero)  {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT_P_NOTCOMP, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                     }
                     nfound++;
                 }
-                else if (per > options->percent && ABS(temp1_double-temp2_double) > options->delta) {
-                    if (print_data(options)) {
+                else if (per > opts->percent && ABS(temp1_double-temp2_double) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT_P, temp1_double, temp2_double,
@@ -2679,7 +2668,7 @@ static hsize_t diff_double(unsigned char *mem1, unsigned char *mem2,
             }
             /* only one is NaN, assume difference */
             else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
@@ -2688,7 +2677,7 @@ static hsize_t diff_double(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(double);
             mem2 += sizeof(double);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         } /* i */
     }
@@ -2701,8 +2690,8 @@ static hsize_t diff_double(unsigned char *mem1, unsigned char *mem2,
             HDmemcpy(&temp1_double, mem1, sizeof(double));
             HDmemcpy(&temp2_double, mem2, sizeof(double));
 
-            if (equal_double(temp1_double, temp2_double, options) == FALSE) {
-                if (print_data(options)) {
+            if (equal_double(temp1_double, temp2_double, opts) == FALSE) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
@@ -2712,7 +2701,7 @@ static hsize_t diff_double(unsigned char *mem1, unsigned char *mem2,
 
             mem1 += sizeof(double);
             mem2 += sizeof(double);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         } /* nelmts */
     }
@@ -2739,7 +2728,7 @@ static hsize_t diff_ldouble(unsigned char *mem1,
         hsize_t *dims,
         hsize_t *acc,
         hsize_t *pos,
-        diff_opt_t *options,
+        diff_opt_t *opts,
         const char *obj1,
         const char *obj2,
         int *ph)
@@ -2761,7 +2750,7 @@ static hsize_t diff_ldouble(unsigned char *mem1,
      *-------------------------------------------------------------------------
      */
 
-    if (options->d && !options->p) {
+    if (opts->d && !opts->p) {
         for ( i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_double, mem1, sizeof(long double));
             HDmemcpy(&temp2_double, mem2, sizeof(long double));
@@ -2770,15 +2759,15 @@ static hsize_t diff_ldouble(unsigned char *mem1,
              * detect NaNs
              *-------------------------------------------------------------------------
              */
-            if (options->do_nans) {
+            if (opts->do_nans) {
                 isnan1 = my_isnan(FLT_LDOUBLE,&temp1_double);
                 isnan2 = my_isnan(FLT_LDOUBLE,&temp2_double);
             }
 
             /* both not NaN, do the comparison */
             if (!isnan1 && !isnan2) {
-                if (ABS(temp1_double-temp2_double) > options->delta) {
-                    if (print_data(options)) {
+                if (ABS(temp1_double-temp2_double) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
@@ -2788,7 +2777,7 @@ static hsize_t diff_ldouble(unsigned char *mem1,
             }
             /* only one is NaN, assume difference */
             else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
@@ -2798,7 +2787,7 @@ static hsize_t diff_ldouble(unsigned char *mem1,
             }
             mem1 += sizeof(long double);
             mem2 += sizeof(long double);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         } /* i */
     }
@@ -2807,7 +2796,7 @@ static hsize_t diff_ldouble(unsigned char *mem1,
      * !-d and -p
      *-------------------------------------------------------------------------
      */
-    else if (!options->d && options->p) {
+    else if (!opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_double, mem1, sizeof(long double));
             HDmemcpy(&temp2_double, mem2, sizeof(long double));
@@ -2816,7 +2805,7 @@ static hsize_t diff_ldouble(unsigned char *mem1,
              * detect NaNs
              *-------------------------------------------------------------------------
              */
-            if (options->do_nans) {
+            if (opts->do_nans) {
                 isnan1 = my_isnan(FLT_LDOUBLE, &temp1_double);
                 isnan2 = my_isnan(FLT_LDOUBLE, &temp2_double);
             }
@@ -2825,15 +2814,15 @@ static hsize_t diff_ldouble(unsigned char *mem1,
                 PER(temp1_double, temp2_double);
 
                 if (not_comparable && !both_zero) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT_P_NOTCOMP, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                     }
                     nfound++;
                 }
-                else if (per > options->percent) {
-                    if (print_data(options)) {
+                else if (per > opts->percent) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT_P, temp1_double, temp2_double,
@@ -2844,7 +2833,7 @@ static hsize_t diff_ldouble(unsigned char *mem1,
             }
             /* only one is NaN, assume difference */
             else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start+i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
@@ -2853,7 +2842,7 @@ static hsize_t diff_ldouble(unsigned char *mem1,
             }
             mem1 += sizeof(long double);
             mem2 += sizeof(long double);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         } /* i */
     }
@@ -2861,7 +2850,7 @@ static hsize_t diff_ldouble(unsigned char *mem1,
      * -d and -p
      *-------------------------------------------------------------------------
      */
-    else if (options->d && options->p) {
+    else if (opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_double, mem1, sizeof(long double));
             HDmemcpy(&temp2_double, mem2, sizeof(long double));
@@ -2870,7 +2859,7 @@ static hsize_t diff_ldouble(unsigned char *mem1,
              * detect NaNs
              *-------------------------------------------------------------------------
              */
-            if (options->do_nans) {
+            if (opts->do_nans) {
                 isnan1 = my_isnan(FLT_LDOUBLE, &temp1_double);
                 isnan2 = my_isnan(FLT_LDOUBLE, &temp2_double);
             }
@@ -2880,15 +2869,15 @@ static hsize_t diff_ldouble(unsigned char *mem1,
                 PER(temp1_double, temp2_double);
 
                 if (not_comparable && !both_zero) {
-                    if (print_data(options)) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT_P_NOTCOMP, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
                     }
                     nfound++;
                 }
-                else if (per > options->percent && ABS(temp1_double - temp2_double) > options->delta) {
-                    if (print_data(options)) {
+                else if (per > opts->percent && ABS(temp1_double - temp2_double) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(F_FORMAT_P, temp1_double, temp2_double, ABS(temp1_double - temp2_double), ABS(1-temp2_double / temp1_double));
@@ -2898,7 +2887,7 @@ static hsize_t diff_ldouble(unsigned char *mem1,
             }
             /* only one is NaN, assume difference */
             else if ((isnan1 && !isnan2) || (!isnan1 && isnan2)) {
-                if (print_data(options))  {
+                if (print_data(opts))  {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
@@ -2907,7 +2896,7 @@ static hsize_t diff_ldouble(unsigned char *mem1,
             }
             mem1 += sizeof(long double);
             mem2 += sizeof(long double);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         } /* i */
     }
@@ -2920,8 +2909,8 @@ static hsize_t diff_ldouble(unsigned char *mem1,
             HDmemcpy(&temp1_double, mem1, sizeof(long double));
             HDmemcpy(&temp2_double, mem2, sizeof(long double));
 
-            if (equal_ldouble(temp1_double, temp2_double, options) == FALSE) {
-                if (print_data(options)) {
+            if (equal_ldouble(temp1_double, temp2_double, opts) == FALSE) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(F_FORMAT, temp1_double, temp2_double, ABS(temp1_double - temp2_double));
@@ -2930,7 +2919,7 @@ static hsize_t diff_ldouble(unsigned char *mem1,
             }
             mem1 += sizeof(long double);
             mem2 += sizeof(long double);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         } /* nelmts */
     }
@@ -2950,7 +2939,7 @@ static hsize_t diff_ldouble(unsigned char *mem1,
  */
 static hsize_t diff_schar(unsigned char *mem1, unsigned char *mem2,
         hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
-        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1,
         const char *obj2, int *ph)
 
 {
@@ -2963,13 +2952,13 @@ static hsize_t diff_schar(unsigned char *mem1, unsigned char *mem2,
 
     h5difftrace("diff_schar start\n");
     /* -d and !-p */
-    if (options->d && !options->p) {
+    if (opts->d && !opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_char, mem1, sizeof(char));
             HDmemcpy(&temp2_char, mem2, sizeof(char));
 
-            if (ABS(temp1_char-temp2_char) > options->delta) {
-                if (print_data(options)) {
+            if (ABS(temp1_char-temp2_char) > opts->delta) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT, temp1_char, temp2_char, ABS(temp1_char - temp2_char));
@@ -2978,12 +2967,12 @@ static hsize_t diff_schar(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(char);
             mem2 += sizeof(char);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
     /* !-d and -p */
-    else if (!options->d && options->p) {
+    else if (!opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_char, mem1, sizeof(char));
             HDmemcpy(&temp2_char, mem2, sizeof(char));
@@ -2991,15 +2980,15 @@ static hsize_t diff_schar(unsigned char *mem1, unsigned char *mem2,
             PER(temp1_char, temp2_char);
 
             if (not_comparable && !both_zero) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P_NOTCOMP, temp1_char, temp2_char, ABS(temp1_char - temp2_char));
                 }
                 nfound++;
             }
-            else if (per > options->percent) {
-                if (print_data(options)) {
+            else if (per > opts->percent) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P, temp1_char, temp2_char, ABS(temp1_char - temp2_char), per);
@@ -3008,12 +2997,12 @@ static hsize_t diff_schar(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(char);
             mem2 += sizeof(char);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
     /* -d and -p */
-    else if (options->d && options->p) {
+    else if (opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_char, mem1, sizeof(char));
             HDmemcpy(&temp2_char, mem2, sizeof(char));
@@ -3021,15 +3010,15 @@ static hsize_t diff_schar(unsigned char *mem1, unsigned char *mem2,
             PER(temp1_char, temp2_char);
 
             if (not_comparable && !both_zero) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P_NOTCOMP, temp1_char, temp2_char, ABS(temp1_char - temp2_char));
                 }
                 nfound++;
             }
-            else if (per > options->percent && ABS(temp1_char-temp2_char) > options->delta) {
-                if (print_data(options)) {
+            else if (per > opts->percent && ABS(temp1_char-temp2_char) > opts->delta) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P, temp1_char, temp2_char, ABS(temp1_char - temp2_char), per);
@@ -3038,7 +3027,7 @@ static hsize_t diff_schar(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(char);
             mem2 += sizeof(char);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
@@ -3048,7 +3037,7 @@ static hsize_t diff_schar(unsigned char *mem1, unsigned char *mem2,
             HDmemcpy(&temp2_char, mem2, sizeof(char));
 
             if (temp1_char != temp2_char) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT, temp1_char, temp2_char, ABS(temp1_char - temp2_char));
@@ -3058,7 +3047,7 @@ static hsize_t diff_schar(unsigned char *mem1, unsigned char *mem2,
 
             mem1 += sizeof(char);
             mem2 += sizeof(char);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         } /* nelmts */
     }
@@ -3077,7 +3066,7 @@ static hsize_t diff_schar(unsigned char *mem1, unsigned char *mem2,
  */
 static hsize_t diff_uchar(unsigned char *mem1, unsigned char *mem2,
         hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
-        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1,
         const char *obj2, int *ph)
 {
     hsize_t       nfound = 0; /* number of differences found */
@@ -3089,13 +3078,13 @@ static hsize_t diff_uchar(unsigned char *mem1, unsigned char *mem2,
 
     h5difftrace("diff_uchar start\n");
     /* -d and !-p */
-    if (options->d && !options->p) {
+    if (opts->d && !opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_uchar, mem1, sizeof(unsigned char));
             HDmemcpy(&temp2_uchar, mem2, sizeof(unsigned char));
 
-            if (PDIFF(temp1_uchar,temp2_uchar) > options->delta) {
-                if (print_data(options)) {
+            if (PDIFF(temp1_uchar,temp2_uchar) > opts->delta) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar));
@@ -3104,12 +3093,12 @@ static hsize_t diff_uchar(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(unsigned char);
             mem2 += sizeof(unsigned char);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
     /* !-d and -p */
-    else if (!options->d && options->p) {
+    else if (!opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_uchar, mem1, sizeof(unsigned char));
             HDmemcpy(&temp2_uchar, mem2, sizeof(unsigned char));
@@ -3117,15 +3106,15 @@ static hsize_t diff_uchar(unsigned char *mem1, unsigned char *mem2,
             PER_UNSIGN(signed char, temp1_uchar, temp2_uchar);
 
             if (not_comparable && !both_zero) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P_NOTCOMP, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar));
                 }
                 nfound++;
             }
-            else if (per > options->percent) {
-                if (print_data(options)) {
+            else if (per > opts->percent) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar), per);
@@ -3134,12 +3123,12 @@ static hsize_t diff_uchar(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(unsigned char);
             mem2 += sizeof(unsigned char);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
     /* -d and -p */
-    else if (options->d && options->p) {
+    else if (opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_uchar, mem1, sizeof(unsigned char));
             HDmemcpy(&temp2_uchar, mem2, sizeof(unsigned char));
@@ -3147,15 +3136,15 @@ static hsize_t diff_uchar(unsigned char *mem1, unsigned char *mem2,
             PER_UNSIGN(signed char, temp1_uchar, temp2_uchar);
 
             if (not_comparable && !both_zero) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P_NOTCOMP, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar));
                 }
                 nfound++;
             }
-            else if (per > options->percent && PDIFF(temp1_uchar,temp2_uchar) > options->delta) {
-                if (print_data(options)) {
+            else if (per > opts->percent && PDIFF(temp1_uchar,temp2_uchar) > opts->delta) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar), per);
@@ -3164,7 +3153,7 @@ static hsize_t diff_uchar(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(unsigned char);
             mem2 += sizeof(unsigned char);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
@@ -3174,7 +3163,7 @@ static hsize_t diff_uchar(unsigned char *mem1, unsigned char *mem2,
             HDmemcpy(&temp2_uchar, mem2, sizeof(unsigned char));
 
             if (temp1_uchar != temp2_uchar) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT, temp1_uchar, temp2_uchar, PDIFF(temp1_uchar, temp2_uchar));
@@ -3184,7 +3173,7 @@ static hsize_t diff_uchar(unsigned char *mem1, unsigned char *mem2,
 
             mem1 += sizeof(unsigned char);
             mem2 += sizeof(unsigned char);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         } /* nelmts */
     }
@@ -3203,7 +3192,7 @@ static hsize_t diff_uchar(unsigned char *mem1, unsigned char *mem2,
  */
 static hsize_t diff_short(unsigned char *mem1, unsigned char *mem2,
         hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
-        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1,
         const char *obj2, int *ph)
 {
     hsize_t nfound = 0; /* number of differences found */
@@ -3215,13 +3204,13 @@ static hsize_t diff_short(unsigned char *mem1, unsigned char *mem2,
 
     h5difftrace("diff_short start\n");
     /* -d and !-p */
-    if (options->d && !options->p) {
+    if (opts->d && !opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_short, mem1, sizeof(short));
             HDmemcpy(&temp2_short, mem2, sizeof(short));
 
-            if (ABS(temp1_short-temp2_short) > options->delta) {
-                if (print_data(options)) {
+            if (ABS(temp1_short-temp2_short) > opts->delta) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT, temp1_short, temp2_short, ABS(temp1_short - temp2_short));
@@ -3230,12 +3219,12 @@ static hsize_t diff_short(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(short);
             mem2 += sizeof(short);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
     /* !-d and -p */
-    else if (!options->d && options->p) {
+    else if (!opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_short, mem1, sizeof(short));
             HDmemcpy(&temp2_short, mem2, sizeof(short));
@@ -3243,15 +3232,15 @@ static hsize_t diff_short(unsigned char *mem1, unsigned char *mem2,
             PER(temp1_short, temp2_short);
 
             if (not_comparable && !both_zero) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P_NOTCOMP, temp1_short, temp2_short, ABS(temp1_short - temp2_short));
                 }
                 nfound++;
             }
-            else if (per > options->percent) {
-                if (print_data(options)) {
+            else if (per > opts->percent) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P, temp1_short, temp2_short, ABS(temp1_short - temp2_short), per);
@@ -3260,12 +3249,12 @@ static hsize_t diff_short(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(short);
             mem2 += sizeof(short);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
     /* -d and -p */
-    else if (options->d && options->p) {
+    else if (opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_short, mem1, sizeof(short));
             HDmemcpy(&temp2_short, mem2, sizeof(short));
@@ -3273,15 +3262,15 @@ static hsize_t diff_short(unsigned char *mem1, unsigned char *mem2,
             PER(temp1_short, temp2_short);
 
             if (not_comparable && !both_zero) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P_NOTCOMP, temp1_short, temp2_short, ABS(temp1_short - temp2_short));
                 }
                 nfound++;
             }
-            else if (per > options->percent && ABS(temp1_short-temp2_short) > options->delta) {
-                if (print_data(options)) {
+            else if (per > opts->percent && ABS(temp1_short-temp2_short) > opts->delta) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P, temp1_short, temp2_short, ABS(temp1_short - temp2_short), per);
@@ -3290,7 +3279,7 @@ static hsize_t diff_short(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(short);
             mem2 += sizeof(short);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
@@ -3300,7 +3289,7 @@ static hsize_t diff_short(unsigned char *mem1, unsigned char *mem2,
             HDmemcpy(&temp2_short, mem2, sizeof(short));
 
             if (temp1_short != temp2_short) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT, temp1_short, temp2_short, ABS(temp1_short - temp2_short));
@@ -3310,7 +3299,7 @@ static hsize_t diff_short(unsigned char *mem1, unsigned char *mem2,
 
             mem1 += sizeof(short);
             mem2 += sizeof(short);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         } /* nelmts */
     }
@@ -3329,7 +3318,7 @@ static hsize_t diff_short(unsigned char *mem1, unsigned char *mem2,
  */
 static hsize_t diff_ushort(unsigned char *mem1, unsigned char *mem2,
         hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
-        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1,
         const char *obj2, int *ph)
 
 {
@@ -3342,13 +3331,13 @@ static hsize_t diff_ushort(unsigned char *mem1, unsigned char *mem2,
 
     h5difftrace("diff_ushort start\n");
     /* -d and !-p */
-    if (options->d && !options->p) {
+    if (opts->d && !opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_ushort, mem1, sizeof(unsigned short));
             HDmemcpy(&temp2_ushort, mem2, sizeof(unsigned short));
 
-            if (PDIFF(temp1_ushort,temp2_ushort) > options->delta) {
-                if (print_data(options)) {
+            if (PDIFF(temp1_ushort,temp2_ushort) > opts->delta) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort));
@@ -3357,12 +3346,12 @@ static hsize_t diff_ushort(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(unsigned short);
             mem2 += sizeof(unsigned short);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
     /* !-d and -p */
-    else if (!options->d && options->p) {
+    else if (!opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_ushort, mem1, sizeof(unsigned short));
             HDmemcpy(&temp2_ushort, mem2, sizeof(unsigned short));
@@ -3370,15 +3359,15 @@ static hsize_t diff_ushort(unsigned char *mem1, unsigned char *mem2,
             PER_UNSIGN(signed short, temp1_ushort, temp2_ushort);
 
             if (not_comparable && !both_zero)  {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P_NOTCOMP, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort));
                 }
                 nfound++;
             }
-            else if (per > options->percent) {
-                if (print_data(options)) {
+            else if (per > opts->percent) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort), per);
@@ -3387,12 +3376,12 @@ static hsize_t diff_ushort(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(unsigned short);
             mem2 += sizeof(unsigned short);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
     /* -d and -p */
-    else if (options->d && options->p) {
+    else if (opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_ushort, mem1, sizeof(unsigned short));
             HDmemcpy(&temp2_ushort, mem2, sizeof(unsigned short));
@@ -3400,15 +3389,15 @@ static hsize_t diff_ushort(unsigned char *mem1, unsigned char *mem2,
             PER_UNSIGN(signed short, temp1_ushort, temp2_ushort);
 
             if (not_comparable && !both_zero) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P_NOTCOMP, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort));
                 }
                 nfound++;
             }
-            else if (per > options->percent && PDIFF(temp1_ushort,temp2_ushort) > options->delta) {
-                if (print_data(options)) {
+            else if (per > opts->percent && PDIFF(temp1_ushort,temp2_ushort) > opts->delta) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort), per);
@@ -3417,7 +3406,7 @@ static hsize_t diff_ushort(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(unsigned short);
             mem2 += sizeof(unsigned short);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
@@ -3427,7 +3416,7 @@ static hsize_t diff_ushort(unsigned char *mem1, unsigned char *mem2,
             HDmemcpy(&temp2_ushort, mem2, sizeof(unsigned short));
 
             if (temp1_ushort != temp2_ushort) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT, temp1_ushort, temp2_ushort, PDIFF(temp1_ushort, temp2_ushort));
@@ -3437,7 +3426,7 @@ static hsize_t diff_ushort(unsigned char *mem1, unsigned char *mem2,
 
             mem1 += sizeof(unsigned short);
             mem2 += sizeof(unsigned short);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         } /* nelmts */
     }
@@ -3456,7 +3445,7 @@ static hsize_t diff_ushort(unsigned char *mem1, unsigned char *mem2,
  */
 static hsize_t diff_int(unsigned char *mem1, unsigned char *mem2,
         hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
-        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1,
         const char *obj2, int *ph)
 {
     hsize_t nfound = 0; /* number of differences found */
@@ -3468,13 +3457,13 @@ static hsize_t diff_int(unsigned char *mem1, unsigned char *mem2,
 
     h5difftrace("diff_int start\n");
     /* -d and !-p */
-    if (options->d && !options->p) {
+    if (opts->d && !opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_int, mem1, sizeof(int));
             HDmemcpy(&temp2_int, mem2, sizeof(int));
 
-            if (ABS(temp1_int-temp2_int) > options->delta) {
-                if (print_data(options)) {
+            if (ABS(temp1_int-temp2_int) > opts->delta) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT, temp1_int, temp2_int, ABS(temp1_int - temp2_int));
@@ -3483,12 +3472,12 @@ static hsize_t diff_int(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(int);
             mem2 += sizeof(int);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
     /* !-d and -p */
-    else if (!options->d && options->p) {
+    else if (!opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_int, mem1, sizeof(int));
             HDmemcpy(&temp2_int, mem2, sizeof(int));
@@ -3496,15 +3485,15 @@ static hsize_t diff_int(unsigned char *mem1, unsigned char *mem2,
             PER(temp1_int, temp2_int);
 
             if (not_comparable && !both_zero) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P_NOTCOMP, temp1_int, temp2_int, ABS(temp1_int - temp2_int));
                 }
                 nfound++;
             }
-            else if (per > options->percent) {
-                if (print_data(options)) {
+            else if (per > opts->percent) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P, temp1_int, temp2_int, ABS(temp1_int - temp2_int), per);
@@ -3513,12 +3502,12 @@ static hsize_t diff_int(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(int);
             mem2 += sizeof(int);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
     /* -d and -p */
-    else if (options->d && options->p) {
+    else if (opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_int, mem1, sizeof(int));
             HDmemcpy(&temp2_int, mem2, sizeof(int));
@@ -3526,15 +3515,15 @@ static hsize_t diff_int(unsigned char *mem1, unsigned char *mem2,
             PER(temp1_int, temp2_int);
 
             if (not_comparable && !both_zero) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P_NOTCOMP, temp1_int, temp2_int, ABS(temp1_int - temp2_int));
                 }
                 nfound++;
             }
-            else if (per > options->percent && ABS(temp1_int-temp2_int) > options->delta) {
-                if (print_data(options)) {
+            else if (per > opts->percent && ABS(temp1_int-temp2_int) > opts->delta) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P, temp1_int, temp2_int, ABS(temp1_int - temp2_int), per);
@@ -3543,7 +3532,7 @@ static hsize_t diff_int(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(int);
             mem2 += sizeof(int);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
@@ -3553,7 +3542,7 @@ static hsize_t diff_int(unsigned char *mem1, unsigned char *mem2,
             HDmemcpy(&temp2_int, mem2, sizeof(int));
 
             if (temp1_int != temp2_int) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT, temp1_int, temp2_int, ABS(temp1_int - temp2_int));
@@ -3563,7 +3552,7 @@ static hsize_t diff_int(unsigned char *mem1, unsigned char *mem2,
 
             mem1 += sizeof(int);
             mem2 += sizeof(int);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         } /* nelmts */
 
@@ -3582,7 +3571,7 @@ static hsize_t diff_int(unsigned char *mem1, unsigned char *mem2,
  */
 static hsize_t diff_uint(unsigned char *mem1, unsigned char *mem2,
         hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
-        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1,
         const char *obj2, int *ph)
 {
     hsize_t nfound = 0; /* number of differences found */
@@ -3594,13 +3583,13 @@ static hsize_t diff_uint(unsigned char *mem1, unsigned char *mem2,
 
     h5difftrace("diff_uint start\n");
     /* -d and !-p */
-    if (options->d && !options->p) {
+    if (opts->d && !opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_uint, mem1, sizeof(unsigned int));
             HDmemcpy(&temp2_uint, mem2, sizeof(unsigned int));
 
-            if (PDIFF(temp1_uint,temp2_uint) > options->delta) {
-                if (print_data(options)) {
+            if (PDIFF(temp1_uint,temp2_uint) > opts->delta) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint));
@@ -3609,12 +3598,12 @@ static hsize_t diff_uint(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(unsigned int);
             mem2 += sizeof(unsigned int);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
     /* !-d and -p */
-    else if (!options->d && options->p) {
+    else if (!opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_uint, mem1, sizeof(unsigned int));
             HDmemcpy(&temp2_uint, mem2, sizeof(unsigned int));
@@ -3622,15 +3611,15 @@ static hsize_t diff_uint(unsigned char *mem1, unsigned char *mem2,
             PER_UNSIGN(signed int, temp1_uint, temp2_uint);
 
             if (not_comparable && !both_zero) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P_NOTCOMP, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint));
                 }
                 nfound++;
             }
-            else if (per > options->percent) {
-                if (print_data(options)) {
+            else if (per > opts->percent) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint), per);
@@ -3639,12 +3628,12 @@ static hsize_t diff_uint(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(unsigned int);
             mem2 += sizeof(unsigned int);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
     /* -d and -p */
-    else if (options->d && options->p) {
+    else if (opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_uint, mem1, sizeof(unsigned int));
             HDmemcpy(&temp2_uint, mem2, sizeof(unsigned int));
@@ -3652,16 +3641,16 @@ static hsize_t diff_uint(unsigned char *mem1, unsigned char *mem2,
             PER_UNSIGN(signed int, temp1_uint, temp2_uint);
 
             if (not_comparable && !both_zero) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P_NOTCOMP, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint));
                 }
                 nfound++;
             }
-            else if (per > options->percent
-                    && PDIFF(temp1_uint,temp2_uint) > options->delta) {
-                if (print_data(options)) {
+            else if (per > opts->percent
+                    && PDIFF(temp1_uint,temp2_uint) > opts->delta) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT_P, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint), per);
@@ -3670,7 +3659,7 @@ static hsize_t diff_uint(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(unsigned int);
             mem2 += sizeof(unsigned int);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
@@ -3680,7 +3669,7 @@ static hsize_t diff_uint(unsigned char *mem1, unsigned char *mem2,
             HDmemcpy(&temp2_uint, mem2, sizeof(unsigned int));
 
             if (temp1_uint != temp2_uint) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(I_FORMAT, temp1_uint, temp2_uint, PDIFF(temp1_uint, temp2_uint));
@@ -3690,7 +3679,7 @@ static hsize_t diff_uint(unsigned char *mem1, unsigned char *mem2,
 
             mem1 += sizeof(unsigned int);
             mem2 += sizeof(unsigned int);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         } /* nelmts */
     }
@@ -3709,7 +3698,7 @@ static hsize_t diff_uint(unsigned char *mem1, unsigned char *mem2,
  */
 static hsize_t diff_long(unsigned char *mem1, unsigned char *mem2,
         hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
-        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1,
         const char *obj2, int *ph)
 {
     hsize_t nfound = 0; /* number of differences found */
@@ -3721,14 +3710,14 @@ static hsize_t diff_long(unsigned char *mem1, unsigned char *mem2,
 
     h5difftrace("diff_long start\n");
     /* -d and !-p */
-    if (options->d && !options->p) {
+    if (opts->d && !opts->p) {
         for (i = 0; i < nelmts; i++) {
             for (i = 0; i < nelmts; i++) {
                 HDmemcpy(&temp1_long, mem1, sizeof(long));
                 HDmemcpy(&temp2_long, mem2, sizeof(long));
 
-                if (ABS(temp1_long-temp2_long) > options->delta) {
-                    if (print_data(options)) {
+                if (ABS(temp1_long-temp2_long) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(LI_FORMAT, temp1_long, temp2_long, ABS(temp1_long - temp2_long));
@@ -3737,13 +3726,13 @@ static hsize_t diff_long(unsigned char *mem1, unsigned char *mem2,
                 }
                 mem1 += sizeof(long);
                 mem2 += sizeof(long);
-                if (options->n && nfound >= options->count)
+                if (opts->n && nfound >= opts->count)
                     return nfound;
             }
         }
     }
     /* !-d and -p */
-    else if (!options->d && options->p) {
+    else if (!opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_long, mem1, sizeof(long));
             HDmemcpy(&temp2_long, mem2, sizeof(long));
@@ -3751,15 +3740,15 @@ static hsize_t diff_long(unsigned char *mem1, unsigned char *mem2,
             PER(temp1_long, temp2_long);
 
             if (not_comparable && !both_zero) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(LI_FORMAT_P_NOTCOMP, temp1_long, temp2_long, ABS(temp1_long - temp2_long));
                 }
                 nfound++;
             }
-            else if (per > options->percent) {
-                if (print_data(options)) {
+            else if (per > opts->percent) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(LI_FORMAT_P, temp1_long, temp2_long, ABS(temp1_long - temp2_long), per);
@@ -3768,12 +3757,12 @@ static hsize_t diff_long(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(long);
             mem2 += sizeof(long);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
     /* -d and -p */
-    else if (options->d && options->p) {
+    else if (opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_long, mem1, sizeof(long));
             HDmemcpy(&temp2_long, mem2, sizeof(long));
@@ -3781,15 +3770,15 @@ static hsize_t diff_long(unsigned char *mem1, unsigned char *mem2,
             PER(temp1_long, temp2_long);
 
             if (not_comparable && !both_zero) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(LI_FORMAT_P_NOTCOMP, temp1_long, temp2_long, ABS(temp1_long - temp2_long));
                 }
                 nfound++;
             }
-            else if (per > options->percent && ABS(temp1_long-temp2_long) > options->delta) {
-                if (print_data(options)) {
+            else if (per > opts->percent && ABS(temp1_long-temp2_long) > opts->delta) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(LI_FORMAT_P, temp1_long, temp2_long, ABS(temp1_long - temp2_long), per);
@@ -3798,7 +3787,7 @@ static hsize_t diff_long(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(long);
             mem2 += sizeof(long);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
@@ -3808,7 +3797,7 @@ static hsize_t diff_long(unsigned char *mem1, unsigned char *mem2,
             HDmemcpy(&temp2_long, mem2, sizeof(long));
 
             if (temp1_long != temp2_long) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(LI_FORMAT, temp1_long, temp2_long, ABS(temp1_long - temp2_long));
@@ -3818,7 +3807,7 @@ static hsize_t diff_long(unsigned char *mem1, unsigned char *mem2,
 
             mem1 += sizeof(long);
             mem2 += sizeof(long);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         } /* nelmts */
     }
@@ -3837,7 +3826,7 @@ static hsize_t diff_long(unsigned char *mem1, unsigned char *mem2,
  */
 static hsize_t diff_ulong(unsigned char *mem1, unsigned char *mem2,
         hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
-        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1,
         const char *obj2, int *ph)
 {
     hsize_t       nfound = 0; /* number of differences found */
@@ -3850,14 +3839,14 @@ static hsize_t diff_ulong(unsigned char *mem1, unsigned char *mem2,
     h5difftrace("diff_ulong start\n");
 
     /* -d and !-p */
-    if (options->d && !options->p) {
+    if (opts->d && !opts->p) {
         for (i = 0; i < nelmts; i++) {
             for (i = 0; i < nelmts; i++) {
                 HDmemcpy(&temp1_ulong, mem1, sizeof(unsigned long));
                 HDmemcpy(&temp2_ulong, mem2, sizeof(unsigned long));
 
-                if (PDIFF(temp1_ulong,temp2_ulong) > options->delta) {
-                    if (print_data(options)) {
+                if (PDIFF(temp1_ulong,temp2_ulong) > opts->delta) {
+                    if (print_data(opts)) {
                         print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                         parallel_print(SPACES);
                         parallel_print(LI_FORMAT, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong));
@@ -3866,13 +3855,13 @@ static hsize_t diff_ulong(unsigned char *mem1, unsigned char *mem2,
                 }
                 mem1 += sizeof(unsigned long);
                 mem2 += sizeof(unsigned long);
-                if (options->n && nfound >= options->count)
+                if (opts->n && nfound >= opts->count)
                     return nfound;
             }
         }
     }
     /* !-d and -p */
-    else if (!options->d && options->p) {
+    else if (!opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_ulong, mem1, sizeof(unsigned long));
             HDmemcpy(&temp2_ulong, mem2, sizeof(unsigned long));
@@ -3880,15 +3869,15 @@ static hsize_t diff_ulong(unsigned char *mem1, unsigned char *mem2,
             PER_UNSIGN(signed long, temp1_ulong, temp2_ulong);
 
             if (not_comparable && !both_zero) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(ULI_FORMAT_P_NOTCOMP, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong));
                 }
                 nfound++;
             }
-            else if (per > options->percent) {
-                if (print_data(options)) {
+            else if (per > opts->percent) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(LI_FORMAT_P, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong), per);
@@ -3897,12 +3886,12 @@ static hsize_t diff_ulong(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(unsigned long);
             mem2 += sizeof(unsigned long);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
     /* -d and -p */
-    else if (options->d && options->p) {
+    else if (opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_ulong, mem1, sizeof(unsigned long));
             HDmemcpy(&temp2_ulong, mem2, sizeof(unsigned long));
@@ -3910,16 +3899,16 @@ static hsize_t diff_ulong(unsigned char *mem1, unsigned char *mem2,
             PER_UNSIGN(signed long, temp1_ulong, temp2_ulong);
 
             if (not_comparable && !both_zero) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(ULI_FORMAT_P_NOTCOMP, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong));
                 }
                 nfound++;
             }
-            else if (per > options->percent
-                    && PDIFF(temp1_ulong,temp2_ulong) > options->delta) {
-                if (print_data(options)) {
+            else if (per > opts->percent
+                    && PDIFF(temp1_ulong,temp2_ulong) > opts->delta) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(LI_FORMAT_P, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong), per);
@@ -3928,7 +3917,7 @@ static hsize_t diff_ulong(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(unsigned long);
             mem2 += sizeof(unsigned long);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
@@ -3938,7 +3927,7 @@ static hsize_t diff_ulong(unsigned char *mem1, unsigned char *mem2,
             HDmemcpy(&temp2_ulong, mem2, sizeof(unsigned long));
 
             if (temp1_ulong != temp2_ulong) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(LI_FORMAT, temp1_ulong, temp2_ulong, PDIFF(temp1_ulong, temp2_ulong));
@@ -3948,7 +3937,7 @@ static hsize_t diff_ulong(unsigned char *mem1, unsigned char *mem2,
 
             mem1 += sizeof(unsigned long);
             mem2 += sizeof(unsigned long);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         } /* nelmts */
     }
@@ -3967,7 +3956,7 @@ static hsize_t diff_ulong(unsigned char *mem1, unsigned char *mem2,
  */
 static hsize_t diff_llong(unsigned char *mem1, unsigned char *mem2,
         hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims,
-        hsize_t *acc, hsize_t *pos, diff_opt_t *options, const char *obj1,
+        hsize_t *acc, hsize_t *pos, diff_opt_t *opts, const char *obj1,
         const char *obj2, int *ph)
 {
     hsize_t   nfound = 0; /* number of differences found */
@@ -3979,13 +3968,13 @@ static hsize_t diff_llong(unsigned char *mem1, unsigned char *mem2,
 
     h5difftrace("diff_llong start\n");
     /* -d and !-p */
-    if (options->d && !options->p) {
+    if (opts->d && !opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_llong, mem1, sizeof(long long));
             HDmemcpy(&temp2_llong, mem2, sizeof(long long));
 
-            if (ABS( temp1_llong-temp2_llong) > options->delta) {
-                if (print_data(options)) {
+            if (ABS( temp1_llong-temp2_llong) > opts->delta) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(LLI_FORMAT, temp1_llong, temp2_llong, ABS(temp1_llong - temp2_llong));
@@ -3994,12 +3983,12 @@ static hsize_t diff_llong(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(long long);
             mem2 += sizeof(long long);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
     /* !-d and -p */
-    else if (!options->d && options->p) {
+    else if (!opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_llong, mem1, sizeof(long long));
             HDmemcpy(&temp2_llong, mem2, sizeof(long long));
@@ -4007,15 +3996,15 @@ static hsize_t diff_llong(unsigned char *mem1, unsigned char *mem2,
             PER(temp1_llong, temp2_llong);
 
             if (not_comparable && !both_zero) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                 parallel_print(LLI_FORMAT_P_NOTCOMP, temp1_llong, temp2_llong, ABS(temp1_llong - temp2_llong));
             }
             nfound++;
         }
-        else if (per > options->percent) {
-            if (print_data(options)) {
+        else if (per > opts->percent) {
+            if (print_data(opts)) {
                 print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                 parallel_print(SPACES);
                 parallel_print(LLI_FORMAT_P, temp1_llong, temp2_llong, ABS(temp1_llong - temp2_llong),per);
@@ -4024,12 +4013,12 @@ static hsize_t diff_llong(unsigned char *mem1, unsigned char *mem2,
         }
         mem1 += sizeof(long long);
         mem2 += sizeof(long long);
-        if (options->n && nfound >= options->count)
+        if (opts->n && nfound >= opts->count)
             return nfound;
         }
     }
     /* -d and -p */
-    else if (options->d && options->p) {
+    else if (opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_llong, mem1, sizeof(long long));
             HDmemcpy(&temp2_llong, mem2, sizeof(long long));
@@ -4037,16 +4026,16 @@ static hsize_t diff_llong(unsigned char *mem1, unsigned char *mem2,
             PER(temp1_llong, temp2_llong);
 
             if (not_comparable && !both_zero) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(LLI_FORMAT_P_NOTCOMP, temp1_llong, temp2_llong, ABS(temp1_llong - temp2_llong));
                 }
                 nfound++;
             }
-            else if (per > options->percent
-                    && ABS(temp1_llong-temp2_llong) > options->delta) {
-                if (print_data(options)) {
+            else if (per > opts->percent
+                    && ABS(temp1_llong-temp2_llong) > opts->delta) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(LLI_FORMAT_P, temp1_llong, temp2_llong, ABS(temp1_llong - temp2_llong),per);
@@ -4055,7 +4044,7 @@ static hsize_t diff_llong(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(long long);
             mem2 += sizeof(long long);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
@@ -4065,7 +4054,7 @@ static hsize_t diff_llong(unsigned char *mem1, unsigned char *mem2,
             HDmemcpy(&temp2_llong, mem2, sizeof(long long));
 
             if (temp1_llong != temp2_llong) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(LLI_FORMAT, temp1_llong, temp2_llong, ABS(temp1_llong - temp2_llong));
@@ -4075,7 +4064,7 @@ static hsize_t diff_llong(unsigned char *mem1, unsigned char *mem2,
 
             mem1 += sizeof(long long);
             mem2 += sizeof(long long);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         } /* nelmts */
     }
@@ -4094,7 +4083,7 @@ static hsize_t diff_llong(unsigned char *mem1, unsigned char *mem2,
  */
 static hsize_t diff_ullong(unsigned char *mem1, unsigned char *mem2,
         hsize_t nelmts, hsize_t hyper_start, int rank, hsize_t *dims, hsize_t *acc,
-        hsize_t *pos, diff_opt_t *options, const char *obj1, const char *obj2, int *ph)
+        hsize_t *pos, diff_opt_t *opts, const char *obj1, const char *obj2, int *ph)
 
 {
     hsize_t            nfound = 0; /* number of differences found */
@@ -4107,13 +4096,13 @@ static hsize_t diff_ullong(unsigned char *mem1, unsigned char *mem2,
 
     h5difftrace("diff_ullong start\n");
     /* -d and !-p */
-    if (options->d && !options->p) {
+    if (opts->d && !opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_ullong, mem1, sizeof(unsigned long long));
             HDmemcpy(&temp2_ullong, mem2, sizeof(unsigned long long));
 
-            if (PDIFF(temp1_ullong,temp2_ullong) > (unsigned long long) options->delta) {
-                if (print_data(options)) {
+            if (PDIFF(temp1_ullong,temp2_ullong) > (unsigned long long) opts->delta) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(ULLI_FORMAT,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong));
@@ -4122,12 +4111,12 @@ static hsize_t diff_ullong(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(unsigned long long);
             mem2 += sizeof(unsigned long long);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
     /* !-d and -p */
-    else if (!options->d && options->p) {
+    else if (!opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_ullong, mem1, sizeof(unsigned long long));
             HDmemcpy(&temp2_ullong, mem2, sizeof(unsigned long long));
@@ -4137,15 +4126,15 @@ static hsize_t diff_ullong(unsigned char *mem1, unsigned char *mem2,
             PER(f1, f2);
 
             if (not_comparable && !both_zero) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(ULLI_FORMAT_P_NOTCOMP,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong));
                 }
                 nfound++;
             }
-            else if (per > options->percent) {
-                if (print_data(options)) {
+            else if (per > opts->percent) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(ULLI_FORMAT_P,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong),per);
@@ -4154,12 +4143,12 @@ static hsize_t diff_ullong(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(unsigned long long);
             mem2 += sizeof(unsigned long long);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
     /* -d and -p */
-    else if (options->d && options->p) {
+    else if (opts->d && opts->p) {
         for (i = 0; i < nelmts; i++) {
             HDmemcpy(&temp1_ullong, mem1, sizeof(unsigned long long));
             HDmemcpy(&temp2_ullong, mem2, sizeof(unsigned long long));
@@ -4169,16 +4158,16 @@ static hsize_t diff_ullong(unsigned char *mem1, unsigned char *mem2,
             PER(f1, f2);
 
             if (not_comparable && !both_zero) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(ULLI_FORMAT_P_NOTCOMP,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong));
                 }
                 nfound++;
             }
-            else if (per > options->percent
-                    && PDIFF(temp1_ullong,temp2_ullong) > (unsigned long long) options->delta) {
-                if (print_data(options)) {
+            else if (per > opts->percent
+                    && PDIFF(temp1_ullong,temp2_ullong) > (unsigned long long) opts->delta) {
+                if (print_data(opts)) {
                     print_pos(ph, 1, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(ULLI_FORMAT_P,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong),per);
@@ -4187,7 +4176,7 @@ static hsize_t diff_ullong(unsigned char *mem1, unsigned char *mem2,
             }
             mem1 += sizeof(unsigned long long);
             mem2 += sizeof(unsigned long long);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         }
     }
@@ -4197,7 +4186,7 @@ static hsize_t diff_ullong(unsigned char *mem1, unsigned char *mem2,
             HDmemcpy(&temp2_ullong, mem2, sizeof(unsigned long long));
 
             if (temp1_ullong != temp2_ullong) {
-                if (print_data(options)) {
+                if (print_data(opts)) {
                     print_pos(ph, 0, hyper_start + i, acc, pos, rank, dims, obj1, obj2);
                     parallel_print(SPACES);
                     parallel_print(ULLI_FORMAT,temp1_ullong,temp2_ullong,PDIFF(temp1_ullong,temp2_ullong));
@@ -4207,7 +4196,7 @@ static hsize_t diff_ullong(unsigned char *mem1, unsigned char *mem2,
 
             mem1 += sizeof(unsigned long long);
             mem2 += sizeof(unsigned long long);
-            if (options->n && nfound >= options->count)
+            if (opts->n && nfound >= opts->count)
                 return nfound;
         } /* nelmts */
     }
@@ -4270,9 +4259,9 @@ done:
  * Purpose:     use a absolute error formula to deal with floating point uncertainty
  *-------------------------------------------------------------------------
  */
-static hbool_t equal_double(double value, double expected, diff_opt_t *options) {
+static hbool_t equal_double(double value, double expected, diff_opt_t *opts) {
     h5difftrace("equal_double start\n");
-    if (options->do_nans) {
+    if (opts->do_nans) {
         /*-------------------------------------------------------------------------
         * detect NaNs
         *-------------------------------------------------------------------------
@@ -4298,7 +4287,7 @@ static hbool_t equal_double(double value, double expected, diff_opt_t *options)
     if (value == expected)
         return TRUE;
 
-    if (options->use_system_epsilon)
+    if (opts->use_system_epsilon)
         if (ABS((value-expected)) < DBL_EPSILON)
             return TRUE;
 
@@ -4316,10 +4305,10 @@ static hbool_t equal_double(double value, double expected, diff_opt_t *options)
 
 #if H5_SIZEOF_LONG_DOUBLE !=0
 static
-hbool_t equal_ldouble(long double value, long double expected, diff_opt_t *options)
+hbool_t equal_ldouble(long double value, long double expected, diff_opt_t *opts)
 {
     h5difftrace("equal_ldouble start\n");
-    if (options->do_nans) {
+    if (opts->do_nans) {
         /*-------------------------------------------------------------------------
          * detect NaNs
          *-------------------------------------------------------------------------
@@ -4345,7 +4334,7 @@ hbool_t equal_ldouble(long double value, long double expected, diff_opt_t *optio
     if (value == expected)
         return TRUE;
 
-    if (options->use_system_epsilon)
+    if (opts->use_system_epsilon)
         if (ABS((value-expected)) < DBL_EPSILON)
             return TRUE;
 
@@ -4362,9 +4351,9 @@ hbool_t equal_ldouble(long double value, long double expected, diff_opt_t *optio
  * Purpose:     use a absolute error formula to deal with floating point uncertainty
  *-------------------------------------------------------------------------
  */
-static hbool_t equal_float(float value, float expected, diff_opt_t *options) {
+static hbool_t equal_float(float value, float expected, diff_opt_t *opts) {
     h5difftrace("equal_float start\n");
-    if (options->do_nans) {
+    if (opts->do_nans) {
         /*-------------------------------------------------------------------------
         * detect NaNs
         *-------------------------------------------------------------------------
@@ -4390,7 +4379,7 @@ static hbool_t equal_float(float value, float expected, diff_opt_t *options) {
     if (value == expected)
         return TRUE;
 
-    if (options->use_system_epsilon)
+    if (opts->use_system_epsilon)
         if ( ABS( (value-expected) ) < FLT_EPSILON)
             return TRUE;
 
@@ -4490,9 +4479,9 @@ static hbool_t my_isnan(dtype_t type, void *val) {
  *-------------------------------------------------------------------------
  */
 static
-int print_data(diff_opt_t *options)
+int print_data(diff_opt_t *opts)
 {
-    return ((options->m_report || options->m_verbose) && !options->m_quiet) ? 1 : 0;
+    return ((opts->m_report || opts->m_verbose) && !opts->m_quiet) ? 1 : 0;
 }
 
 /*-------------------------------------------------------------------------
diff --git a/tools/lib/h5diff_attr.c b/tools/lib/h5diff_attr.c
index 64038f3..d671449 100644
--- a/tools/lib/h5diff_attr.c
+++ b/tools/lib/h5diff_attr.c
@@ -137,7 +137,7 @@ static void table_attr_mark_exist(unsigned *exist, char *name, table_attrs_t *ta
  * Parameter:
  *  table_out [OUT] : return the list
  *------------------------------------------------------------------------*/
-static herr_t build_match_list_attrs(hid_t loc1_id, hid_t loc2_id, table_attrs_t ** table_out,  diff_opt_t *options)
+static herr_t build_match_list_attrs(hid_t loc1_id, hid_t loc2_id, table_attrs_t ** table_out,  diff_opt_t *opts)
 {
     int        ret_value = 0;     /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
     H5O_info_t oinfo1, oinfo2;    /* Object info */
@@ -264,7 +264,7 @@ static herr_t build_match_list_attrs(hid_t loc1_id, hid_t loc2_id, table_attrs_t
     /*------------------------------------------------------
      * print the list
      */
-    if(options->m_verbose_level == 2) {
+    if(opts->m_verbose_level == 2) {
         /* if '-v2' is detected */
         parallel_print("   obj1   obj2\n");
         parallel_print(" --------------------------------------\n");
@@ -276,7 +276,7 @@ static herr_t build_match_list_attrs(hid_t loc1_id, hid_t loc2_id, table_attrs_t
         } /* end for */
     }
 
-    if(options->m_verbose_level >= 1)
+    if(opts->m_verbose_level >= 1)
         parallel_print("Attributes status:  %d common, %d only in obj1, %d only in obj2\n",
                 table_lp->nattrs - table_lp->nattrs_only1 - table_lp->nattrs_only2,
                 table_lp->nattrs_only1, table_lp->nattrs_only2);
@@ -312,7 +312,7 @@ hsize_t diff_attr(hid_t loc1_id,
                   hid_t loc2_id,
                   const char *path1,
                   const char *path2,
-                  diff_opt_t *options)
+                  diff_opt_t *opts)
 {
     int        ret_value = 0;     /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
     hid_t      attr1_id = -1;     /* attr ID */
@@ -349,16 +349,16 @@ hsize_t diff_attr(hid_t loc1_id,
     h5difftrace("diff_attr start\n");
 
     /* Initialize error status */
-    options->err_stat = 1;
+    opts->err_stat = 1;
 
-    if(build_match_list_attrs(loc1_id, loc2_id, &match_list_attrs, options) < 0)
+    if(build_match_list_attrs(loc1_id, loc2_id, &match_list_attrs, opts) < 0)
         HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "build_match_list_attrs failed");
 
     /* if detect any unique extra attr */
     if(match_list_attrs->nattrs_only1 || match_list_attrs->nattrs_only2) {
         h5difftrace("diff_attr attributes only in one file\n");
         /* exit will be 1 */
-        options->contents = 0;
+        opts->contents = 0;
     }
 
     for(u = 0; u < (unsigned)match_list_attrs->nattrs; u++) {
@@ -387,10 +387,10 @@ hsize_t diff_attr(hid_t loc1_id,
 
             /* no compare if either one but not both are variable string type */
             if (vstrtype1 != vstrtype2) {
-                if((options->m_verbose || options->m_list_not_cmp))
+                if((opts->m_verbose || opts->m_list_not_cmp))
                     parallel_print("Not comparable: one of attribute <%s/%s> or <%s/%s> is of variable length type\n",
                             path1, name1, path2, name2);
-                options->not_cmp = 1;
+                opts->not_cmp = 1;
                 if (H5Tclose(ftype1_id) < 0)
                     HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose first attribute ftype failed");
                 if (H5Tclose(ftype2_id) < 0)
@@ -432,7 +432,7 @@ hsize_t diff_attr(hid_t loc1_id,
             /* pass dims1 and dims2 for maxdims as well since attribute's maxdims
             * are always same */
             if(diff_can_type(ftype1_id, ftype2_id, rank1, rank2, dims1, dims2,
-                    dims1, dims2, name1, name2, options, 0) != 1) {
+                    dims1, dims2, name1, name2, opts, 0) != 1) {
                 if(H5Tclose(ftype1_id) < 0)
                     HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tclose first attribute ftype failed");
                 if(H5Tclose(ftype2_id) < 0)
@@ -500,22 +500,22 @@ hsize_t diff_attr(hid_t loc1_id,
 
             /* always print name */
             /* verbose (-v) and report (-r) mode */
-            if(options->m_verbose || options->m_report) {
+            if(opts->m_verbose || opts->m_report) {
                 do_print_attrname("attribute", np1, np2);
 
                 nfound = diff_array(buf1, buf2, nelmts1, (hsize_t) 0, rank1,
-                        dims1, options, np1, np2, mtype1_id, attr1_id, attr2_id);
+                        dims1, opts, np1, np2, mtype1_id, attr1_id, attr2_id);
                 print_found(nfound);
             }
             /* quiet mode (-q), just count differences */
-            else if(options->m_quiet) {
+            else if(opts->m_quiet) {
                 nfound = diff_array(buf1, buf2, nelmts1, (hsize_t) 0, rank1,
-                        dims1, options, np1, np2, mtype1_id, attr1_id, attr2_id);
+                        dims1, opts, np1, np2, mtype1_id, attr1_id, attr2_id);
             }
             /* the rest (-c, none, ...) */
             else {
                 nfound = diff_array(buf1, buf2, nelmts1, (hsize_t) 0, rank1,
-                        dims1, options, np1, np2, mtype1_id, attr1_id, attr2_id);
+                        dims1, opts, np1, np2, mtype1_id, attr1_id, attr2_id);
 
                 /* print info if compatible and difference found */
                 if (nfound) {
@@ -562,7 +562,7 @@ hsize_t diff_attr(hid_t loc1_id,
         }
     } /* u */
 
-    options->err_stat = 0;
+    opts->err_stat = 0;
 
 done:
     H5E_BEGIN_TRY {
diff --git a/tools/lib/h5diff_dset.c b/tools/lib/h5diff_dset.c
index 16239f5..768caff 100644
--- a/tools/lib/h5diff_dset.c
+++ b/tools/lib/h5diff_dset.c
@@ -31,7 +31,7 @@ hsize_t diff_dataset(hid_t file1_id,
                      hid_t file2_id,
                      const char *obj1_name,
                      const char *obj2_name,
-                     diff_opt_t *options)
+                     diff_opt_t *opts)
 {
     int     ret_value = 0; /*no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
     hid_t   did1 = -1;
@@ -41,7 +41,7 @@ hsize_t diff_dataset(hid_t file1_id,
     hsize_t nfound = 0;
 
     h5difftrace("diff_dataset start\n");
-    options->err_stat = 1;
+    opts->err_stat = 1;
     /*-------------------------------------------------------------------------
      * open the handles
      *-------------------------------------------------------------------------
@@ -68,13 +68,16 @@ hsize_t diff_dataset(hid_t file1_id,
      * 2) the internal filters might be turned off
      *-------------------------------------------------------------------------
      */
-    if ((h5tools_canreadf((options->m_verbose ? obj1_name : NULL), dcpl1) == 1) &&
-            (h5tools_canreadf((options->m_verbose ? obj2_name : NULL), dcpl2) == 1))
-        nfound = diff_datasetid(did1, did2, obj1_name, obj2_name, options);
-    else
+    if ((ret_value = h5tools_canreadf((opts->m_verbose ? obj1_name : NULL), dcpl1) == 1) &&
+            (ret_value = h5tools_canreadf((opts->m_verbose ? obj2_name : NULL), dcpl2) == 1))
+        nfound = diff_datasetid(did1, did2, obj1_name, obj2_name, opts);
+    else if (ret_value < 0) {
         HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "h5tools_canreadf failed");
+    }
+    else
+        opts->not_cmp = 1;
 
-    options->err_stat = 0;
+    opts->err_stat = 0;
 
 done:
     /* disable error reporting */
@@ -86,7 +89,7 @@ done:
         /* enable error reporting */
     } H5E_END_TRY;
 
-    h5difftrace("diff_dataset end\n");
+    h5diffdebug2("diff_dataset finish:%d\n", nfound);
     return nfound;
 }
 
@@ -145,7 +148,7 @@ hsize_t diff_datasetid(hid_t did1,
                        hid_t did2,
                        const char *obj1_name,
                        const char *obj2_name,
-                       diff_opt_t *options)
+                       diff_opt_t *opts)
 {
     int        ret_value = 0;            /* no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
     hid_t      sid1 = -1;
@@ -189,7 +192,7 @@ hsize_t diff_datasetid(hid_t did1,
     int        i;
     unsigned int  vl_data = 0;          /*contains VL datatypes */
 
-    options->err_stat = 1;
+    opts->err_stat = 1;
     h5difftrace("diff_datasetid start\n");
     /* Get the dataspace handle */
     if((sid1 = H5Dget_space(did1)) < 0)
@@ -255,14 +258,14 @@ hsize_t diff_datasetid(hid_t did1,
 
     if(storage_size1 == 0 || storage_size2 == 0) {
         if(stl1 == H5D_VIRTUAL || stl2 == H5D_VIRTUAL) {
-            if((options->m_verbose||options->m_list_not_cmp) && obj1_name && obj2_name)
+            if((opts->m_verbose||opts->m_list_not_cmp) && obj1_name && obj2_name)
                 parallel_print("Warning: <%s> or <%s> is a virtual dataset\n", obj1_name, obj2_name);
         }
         else {
-            if((options->m_verbose || options->m_list_not_cmp) && obj1_name && obj2_name)
+            if((opts->m_verbose || opts->m_list_not_cmp) && obj1_name && obj2_name)
                 parallel_print("Not comparable: <%s> or <%s> is an empty dataset\n", obj1_name, obj2_name);
             can_compare = 0;
-            options->not_cmp = 1;
+            opts->not_cmp = 1;
         }
     }
 
@@ -273,7 +276,7 @@ hsize_t diff_datasetid(hid_t did1,
     if (diff_can_type(f_tid1, f_tid2, rank1, rank2,
             dims1, dims2, maxdim1, maxdim2,
             obj1_name, obj2_name,
-            options, 0) != 1)
+            opts, 0) != 1)
         can_compare = 0;
 
     /*-------------------------------------------------------------------------
@@ -301,13 +304,13 @@ hsize_t diff_datasetid(hid_t did1,
         sign2 = H5Tget_sign(m_tid2);
         if(sign1 != sign2) {
             h5difftrace("sign1 != sign2\n");
-            if((options->m_verbose || options->m_list_not_cmp) && obj1_name && obj2_name) {
+            if((opts->m_verbose || opts->m_list_not_cmp) && obj1_name && obj2_name) {
                 parallel_print("Not comparable: <%s> has sign %s ", obj1_name, get_sign(sign1));
                 parallel_print("and <%s> has sign %s\n", obj2_name, get_sign(sign2));
             }
 
             can_compare = 0;
-            options->not_cmp = 1;
+            opts->not_cmp = 1;
         }
     }
 
@@ -401,7 +404,7 @@ hsize_t diff_datasetid(hid_t did1,
 
             /* array diff */
             nfound = diff_array(buf1, buf2, danelmts, (hsize_t)0, rank1, dadims,
-                options, name1, name2, dam_tid, did1, did2);
+                opts, name1, name2, dam_tid, did1, did2);
             h5diffdebug2("diff_array nfound:%d\n", nfound);
 
             /* reclaim any VL memory, if necessary */
@@ -496,7 +499,7 @@ hsize_t diff_datasetid(hid_t did1,
                 /* get array differences. in the case of hyperslab read, increment the number of differences
                 found in each hyperslab and pass the position at the beginning for printing */
                 nfound += diff_array(sm_buf1, sm_buf2, hs_nelmts, elmtno, rank1,
-                        dadims, options, name1, name2, dam_tid, did1, did2);
+                        dadims, opts, name1, name2, dam_tid, did1, did2);
 
                 /* reclaim any VL memory, if necessary */
                 if(vl_data) {
@@ -535,7 +538,7 @@ hsize_t diff_datasetid(hid_t did1,
 
 done:
 
-    options->err_stat = ret_value;
+    opts->err_stat = ret_value;
 
     /* free */
     if(buf1 != NULL) {
@@ -577,8 +580,8 @@ done:
         H5Tclose(m_tid2);
         /* enable error reporting */
     } H5E_END_TRY;
-    h5diffdebug3("diff_datasetid return:%d with nfound:%d\n", ret_value, nfound);
 
+    h5diffdebug3("diff_datasetid return:%d with nfound:%d\n", ret_value, nfound);
     return nfound;
 }
 
@@ -604,10 +607,10 @@ int diff_can_type(hid_t       f_tid1, /* file data type */
                   hsize_t     *maxdim2,
                   const char  *obj1_name,
                   const char  *obj2_name,
-                  diff_opt_t  *options,
+                  diff_opt_t  *opts,
                   int         is_compound)
 {
-    int          ret_value = 0;            /* can_compare value, no need to LEAVE() on ERROR: HERR_INIT(int, SUCCEED) */
+    int          ret_value = 1;            /* can_compare value */
     H5T_class_t  tclass1;
     H5T_class_t  tclass2;
     int          maxdim_diff = 0;          /* maximum dimensions are different */
@@ -625,7 +628,7 @@ int diff_can_type(hid_t       f_tid1, /* file data type */
         HGOTO_ERROR(FAIL, H5E_tools_min_id_g, "H5Tget_class second object failed");
 
     if(tclass1 != tclass2) {
-        if((options->m_verbose || options->m_list_not_cmp) && obj1_name && obj2_name) {
+        if((opts->m_verbose || opts->m_list_not_cmp) && obj1_name && obj2_name) {
             if(is_compound) {
                 parallel_print("Not comparable: <%s> has a class %s and <%s> has a class %s\n",
                         obj1_name, get_class(tclass1),
@@ -637,7 +640,7 @@ int diff_can_type(hid_t       f_tid1, /* file data type */
                         obj2_name, get_class(tclass2));
             }
         }
-        options->not_cmp = 1;
+        opts->not_cmp = 1;
         HGOTO_DONE(0);
     }
 
@@ -647,11 +650,11 @@ int diff_can_type(hid_t       f_tid1, /* file data type */
      */
     switch (tclass1) {
         case H5T_TIME:
-            if((options->m_verbose || options->m_list_not_cmp) && obj1_name && obj2_name) {
+            if((opts->m_verbose || opts->m_list_not_cmp) && obj1_name && obj2_name) {
                 parallel_print("Not comparable: <%s> and <%s> are of class %s\n",
                         obj1_name, obj2_name, get_class(tclass2));
             } /* end if */
-            options->not_cmp = 1;
+            opts->not_cmp = 1;
             HGOTO_DONE(0);
 
         case H5T_INTEGER:
@@ -675,7 +678,7 @@ int diff_can_type(hid_t       f_tid1, /* file data type */
      * check for equal file datatype; warning only
      *-------------------------------------------------------------------------
      */
-    if((H5Tequal(f_tid1, f_tid2) == 0) && (options->m_verbose) && obj1_name && obj2_name) {
+    if((H5Tequal(f_tid1, f_tid2) == 0) && (opts->m_verbose) && obj1_name && obj2_name) {
         H5T_class_t cl = H5Tget_class(f_tid1);
 
         parallel_print("Warning: different storage datatype\n");
@@ -694,7 +697,7 @@ int diff_can_type(hid_t       f_tid1, /* file data type */
      *-------------------------------------------------------------------------
      */
     if(rank1 != rank2) {
-        if((options->m_verbose || options->m_list_not_cmp) && obj1_name && obj2_name) {
+        if((opts->m_verbose || opts->m_list_not_cmp) && obj1_name && obj2_name) {
             parallel_print("Not comparable: <%s> has rank %d, dimensions ", obj1_name, rank1);
             print_dimensions(rank1, dims1);
             parallel_print(", max dimensions ");
@@ -706,7 +709,7 @@ int diff_can_type(hid_t       f_tid1, /* file data type */
             print_dimensions(rank2, maxdim2);
             parallel_print("\n");
         }
-        options->not_cmp = 1;
+        opts->not_cmp = 1;
         HGOTO_DONE(0);
     }
 
@@ -728,7 +731,7 @@ int diff_can_type(hid_t       f_tid1, /* file data type */
      *-------------------------------------------------------------------------
      */
     if(dim_diff == 1) {
-        if((options->m_verbose || options->m_list_not_cmp) && obj1_name && obj2_name) {
+        if((opts->m_verbose || opts->m_list_not_cmp) && obj1_name && obj2_name) {
             parallel_print("Not comparable: <%s> has rank %d, dimensions ", obj1_name, rank1);
             print_dimensions(rank1, dims1);
             if(maxdim1 && maxdim2) {
@@ -742,7 +745,7 @@ int diff_can_type(hid_t       f_tid1, /* file data type */
                 parallel_print("\n");
             }
         }
-        options->not_cmp = 1;
+        opts->not_cmp = 1;
         HGOTO_DONE(0);
     }
 
@@ -751,7 +754,7 @@ int diff_can_type(hid_t       f_tid1, /* file data type */
      *-------------------------------------------------------------------------
      */
     if(maxdim1 && maxdim2 && maxdim_diff == 1 && obj1_name) {
-        if(options->m_verbose) {
+        if(opts->m_verbose) {
             parallel_print( "Warning: different maximum dimensions\n");
             parallel_print("<%s> has max dimensions ", obj1_name);
             print_dimensions(rank1, maxdim1);
@@ -773,12 +776,12 @@ int diff_can_type(hid_t       f_tid1, /* file data type */
         nmembs2 = H5Tget_nmembers(f_tid2);
 
         if(nmembs1 != nmembs2) {
-            if((options->m_verbose || options->m_list_not_cmp) && obj1_name && obj2_name) {
+            if((opts->m_verbose || opts->m_list_not_cmp) && obj1_name && obj2_name) {
                 parallel_print("Not comparable: <%s> has %d members ", obj1_name, nmembs1);
                 parallel_print("<%s> has %d members ", obj2_name, nmembs2);
                 parallel_print("\n");
             }
-            options->not_cmp = 1;
+            opts->not_cmp = 1;
             HGOTO_DONE(0);
         }
 
@@ -788,8 +791,8 @@ int diff_can_type(hid_t       f_tid1, /* file data type */
 
             if (diff_can_type(memb_type1, memb_type2, rank1, rank2,
                     dims1, dims2, maxdim1, maxdim2, obj1_name, obj2_name,
-                    options, 1) != 1) {
-                options->not_cmp = 1;
+                    opts, 1) != 1) {
+                opts->not_cmp = 1;
                 H5Tclose(memb_type1);
                 H5Tclose(memb_type2);
                 HGOTO_DONE(0);
@@ -799,7 +802,7 @@ int diff_can_type(hid_t       f_tid1, /* file data type */
         }
     }
 done:
-    h5diffdebug2("diff_can_type end - %d\n", can_compare);
+    h5diffdebug2("diff_can_type end - %d\n", ret_value);
     return ret_value;
 }
 
diff --git a/tools/lib/h5tools_filters.c b/tools/lib/h5tools_filters.c
index a5d0994..132e69a 100644
--- a/tools/lib/h5tools_filters.c
+++ b/tools/lib/h5tools_filters.c
@@ -21,7 +21,7 @@
 static void print_warning(const char *dname, const char *fname)
 {
     fprintf(stderr,
-            "warning: dataset <%s> cannot be read, %s filter is not available\n",
+            "Warning: dataset <%s> cannot be read, %s filter is not available\n",
             dname, fname);
 }
 
diff --git a/tools/lib/ph5diff.h b/tools/lib/ph5diff.h
index 996a611..2189e31 100644
--- a/tools/lib/ph5diff.h
+++ b/tools/lib/ph5diff.h
@@ -32,7 +32,7 @@ struct diff_mpi_args
 {
     char  name1[256];
     char  name2[256];
-    diff_opt_t  options;
+    diff_opt_t  opts;
     diff_args_t argdata;  /* rest args */
 };