Brings the tools getopt(3) replacement into the main library (#803)

* Moves get_option from the tools library to the C library

* Adds H5 prefix to get_option call and variables

* Renames the H5_get_option long options struct and enum

7 files changed, 474 insertions, 472 deletions

diff --git a/tools/test/perform/pio_perf.c b/tools/test/perform/pio_perf.c
index 6fb5043..d38c574 100644
--- a/tools/test/perform/pio_perf.c
+++ b/tools/test/perform/pio_perf.c
@@ -123,12 +123,12 @@ static const char *s_opts = "a:A:B:cCd:D:e:F:ghi:Imno:p:P:stT:wx:X:";
 #else
 static const char *s_opts = "a:A:bB:cCd:D:e:F:ghi:Imno:p:P:stT:wx:X:";
 #endif /* 1 */
-static struct long_options l_opts[] = {{"align", require_arg, 'a'},
-                                       {"alig", require_arg, 'a'},
-                                       {"ali", require_arg, 'a'},
-                                       {"al", require_arg, 'a'},
-                                       {"api", require_arg, 'A'},
-                                       {"ap", require_arg, 'A'},
+static struct h5_long_options l_opts[] = {{"align", require_arg, 'a'},
+                                          {"alig", require_arg, 'a'},
+                                          {"ali", require_arg, 'a'},
+                                          {"al", require_arg, 'a'},
+                                          {"api", require_arg, 'A'},
+                                          {"ap", require_arg, 'A'},
 #if 0
     /* a sighting of the elusive binary option */
     { "binary", no_arg, 'b' },
@@ -137,133 +137,133 @@ static struct long_options l_opts[] = {{"align", require_arg, 'a'},
     { "bin", no_arg, 'b' },
     { "bi", no_arg, 'b' },
 #endif /* 0 */
-                                       {"block-size", require_arg, 'B'},
-                                       {"block-siz", require_arg, 'B'},
-                                       {"block-si", require_arg, 'B'},
-                                       {"block-s", require_arg, 'B'},
-                                       {"block-", require_arg, 'B'},
-                                       {"block", require_arg, 'B'},
-                                       {"bloc", require_arg, 'B'},
-                                       {"blo", require_arg, 'B'},
-                                       {"bl", require_arg, 'B'},
-                                       {"chunk", no_arg, 'c'},
-                                       {"chun", no_arg, 'c'},
-                                       {"chu", no_arg, 'c'},
-                                       {"ch", no_arg, 'c'},
-                                       {"collective", no_arg, 'C'},
-                                       {"collectiv", no_arg, 'C'},
-                                       {"collecti", no_arg, 'C'},
-                                       {"collect", no_arg, 'C'},
-                                       {"collec", no_arg, 'C'},
-                                       {"colle", no_arg, 'C'},
-                                       {"coll", no_arg, 'C'},
-                                       {"col", no_arg, 'C'},
-                                       {"co", no_arg, 'C'},
-                                       {"debug", require_arg, 'D'},
-                                       {"debu", require_arg, 'D'},
-                                       {"deb", require_arg, 'D'},
-                                       {"de", require_arg, 'D'},
-                                       {"geometry", no_arg, 'g'},
-                                       {"geometr", no_arg, 'g'},
-                                       {"geomet", no_arg, 'g'},
-                                       {"geome", no_arg, 'g'},
-                                       {"geom", no_arg, 'g'},
-                                       {"geo", no_arg, 'g'},
-                                       {"ge", no_arg, 'g'},
-                                       {"help", no_arg, 'h'},
-                                       {"hel", no_arg, 'h'},
-                                       {"he", no_arg, 'h'},
-                                       {"interleaved", require_arg, 'I'},
-                                       {"interleave", require_arg, 'I'},
-                                       {"interleav", require_arg, 'I'},
-                                       {"interlea", require_arg, 'I'},
-                                       {"interle", require_arg, 'I'},
-                                       {"interl", require_arg, 'I'},
-                                       {"inter", require_arg, 'I'},
-                                       {"inte", require_arg, 'I'},
-                                       {"int", require_arg, 'I'},
-                                       {"in", require_arg, 'I'},
-                                       {"max-num-processes", require_arg, 'P'},
-                                       {"max-num-processe", require_arg, 'P'},
-                                       {"max-num-process", require_arg, 'P'},
-                                       {"max-num-proces", require_arg, 'P'},
-                                       {"max-num-proce", require_arg, 'P'},
-                                       {"max-num-proc", require_arg, 'P'},
-                                       {"max-num-pro", require_arg, 'P'},
-                                       {"max-num-pr", require_arg, 'P'},
-                                       {"max-num-p", require_arg, 'P'},
-                                       {"min-num-processes", require_arg, 'p'},
-                                       {"min-num-processe", require_arg, 'p'},
-                                       {"min-num-process", require_arg, 'p'},
-                                       {"min-num-proces", require_arg, 'p'},
-                                       {"min-num-proce", require_arg, 'p'},
-                                       {"min-num-proc", require_arg, 'p'},
-                                       {"min-num-pro", require_arg, 'p'},
-                                       {"min-num-pr", require_arg, 'p'},
-                                       {"min-num-p", require_arg, 'p'},
-                                       {"max-xfer-size", require_arg, 'X'},
-                                       {"max-xfer-siz", require_arg, 'X'},
-                                       {"max-xfer-si", require_arg, 'X'},
-                                       {"max-xfer-s", require_arg, 'X'},
-                                       {"max-xfer", require_arg, 'X'},
-                                       {"max-xfe", require_arg, 'X'},
-                                       {"max-xf", require_arg, 'X'},
-                                       {"max-x", require_arg, 'X'},
-                                       {"min-xfer-size", require_arg, 'x'},
-                                       {"min-xfer-siz", require_arg, 'x'},
-                                       {"min-xfer-si", require_arg, 'x'},
-                                       {"min-xfer-s", require_arg, 'x'},
-                                       {"min-xfer", require_arg, 'x'},
-                                       {"min-xfe", require_arg, 'x'},
-                                       {"min-xf", require_arg, 'x'},
-                                       {"min-x", require_arg, 'x'},
-                                       {"num-bytes", require_arg, 'e'},
-                                       {"num-byte", require_arg, 'e'},
-                                       {"num-byt", require_arg, 'e'},
-                                       {"num-by", require_arg, 'e'},
-                                       {"num-b", require_arg, 'e'},
-                                       {"num-dsets", require_arg, 'd'},
-                                       {"num-dset", require_arg, 'd'},
-                                       {"num-dse", require_arg, 'd'},
-                                       {"num-ds", require_arg, 'd'},
-                                       {"num-d", require_arg, 'd'},
-                                       {"num-files", require_arg, 'F'},
-                                       {"num-file", require_arg, 'F'},
-                                       {"num-fil", require_arg, 'F'},
-                                       {"num-fi", require_arg, 'F'},
-                                       {"num-f", require_arg, 'F'},
-                                       {"num-iterations", require_arg, 'i'},
-                                       {"num-iteration", require_arg, 'i'},
-                                       {"num-iteratio", require_arg, 'i'},
-                                       {"num-iterati", require_arg, 'i'},
-                                       {"num-iterat", require_arg, 'i'},
-                                       {"num-itera", require_arg, 'i'},
-                                       {"num-iter", require_arg, 'i'},
-                                       {"num-ite", require_arg, 'i'},
-                                       {"num-it", require_arg, 'i'},
-                                       {"num-i", require_arg, 'i'},
-                                       {"output", require_arg, 'o'},
-                                       {"outpu", require_arg, 'o'},
-                                       {"outp", require_arg, 'o'},
-                                       {"out", require_arg, 'o'},
-                                       {"ou", require_arg, 'o'},
-                                       {"threshold", require_arg, 'T'},
-                                       {"threshol", require_arg, 'T'},
-                                       {"thresho", require_arg, 'T'},
-                                       {"thresh", require_arg, 'T'},
-                                       {"thres", require_arg, 'T'},
-                                       {"thre", require_arg, 'T'},
-                                       {"thr", require_arg, 'T'},
-                                       {"th", require_arg, 'T'},
-                                       {"write-only", require_arg, 'w'},
-                                       {"write-onl", require_arg, 'w'},
-                                       {"write-on", require_arg, 'w'},
-                                       {"write-o", require_arg, 'w'},
-                                       {"write", require_arg, 'w'},
-                                       {"writ", require_arg, 'w'},
-                                       {"wri", require_arg, 'w'},
-                                       {"wr", require_arg, 'w'},
-                                       {NULL, 0, '\0'}};
+                                          {"block-size", require_arg, 'B'},
+                                          {"block-siz", require_arg, 'B'},
+                                          {"block-si", require_arg, 'B'},
+                                          {"block-s", require_arg, 'B'},
+                                          {"block-", require_arg, 'B'},
+                                          {"block", require_arg, 'B'},
+                                          {"bloc", require_arg, 'B'},
+                                          {"blo", require_arg, 'B'},
+                                          {"bl", require_arg, 'B'},
+                                          {"chunk", no_arg, 'c'},
+                                          {"chun", no_arg, 'c'},
+                                          {"chu", no_arg, 'c'},
+                                          {"ch", no_arg, 'c'},
+                                          {"collective", no_arg, 'C'},
+                                          {"collectiv", no_arg, 'C'},
+                                          {"collecti", no_arg, 'C'},
+                                          {"collect", no_arg, 'C'},
+                                          {"collec", no_arg, 'C'},
+                                          {"colle", no_arg, 'C'},
+                                          {"coll", no_arg, 'C'},
+                                          {"col", no_arg, 'C'},
+                                          {"co", no_arg, 'C'},
+                                          {"debug", require_arg, 'D'},
+                                          {"debu", require_arg, 'D'},
+                                          {"deb", require_arg, 'D'},
+                                          {"de", require_arg, 'D'},
+                                          {"geometry", no_arg, 'g'},
+                                          {"geometr", no_arg, 'g'},
+                                          {"geomet", no_arg, 'g'},
+                                          {"geome", no_arg, 'g'},
+                                          {"geom", no_arg, 'g'},
+                                          {"geo", no_arg, 'g'},
+                                          {"ge", no_arg, 'g'},
+                                          {"help", no_arg, 'h'},
+                                          {"hel", no_arg, 'h'},
+                                          {"he", no_arg, 'h'},
+                                          {"interleaved", require_arg, 'I'},
+                                          {"interleave", require_arg, 'I'},
+                                          {"interleav", require_arg, 'I'},
+                                          {"interlea", require_arg, 'I'},
+                                          {"interle", require_arg, 'I'},
+                                          {"interl", require_arg, 'I'},
+                                          {"inter", require_arg, 'I'},
+                                          {"inte", require_arg, 'I'},
+                                          {"int", require_arg, 'I'},
+                                          {"in", require_arg, 'I'},
+                                          {"max-num-processes", require_arg, 'P'},
+                                          {"max-num-processe", require_arg, 'P'},
+                                          {"max-num-process", require_arg, 'P'},
+                                          {"max-num-proces", require_arg, 'P'},
+                                          {"max-num-proce", require_arg, 'P'},
+                                          {"max-num-proc", require_arg, 'P'},
+                                          {"max-num-pro", require_arg, 'P'},
+                                          {"max-num-pr", require_arg, 'P'},
+                                          {"max-num-p", require_arg, 'P'},
+                                          {"min-num-processes", require_arg, 'p'},
+                                          {"min-num-processe", require_arg, 'p'},
+                                          {"min-num-process", require_arg, 'p'},
+                                          {"min-num-proces", require_arg, 'p'},
+                                          {"min-num-proce", require_arg, 'p'},
+                                          {"min-num-proc", require_arg, 'p'},
+                                          {"min-num-pro", require_arg, 'p'},
+                                          {"min-num-pr", require_arg, 'p'},
+                                          {"min-num-p", require_arg, 'p'},
+                                          {"max-xfer-size", require_arg, 'X'},
+                                          {"max-xfer-siz", require_arg, 'X'},
+                                          {"max-xfer-si", require_arg, 'X'},
+                                          {"max-xfer-s", require_arg, 'X'},
+                                          {"max-xfer", require_arg, 'X'},
+                                          {"max-xfe", require_arg, 'X'},
+                                          {"max-xf", require_arg, 'X'},
+                                          {"max-x", require_arg, 'X'},
+                                          {"min-xfer-size", require_arg, 'x'},
+                                          {"min-xfer-siz", require_arg, 'x'},
+                                          {"min-xfer-si", require_arg, 'x'},
+                                          {"min-xfer-s", require_arg, 'x'},
+                                          {"min-xfer", require_arg, 'x'},
+                                          {"min-xfe", require_arg, 'x'},
+                                          {"min-xf", require_arg, 'x'},
+                                          {"min-x", require_arg, 'x'},
+                                          {"num-bytes", require_arg, 'e'},
+                                          {"num-byte", require_arg, 'e'},
+                                          {"num-byt", require_arg, 'e'},
+                                          {"num-by", require_arg, 'e'},
+                                          {"num-b", require_arg, 'e'},
+                                          {"num-dsets", require_arg, 'd'},
+                                          {"num-dset", require_arg, 'd'},
+                                          {"num-dse", require_arg, 'd'},
+                                          {"num-ds", require_arg, 'd'},
+                                          {"num-d", require_arg, 'd'},
+                                          {"num-files", require_arg, 'F'},
+                                          {"num-file", require_arg, 'F'},
+                                          {"num-fil", require_arg, 'F'},
+                                          {"num-fi", require_arg, 'F'},
+                                          {"num-f", require_arg, 'F'},
+                                          {"num-iterations", require_arg, 'i'},
+                                          {"num-iteration", require_arg, 'i'},
+                                          {"num-iteratio", require_arg, 'i'},
+                                          {"num-iterati", require_arg, 'i'},
+                                          {"num-iterat", require_arg, 'i'},
+                                          {"num-itera", require_arg, 'i'},
+                                          {"num-iter", require_arg, 'i'},
+                                          {"num-ite", require_arg, 'i'},
+                                          {"num-it", require_arg, 'i'},
+                                          {"num-i", require_arg, 'i'},
+                                          {"output", require_arg, 'o'},
+                                          {"outpu", require_arg, 'o'},
+                                          {"outp", require_arg, 'o'},
+                                          {"out", require_arg, 'o'},
+                                          {"ou", require_arg, 'o'},
+                                          {"threshold", require_arg, 'T'},
+                                          {"threshol", require_arg, 'T'},
+                                          {"thresho", require_arg, 'T'},
+                                          {"thresh", require_arg, 'T'},
+                                          {"thres", require_arg, 'T'},
+                                          {"thre", require_arg, 'T'},
+                                          {"thr", require_arg, 'T'},
+                                          {"th", require_arg, 'T'},
+                                          {"write-only", require_arg, 'w'},
+                                          {"write-onl", require_arg, 'w'},
+                                          {"write-on", require_arg, 'w'},
+                                          {"write-o", require_arg, 'w'},
+                                          {"write", require_arg, 'w'},
+                                          {"writ", require_arg, 'w'},
+                                          {"wri", require_arg, 'w'},
+                                          {"wr", require_arg, 'w'},
+                                          {NULL, 0, '\0'}};
 
 struct options {
     long        io_types;      /* bitmask of which I/O types to test   */
@@ -1286,13 +1286,13 @@ parse_command_line(int argc, char *argv[])
     cl_opts->h5_write_only = FALSE; /* Do both read and write by default */
     cl_opts->verify        = FALSE; /* No Verify data correctness by default */
 
-    while ((opt = get_option(argc, (const char **)argv, s_opts, l_opts)) != EOF) {
+    while ((opt = H5_get_option(argc, (const char **)argv, s_opts, l_opts)) != EOF) {
         switch ((char)opt) {
             case 'a':
-                cl_opts->h5_alignment = parse_size_directive(opt_arg);
+                cl_opts->h5_alignment = parse_size_directive(H5_optarg);
                 break;
             case 'A': {
-                const char *end = opt_arg;
+                const char *end = H5_optarg;
 
                 while (end && *end != '\0') {
                     char buf[10];
@@ -1332,7 +1332,7 @@ parse_command_line(int argc, char *argv[])
             break;
 #endif /* 0 */
             case 'B':
-                cl_opts->blk_size = (size_t)parse_size_directive(opt_arg);
+                cl_opts->blk_size = (size_t)parse_size_directive(H5_optarg);
                 break;
             case 'c':
                 /* Turn on chunked HDF5 dataset creation */
@@ -1342,10 +1342,10 @@ parse_command_line(int argc, char *argv[])
                 cl_opts->collective = 1;
                 break;
             case 'd':
-                cl_opts->num_dsets = atoi(opt_arg);
+                cl_opts->num_dsets = atoi(H5_optarg);
                 break;
             case 'D': {
-                const char *end = opt_arg;
+                const char *end = H5_optarg;
 
                 while (end && *end != '\0') {
                     char buf[10];
@@ -1402,40 +1402,40 @@ parse_command_line(int argc, char *argv[])
 
             break;
             case 'e':
-                cl_opts->num_bpp = parse_size_directive(opt_arg);
+                cl_opts->num_bpp = parse_size_directive(H5_optarg);
                 break;
             case 'F':
-                cl_opts->num_files = HDatoi(opt_arg);
+                cl_opts->num_files = HDatoi(H5_optarg);
                 break;
             case 'g':
                 cl_opts->dim2d = 1;
                 break;
             case 'i':
-                cl_opts->num_iters = HDatoi(opt_arg);
+                cl_opts->num_iters = HDatoi(H5_optarg);
                 break;
             case 'I':
                 cl_opts->interleaved = 1;
                 break;
             case 'o':
-                cl_opts->output_file = opt_arg;
+                cl_opts->output_file = H5_optarg;
                 break;
             case 'p':
-                cl_opts->min_num_procs = HDatoi(opt_arg);
+                cl_opts->min_num_procs = HDatoi(H5_optarg);
                 break;
             case 'P':
-                cl_opts->max_num_procs = HDatoi(opt_arg);
+                cl_opts->max_num_procs = HDatoi(H5_optarg);
                 break;
             case 'T':
-                cl_opts->h5_threshold = parse_size_directive(opt_arg);
+                cl_opts->h5_threshold = parse_size_directive(H5_optarg);
                 break;
             case 'w':
                 cl_opts->h5_write_only = TRUE;
                 break;
             case 'x':
-                cl_opts->min_xfer_size = (size_t)parse_size_directive(opt_arg);
+                cl_opts->min_xfer_size = (size_t)parse_size_directive(H5_optarg);
                 break;
             case 'X':
-                cl_opts->max_xfer_size = (size_t)parse_size_directive(opt_arg);
+                cl_opts->max_xfer_size = (size_t)parse_size_directive(H5_optarg);
                 break;
             case 'h':
             case '?':
diff --git a/tools/test/perform/pio_standalone.c b/tools/test/perform/pio_standalone.c
index 0a9bfc0..db8633e 100644
--- a/tools/test/perform/pio_standalone.c
+++ b/tools/test/perform/pio_standalone.c
@@ -27,30 +27,30 @@ MPI_Info h5_io_info_g = MPI_INFO_NULL; /* MPI INFO object for IO */
 int nCols = 80;
 
 /* ``get_option'' variables */
-int         opt_err = 1; /*get_option prints errors if this is on */
-int         opt_ind = 1; /*token pointer                          */
-const char *opt_arg;     /*flag argument (or value)               */
+int         H5_opterr = 1; /*get_option prints errors if this is on */
+int         H5_optind = 1; /*token pointer                          */
+const char *H5_optarg;     /*flag argument (or value)               */
 
 int
-get_option(int argc, const char **argv, const char *opts, const struct long_options *l_opts)
+get_option(int argc, const char **argv, const char *opts, const struct h5_long_options *l_opts)
 {
     static int sp      = 1;   /* character index in current token */
     int        opt_opt = '?'; /* option character passed back to user */
 
     if (sp == 1) {
         /* check for more flag-like tokens */
-        if (opt_ind >= argc || argv[opt_ind][0] != '-' || argv[opt_ind][1] == '\0') {
+        if (H5_optind >= argc || argv[H5_optind][0] != '-' || argv[H5_optind][1] == '\0') {
             return EOF;
         }
-        else if (HDstrcmp(argv[opt_ind], "--") == 0) {
-            opt_ind++;
+        else if (HDstrcmp(argv[H5_optind], "--") == 0) {
+            H5_optind++;
             return EOF;
         }
     }
 
-    if (sp == 1 && argv[opt_ind][0] == '-' && argv[opt_ind][1] == '-') {
+    if (sp == 1 && argv[H5_optind][0] == '-' && argv[H5_optind][1] == '-') {
         /* long command line option */
-        const char *arg = &argv[opt_ind][2];
+        const char *arg = &argv[H5_optind][2];
         int         i;
 
         for (i = 0; l_opts && l_opts[i].name; i++) {
@@ -62,13 +62,13 @@ get_option(int argc, const char **argv, const char *opts, const struct long_opti
 
                 if (l_opts[i].has_arg != no_arg) {
                     if (arg[len] == '=') {
-                        opt_arg = &arg[len + 1];
+                        H5_optarg = &arg[len + 1];
                     }
-                    else if (opt_ind < (argc - 1) && argv[opt_ind + 1][0] != '-') {
-                        opt_arg = argv[++opt_ind];
+                    else if (H5_optind < (argc - 1) && argv[H5_optind + 1][0] != '-') {
+                        H5_optarg = argv[++H5_optind];
                     }
                     else if (l_opts[i].has_arg == require_arg) {
-                        if (opt_err)
+                        if (H5_opterr)
                             HDfprintf(stderr, "%s: option required for \"--%s\" flag\n", argv[0], arg);
 
                         opt_opt = '?';
@@ -76,13 +76,13 @@ get_option(int argc, const char **argv, const char *opts, const struct long_opti
                 }
                 else {
                     if (arg[len] == '=') {
-                        if (opt_err)
+                        if (H5_opterr)
                             HDfprintf(stderr, "%s: no option required for \"%s\" flag\n", argv[0], arg);
 
                         opt_opt = '?';
                     }
 
-                    opt_arg = NULL;
+                    H5_optarg = NULL;
                 }
 
                 break;
@@ -91,29 +91,29 @@ get_option(int argc, const char **argv, const char *opts, const struct long_opti
 
         if (l_opts[i].name == NULL) {
             /* exhausted all of the l_opts we have and still didn't match */
-            if (opt_err)
+            if (H5_opterr)
                 HDfprintf(stderr, "%s: unknown option \"%s\"\n", argv[0], arg);
 
             opt_opt = '?';
         }
 
-        opt_ind++;
+        H5_optind++;
         sp = 1;
     }
     else {
         register char *cp; /* pointer into current token */
 
         /* short command line option */
-        opt_opt = argv[opt_ind][sp];
+        opt_opt = argv[H5_optind][sp];
 
         if (opt_opt == ':' || (cp = strchr(opts, opt_opt)) == 0) {
 
-            if (opt_err)
+            if (H5_opterr)
                 HDfprintf(stderr, "%s: unknown option \"%c\"\n", argv[0], opt_opt);
 
             /* if no chars left in this token, move to next token */
-            if (argv[opt_ind][++sp] == '\0') {
-                opt_ind++;
+            if (argv[H5_optind][++sp] == '\0') {
+                H5_optind++;
                 sp = 1;
             }
 
@@ -122,32 +122,32 @@ get_option(int argc, const char **argv, const char *opts, const struct long_opti
 
         if (*++cp == ':') {
             /* if a value is expected, get it */
-            if (argv[opt_ind][sp + 1] != '\0') {
+            if (argv[H5_optind][sp + 1] != '\0') {
                 /* flag value is rest of current token */
-                opt_arg = &argv[opt_ind++][sp + 1];
+                H5_optarg = &argv[H5_optind++][sp + 1];
             }
-            else if (++opt_ind >= argc) {
-                if (opt_err)
+            else if (++H5_optind >= argc) {
+                if (H5_opterr)
                     HDfprintf(stderr, "%s: value expected for option \"%c\"\n", argv[0], opt_opt);
 
                 opt_opt = '?';
             }
             else {
                 /* flag value is next token */
-                opt_arg = argv[opt_ind++];
+                H5_optarg = argv[H5_optind++];
             }
 
             sp = 1;
         }
         else {
             /* set up to look at next char in token, next time */
-            if (argv[opt_ind][++sp] == '\0') {
+            if (argv[H5_optind][++sp] == '\0') {
                 /* no more in current token, so setup next token */
-                opt_ind++;
+                H5_optind++;
                 sp = 1;
             }
 
-            opt_arg = NULL;
+            H5_optarg = NULL;
         }
     }
 
diff --git a/tools/test/perform/pio_standalone.h b/tools/test/perform/pio_standalone.h
index 276fa0f..4b5c7b2 100644
--- a/tools/test/perform/pio_standalone.h
+++ b/tools/test/perform/pio_standalone.h
@@ -454,24 +454,25 @@ void h5_dump_info_object(MPI_Info info);
 
 /** From h5tools_utils.h **/
 
-extern int         opt_err; /* getoption prints errors if this is on    */
-extern int         opt_ind; /* token pointer                            */
-extern const char *opt_arg; /* flag argument (or value)                 */
+extern int         H5_opterr; /* getoption prints errors if this is on    */
+extern int         H5_optind; /* token pointer                            */
+extern const char *H5_optarg; /* flag argument (or value)                 */
 
-enum {
+enum h5_arg_level {
     no_arg = 0,  /* doesn't take an argument     */
     require_arg, /* requires an argument          */
     optional_arg /* argument is optional         */
 };
 
-typedef struct long_options {
-    const char *name;     /* name of the long option              */
-    int         has_arg;  /* whether we should look for an arg    */
-    char        shortval; /* the shortname equivalent of long arg
-                           * this gets returned from get_option   */
-} long_options;
+struct h5_long_options {
+    const char *      name;     /* Name of the long option */
+    enum h5_arg_level has_arg;  /* Whether we should look for an arg */
+    char              shortval; /* The shortname equivalent of long arg
+                                 * this gets returned from get_option
+                                 */
+};
 
-extern int get_option(int argc, const char **argv, const char *opt, const struct long_options *l_opt);
+extern int H5_get_option(int argc, const char **argv, const char *opt, const struct h5_long_options *l_opt);
 
 extern int nCols; /*max number of columns for outputting  */
 
diff --git a/tools/test/perform/sio_perf.c b/tools/test/perform/sio_perf.c
index fe4e7e7..51a7825 100644
--- a/tools/test/perform/sio_perf.c
+++ b/tools/test/perform/sio_perf.c
@@ -97,13 +97,13 @@ static const char *progname = "h5perf_serial";
  * It seems that only the options that accept additional information
  * such as dataset size (-e) require the colon next to it.
  */
-static const char *        s_opts   = "a:A:B:c:Cd:D:e:F:ghi:Imno:p:P:r:stT:v:wx:X:";
-static struct long_options l_opts[] = {{"align", require_arg, 'a'},
-                                       {"alig", require_arg, 'a'},
-                                       {"ali", require_arg, 'a'},
-                                       {"al", require_arg, 'a'},
-                                       {"api", require_arg, 'A'},
-                                       {"ap", require_arg, 'A'},
+static const char *           s_opts   = "a:A:B:c:Cd:D:e:F:ghi:Imno:p:P:r:stT:v:wx:X:";
+static struct h5_long_options l_opts[] = {{"align", require_arg, 'a'},
+                                          {"alig", require_arg, 'a'},
+                                          {"ali", require_arg, 'a'},
+                                          {"al", require_arg, 'a'},
+                                          {"api", require_arg, 'A'},
+                                          {"ap", require_arg, 'A'},
 #if 0
     /* a sighting of the elusive binary option */
     { "binary", no_arg, 'b' },
@@ -112,156 +112,156 @@ static struct long_options l_opts[] = {{"align", require_arg, 'a'},
     { "bin", no_arg, 'b' },
     { "bi", no_arg, 'b' },
 #endif /* 0 */
-                                       {"block-size", require_arg, 'B'},
-                                       {"block-siz", require_arg, 'B'},
-                                       {"block-si", require_arg, 'B'},
-                                       {"block-s", require_arg, 'B'},
-                                       {"block-", require_arg, 'B'},
-                                       {"block", require_arg, 'B'},
-                                       {"bloc", require_arg, 'B'},
-                                       {"blo", require_arg, 'B'},
-                                       {"bl", require_arg, 'B'},
-                                       {"chunk", no_arg, 'c'},
-                                       {"chun", no_arg, 'c'},
-                                       {"chu", no_arg, 'c'},
-                                       {"ch", no_arg, 'c'},
-                                       {"collective", no_arg, 'C'},
-                                       {"collectiv", no_arg, 'C'},
-                                       {"collecti", no_arg, 'C'},
-                                       {"collect", no_arg, 'C'},
-                                       {"collec", no_arg, 'C'},
-                                       {"colle", no_arg, 'C'},
-                                       {"coll", no_arg, 'C'},
-                                       {"col", no_arg, 'C'},
-                                       {"co", no_arg, 'C'},
-                                       {"debug", require_arg, 'D'},
-                                       {"debu", require_arg, 'D'},
-                                       {"deb", require_arg, 'D'},
-                                       {"de", require_arg, 'D'},
-                                       {"file-driver", require_arg, 'v'},
-                                       {"file-drive", require_arg, 'v'},
-                                       {"file-driv", require_arg, 'v'},
-                                       {"file-dri", require_arg, 'v'},
-                                       {"file-dr", require_arg, 'v'},
-                                       {"file-d", require_arg, 'v'},
-                                       {"file-", require_arg, 'v'},
-                                       {"file", require_arg, 'v'},
-                                       {"fil", require_arg, 'v'},
-                                       {"fi", require_arg, 'v'},
-                                       {"geometry", no_arg, 'g'},
-                                       {"geometr", no_arg, 'g'},
-                                       {"geomet", no_arg, 'g'},
-                                       {"geome", no_arg, 'g'},
-                                       {"geom", no_arg, 'g'},
-                                       {"geo", no_arg, 'g'},
-                                       {"ge", no_arg, 'g'},
-                                       {"help", no_arg, 'h'},
-                                       {"hel", no_arg, 'h'},
-                                       {"he", no_arg, 'h'},
-                                       {"interleaved", require_arg, 'I'},
-                                       {"interleave", require_arg, 'I'},
-                                       {"interleav", require_arg, 'I'},
-                                       {"interlea", require_arg, 'I'},
-                                       {"interle", require_arg, 'I'},
-                                       {"interl", require_arg, 'I'},
-                                       {"inter", require_arg, 'I'},
-                                       {"inte", require_arg, 'I'},
-                                       {"int", require_arg, 'I'},
-                                       {"in", require_arg, 'I'},
-                                       {"max-num-processes", require_arg, 'P'},
-                                       {"max-num-processe", require_arg, 'P'},
-                                       {"max-num-process", require_arg, 'P'},
-                                       {"max-num-proces", require_arg, 'P'},
-                                       {"max-num-proce", require_arg, 'P'},
-                                       {"max-num-proc", require_arg, 'P'},
-                                       {"max-num-pro", require_arg, 'P'},
-                                       {"max-num-pr", require_arg, 'P'},
-                                       {"max-num-p", require_arg, 'P'},
-                                       {"min-num-processes", require_arg, 'p'},
-                                       {"min-num-processe", require_arg, 'p'},
-                                       {"min-num-process", require_arg, 'p'},
-                                       {"min-num-proces", require_arg, 'p'},
-                                       {"min-num-proce", require_arg, 'p'},
-                                       {"min-num-proc", require_arg, 'p'},
-                                       {"min-num-pro", require_arg, 'p'},
-                                       {"min-num-pr", require_arg, 'p'},
-                                       {"min-num-p", require_arg, 'p'},
-                                       {"max-xfer-size", require_arg, 'X'},
-                                       {"max-xfer-siz", require_arg, 'X'},
-                                       {"max-xfer-si", require_arg, 'X'},
-                                       {"max-xfer-s", require_arg, 'X'},
-                                       {"max-xfer", require_arg, 'X'},
-                                       {"max-xfe", require_arg, 'X'},
-                                       {"max-xf", require_arg, 'X'},
-                                       {"max-x", require_arg, 'X'},
-                                       {"min-xfer-size", require_arg, 'x'},
-                                       {"min-xfer-siz", require_arg, 'x'},
-                                       {"min-xfer-si", require_arg, 'x'},
-                                       {"min-xfer-s", require_arg, 'x'},
-                                       {"min-xfer", require_arg, 'x'},
-                                       {"min-xfe", require_arg, 'x'},
-                                       {"min-xf", require_arg, 'x'},
-                                       {"min-x", require_arg, 'x'},
-                                       {"num-bytes", require_arg, 'e'},
-                                       {"num-byte", require_arg, 'e'},
-                                       {"num-byt", require_arg, 'e'},
-                                       {"num-by", require_arg, 'e'},
-                                       {"num-b", require_arg, 'e'},
-                                       {"num-dsets", require_arg, 'd'},
-                                       {"num-dset", require_arg, 'd'},
-                                       {"num-dse", require_arg, 'd'},
-                                       {"num-ds", require_arg, 'd'},
-                                       {"num-d", require_arg, 'd'},
-                                       {"num-files", require_arg, 'F'},
-                                       {"num-file", require_arg, 'F'},
-                                       {"num-fil", require_arg, 'F'},
-                                       {"num-fi", require_arg, 'F'},
-                                       {"num-f", require_arg, 'F'},
-                                       {"num-iterations", require_arg, 'i'},
-                                       {"num-iteration", require_arg, 'i'},
-                                       {"num-iteratio", require_arg, 'i'},
-                                       {"num-iterati", require_arg, 'i'},
-                                       {"num-iterat", require_arg, 'i'},
-                                       {"num-itera", require_arg, 'i'},
-                                       {"num-iter", require_arg, 'i'},
-                                       {"num-ite", require_arg, 'i'},
-                                       {"num-it", require_arg, 'i'},
-                                       {"num-i", require_arg, 'i'},
-                                       {"order", require_arg, 'r'},
-                                       {"orde", require_arg, 'r'},
-                                       {"ord", require_arg, 'r'},
-                                       {"or", require_arg, 'r'},
-                                       {"output", require_arg, 'o'},
-                                       {"outpu", require_arg, 'o'},
-                                       {"outp", require_arg, 'o'},
-                                       {"out", require_arg, 'o'},
-                                       {"ou", require_arg, 'o'},
-                                       {"extendable", no_arg, 't'},
-                                       {"extendabl", no_arg, 't'},
-                                       {"extendab", no_arg, 't'},
-                                       {"extenda", no_arg, 't'},
-                                       {"extend", no_arg, 't'},
-                                       {"exten", no_arg, 't'},
-                                       {"exte", no_arg, 't'},
-                                       {"ext", no_arg, 't'},
-                                       {"ex", no_arg, 't'},
-                                       {"threshold", require_arg, 'T'},
-                                       {"threshol", require_arg, 'T'},
-                                       {"thresho", require_arg, 'T'},
-                                       {"thresh", require_arg, 'T'},
-                                       {"thres", require_arg, 'T'},
-                                       {"thre", require_arg, 'T'},
-                                       {"thr", require_arg, 'T'},
-                                       {"th", require_arg, 'T'},
-                                       {"write-only", require_arg, 'w'},
-                                       {"write-onl", require_arg, 'w'},
-                                       {"write-on", require_arg, 'w'},
-                                       {"write-o", require_arg, 'w'},
-                                       {"write", require_arg, 'w'},
-                                       {"writ", require_arg, 'w'},
-                                       {"wri", require_arg, 'w'},
-                                       {"wr", require_arg, 'w'},
-                                       {NULL, 0, '\0'}};
+                                          {"block-size", require_arg, 'B'},
+                                          {"block-siz", require_arg, 'B'},
+                                          {"block-si", require_arg, 'B'},
+                                          {"block-s", require_arg, 'B'},
+                                          {"block-", require_arg, 'B'},
+                                          {"block", require_arg, 'B'},
+                                          {"bloc", require_arg, 'B'},
+                                          {"blo", require_arg, 'B'},
+                                          {"bl", require_arg, 'B'},
+                                          {"chunk", no_arg, 'c'},
+                                          {"chun", no_arg, 'c'},
+                                          {"chu", no_arg, 'c'},
+                                          {"ch", no_arg, 'c'},
+                                          {"collective", no_arg, 'C'},
+                                          {"collectiv", no_arg, 'C'},
+                                          {"collecti", no_arg, 'C'},
+                                          {"collect", no_arg, 'C'},
+                                          {"collec", no_arg, 'C'},
+                                          {"colle", no_arg, 'C'},
+                                          {"coll", no_arg, 'C'},
+                                          {"col", no_arg, 'C'},
+                                          {"co", no_arg, 'C'},
+                                          {"debug", require_arg, 'D'},
+                                          {"debu", require_arg, 'D'},
+                                          {"deb", require_arg, 'D'},
+                                          {"de", require_arg, 'D'},
+                                          {"file-driver", require_arg, 'v'},
+                                          {"file-drive", require_arg, 'v'},
+                                          {"file-driv", require_arg, 'v'},
+                                          {"file-dri", require_arg, 'v'},
+                                          {"file-dr", require_arg, 'v'},
+                                          {"file-d", require_arg, 'v'},
+                                          {"file-", require_arg, 'v'},
+                                          {"file", require_arg, 'v'},
+                                          {"fil", require_arg, 'v'},
+                                          {"fi", require_arg, 'v'},
+                                          {"geometry", no_arg, 'g'},
+                                          {"geometr", no_arg, 'g'},
+                                          {"geomet", no_arg, 'g'},
+                                          {"geome", no_arg, 'g'},
+                                          {"geom", no_arg, 'g'},
+                                          {"geo", no_arg, 'g'},
+                                          {"ge", no_arg, 'g'},
+                                          {"help", no_arg, 'h'},
+                                          {"hel", no_arg, 'h'},
+                                          {"he", no_arg, 'h'},
+                                          {"interleaved", require_arg, 'I'},
+                                          {"interleave", require_arg, 'I'},
+                                          {"interleav", require_arg, 'I'},
+                                          {"interlea", require_arg, 'I'},
+                                          {"interle", require_arg, 'I'},
+                                          {"interl", require_arg, 'I'},
+                                          {"inter", require_arg, 'I'},
+                                          {"inte", require_arg, 'I'},
+                                          {"int", require_arg, 'I'},
+                                          {"in", require_arg, 'I'},
+                                          {"max-num-processes", require_arg, 'P'},
+                                          {"max-num-processe", require_arg, 'P'},
+                                          {"max-num-process", require_arg, 'P'},
+                                          {"max-num-proces", require_arg, 'P'},
+                                          {"max-num-proce", require_arg, 'P'},
+                                          {"max-num-proc", require_arg, 'P'},
+                                          {"max-num-pro", require_arg, 'P'},
+                                          {"max-num-pr", require_arg, 'P'},
+                                          {"max-num-p", require_arg, 'P'},
+                                          {"min-num-processes", require_arg, 'p'},
+                                          {"min-num-processe", require_arg, 'p'},
+                                          {"min-num-process", require_arg, 'p'},
+                                          {"min-num-proces", require_arg, 'p'},
+                                          {"min-num-proce", require_arg, 'p'},
+                                          {"min-num-proc", require_arg, 'p'},
+                                          {"min-num-pro", require_arg, 'p'},
+                                          {"min-num-pr", require_arg, 'p'},
+                                          {"min-num-p", require_arg, 'p'},
+                                          {"max-xfer-size", require_arg, 'X'},
+                                          {"max-xfer-siz", require_arg, 'X'},
+                                          {"max-xfer-si", require_arg, 'X'},
+                                          {"max-xfer-s", require_arg, 'X'},
+                                          {"max-xfer", require_arg, 'X'},
+                                          {"max-xfe", require_arg, 'X'},
+                                          {"max-xf", require_arg, 'X'},
+                                          {"max-x", require_arg, 'X'},
+                                          {"min-xfer-size", require_arg, 'x'},
+                                          {"min-xfer-siz", require_arg, 'x'},
+                                          {"min-xfer-si", require_arg, 'x'},
+                                          {"min-xfer-s", require_arg, 'x'},
+                                          {"min-xfer", require_arg, 'x'},
+                                          {"min-xfe", require_arg, 'x'},
+                                          {"min-xf", require_arg, 'x'},
+                                          {"min-x", require_arg, 'x'},
+                                          {"num-bytes", require_arg, 'e'},
+                                          {"num-byte", require_arg, 'e'},
+                                          {"num-byt", require_arg, 'e'},
+                                          {"num-by", require_arg, 'e'},
+                                          {"num-b", require_arg, 'e'},
+                                          {"num-dsets", require_arg, 'd'},
+                                          {"num-dset", require_arg, 'd'},
+                                          {"num-dse", require_arg, 'd'},
+                                          {"num-ds", require_arg, 'd'},
+                                          {"num-d", require_arg, 'd'},
+                                          {"num-files", require_arg, 'F'},
+                                          {"num-file", require_arg, 'F'},
+                                          {"num-fil", require_arg, 'F'},
+                                          {"num-fi", require_arg, 'F'},
+                                          {"num-f", require_arg, 'F'},
+                                          {"num-iterations", require_arg, 'i'},
+                                          {"num-iteration", require_arg, 'i'},
+                                          {"num-iteratio", require_arg, 'i'},
+                                          {"num-iterati", require_arg, 'i'},
+                                          {"num-iterat", require_arg, 'i'},
+                                          {"num-itera", require_arg, 'i'},
+                                          {"num-iter", require_arg, 'i'},
+                                          {"num-ite", require_arg, 'i'},
+                                          {"num-it", require_arg, 'i'},
+                                          {"num-i", require_arg, 'i'},
+                                          {"order", require_arg, 'r'},
+                                          {"orde", require_arg, 'r'},
+                                          {"ord", require_arg, 'r'},
+                                          {"or", require_arg, 'r'},
+                                          {"output", require_arg, 'o'},
+                                          {"outpu", require_arg, 'o'},
+                                          {"outp", require_arg, 'o'},
+                                          {"out", require_arg, 'o'},
+                                          {"ou", require_arg, 'o'},
+                                          {"extendable", no_arg, 't'},
+                                          {"extendabl", no_arg, 't'},
+                                          {"extendab", no_arg, 't'},
+                                          {"extenda", no_arg, 't'},
+                                          {"extend", no_arg, 't'},
+                                          {"exten", no_arg, 't'},
+                                          {"exte", no_arg, 't'},
+                                          {"ext", no_arg, 't'},
+                                          {"ex", no_arg, 't'},
+                                          {"threshold", require_arg, 'T'},
+                                          {"threshol", require_arg, 'T'},
+                                          {"thresho", require_arg, 'T'},
+                                          {"thresh", require_arg, 'T'},
+                                          {"thres", require_arg, 'T'},
+                                          {"thre", require_arg, 'T'},
+                                          {"thr", require_arg, 'T'},
+                                          {"th", require_arg, 'T'},
+                                          {"write-only", require_arg, 'w'},
+                                          {"write-onl", require_arg, 'w'},
+                                          {"write-on", require_arg, 'w'},
+                                          {"write-o", require_arg, 'w'},
+                                          {"write", require_arg, 'w'},
+                                          {"writ", require_arg, 'w'},
+                                          {"wri", require_arg, 'w'},
+                                          {"wr", require_arg, 'w'},
+                                          {NULL, 0, '\0'}};
 
 struct options {
     long        io_types;            /* bitmask of which I/O types to test   */
@@ -993,19 +993,19 @@ parse_command_line(int argc, const char *argv[])
     cl_opts->h5_extendable = FALSE; /* Use extendable dataset */
     cl_opts->verify        = FALSE; /* No Verify data correctness by default */
 
-    while ((opt = get_option(argc, argv, s_opts, l_opts)) != EOF) {
+    while ((opt = H5_get_option(argc, argv, s_opts, l_opts)) != EOF) {
         switch ((char)opt) {
             case 'a':
-                cl_opts->h5_alignment = parse_size_directive(opt_arg);
+                cl_opts->h5_alignment = parse_size_directive(H5_optarg);
                 break;
             case 'G':
-                cl_opts->page_size = parse_size_directive(opt_arg);
+                cl_opts->page_size = parse_size_directive(H5_optarg);
                 break;
             case 'b':
-                cl_opts->page_buffer_size = parse_size_directive(opt_arg);
+                cl_opts->page_buffer_size = parse_size_directive(H5_optarg);
                 break;
             case 'A': {
-                const char *end = opt_arg;
+                const char *end = H5_optarg;
                 while (end && *end != '\0') {
                     char buf[10];
 
@@ -1043,7 +1043,7 @@ parse_command_line(int argc, const char *argv[])
                 /* Turn on chunked HDF5 dataset creation */
                 cl_opts->h5_use_chunks = 1;
                 {
-                    const char *end = opt_arg;
+                    const char *end = H5_optarg;
                     int         j   = 0;
 
                     while (end && *end != '\0') {
@@ -1070,7 +1070,7 @@ parse_command_line(int argc, const char *argv[])
                 break;
 
             case 'D': {
-                const char *end = opt_arg;
+                const char *end = H5_optarg;
 
                 while (end && *end != '\0') {
                     char buf[10];
@@ -1126,7 +1126,7 @@ parse_command_line(int argc, const char *argv[])
 
             break;
             case 'e': {
-                const char *end = opt_arg;
+                const char *end = H5_optarg;
                 int         j   = 0;
 
                 while (end && *end != '\0') {
@@ -1153,38 +1153,38 @@ parse_command_line(int argc, const char *argv[])
             break;
 
             case 'i':
-                cl_opts->num_iters = HDatoi(opt_arg);
+                cl_opts->num_iters = HDatoi(H5_optarg);
                 break;
             case 'o':
-                cl_opts->output_file = opt_arg;
+                cl_opts->output_file = H5_optarg;
                 break;
             case 'T':
-                cl_opts->h5_threshold = parse_size_directive(opt_arg);
+                cl_opts->h5_threshold = parse_size_directive(H5_optarg);
                 break;
             case 'v':
-                if (!HDstrcasecmp(opt_arg, "sec2")) {
+                if (!HDstrcasecmp(H5_optarg, "sec2")) {
                     cl_opts->vfd = sec2;
                 }
-                else if (!HDstrcasecmp(opt_arg, "stdio")) {
+                else if (!HDstrcasecmp(H5_optarg, "stdio")) {
                     cl_opts->vfd = stdio;
                 }
-                else if (!HDstrcasecmp(opt_arg, "core")) {
+                else if (!HDstrcasecmp(H5_optarg, "core")) {
                     cl_opts->vfd = core;
                 }
-                else if (!HDstrcasecmp(opt_arg, "split")) {
+                else if (!HDstrcasecmp(H5_optarg, "split")) {
                     cl_opts->vfd = split;
                 }
-                else if (!HDstrcasecmp(opt_arg, "multi")) {
+                else if (!HDstrcasecmp(H5_optarg, "multi")) {
                     cl_opts->vfd = multi;
                 }
-                else if (!HDstrcasecmp(opt_arg, "family")) {
+                else if (!HDstrcasecmp(H5_optarg, "family")) {
                     cl_opts->vfd = family;
                 }
-                else if (!HDstrcasecmp(opt_arg, "direct")) {
+                else if (!HDstrcasecmp(H5_optarg, "direct")) {
                     cl_opts->vfd = direct;
                 }
                 else {
-                    HDfprintf(stderr, "sio_perf: invalid --api option %s\n", opt_arg);
+                    HDfprintf(stderr, "sio_perf: invalid --api option %s\n", H5_optarg);
                     HDexit(EXIT_FAILURE);
                 }
                 break;
@@ -1195,7 +1195,7 @@ parse_command_line(int argc, const char *argv[])
                 cl_opts->h5_extendable = TRUE;
                 break;
             case 'x': {
-                const char *end = opt_arg;
+                const char *end = H5_optarg;
                 int         j   = 0;
 
                 while (end && *end != '\0') {
@@ -1222,7 +1222,7 @@ parse_command_line(int argc, const char *argv[])
             break;
 
             case 'r': {
-                const char *end = opt_arg;
+                const char *end = H5_optarg;
                 int         j   = 0;
 
                 while (end && *end != '\0') {
diff --git a/tools/test/perform/sio_standalone.c b/tools/test/perform/sio_standalone.c
index abc0777..2e793fb 100644
--- a/tools/test/perform/sio_standalone.c
+++ b/tools/test/perform/sio_standalone.c
@@ -23,30 +23,30 @@
 int nCols = 80;
 
 /* ``get_option'' variables */
-int         opt_err = 1; /*get_option prints errors if this is on */
-int         opt_ind = 1; /*token pointer                          */
-const char *opt_arg;     /*flag argument (or value)               */
+int         H5_opterr = 1; /*get_option prints errors if this is on */
+int         H5_optind = 1; /*token pointer                          */
+const char *H5_optarg;     /*flag argument (or value)               */
 
 int
-get_option(int argc, const char **argv, const char *opts, const struct long_options *l_opts)
+get_option(int argc, const char **argv, const char *opts, const struct h5_long_options *l_opts)
 {
     static int sp      = 1;   /* character index in current token */
     int        opt_opt = '?'; /* option character passed back to user */
 
     if (sp == 1) {
         /* check for more flag-like tokens */
-        if (opt_ind >= argc || argv[opt_ind][0] != '-' || argv[opt_ind][1] == '\0') {
+        if (H5_optind >= argc || argv[H5_optind][0] != '-' || argv[H5_optind][1] == '\0') {
             return EOF;
         }
-        else if (HDstrcmp(argv[opt_ind], "--") == 0) {
-            opt_ind++;
+        else if (HDstrcmp(argv[H5_optind], "--") == 0) {
+            H5_optind++;
             return EOF;
         }
     }
 
-    if (sp == 1 && argv[opt_ind][0] == '-' && argv[opt_ind][1] == '-') {
+    if (sp == 1 && argv[H5_optind][0] == '-' && argv[H5_optind][1] == '-') {
         /* long command line option */
-        const char *arg = &argv[opt_ind][2];
+        const char *arg = &argv[H5_optind][2];
         int         i;
 
         for (i = 0; l_opts && l_opts[i].name; i++) {
@@ -58,13 +58,13 @@ get_option(int argc, const char **argv, const char *opts, const struct long_opti
 
                 if (l_opts[i].has_arg != no_arg) {
                     if (arg[len] == '=') {
-                        opt_arg = &arg[len + 1];
+                        H5_optarg = &arg[len + 1];
                     }
-                    else if (opt_ind < (argc - 1) && argv[opt_ind + 1][0] != '-') {
-                        opt_arg = argv[++opt_ind];
+                    else if (H5_optind < (argc - 1) && argv[H5_optind + 1][0] != '-') {
+                        H5_optarg = argv[++H5_optind];
                     }
                     else if (l_opts[i].has_arg == require_arg) {
-                        if (opt_err)
+                        if (H5_opterr)
                             HDfprintf(stderr, "%s: option required for \"--%s\" flag\n", argv[0], arg);
 
                         opt_opt = '?';
@@ -72,13 +72,13 @@ get_option(int argc, const char **argv, const char *opts, const struct long_opti
                 }
                 else {
                     if (arg[len] == '=') {
-                        if (opt_err)
+                        if (H5_opterr)
                             HDfprintf(stderr, "%s: no option required for \"%s\" flag\n", argv[0], arg);
 
                         opt_opt = '?';
                     }
 
-                    opt_arg = NULL;
+                    H5_optarg = NULL;
                 }
 
                 break;
@@ -87,29 +87,29 @@ get_option(int argc, const char **argv, const char *opts, const struct long_opti
 
         if (l_opts[i].name == NULL) {
             /* exhausted all of the l_opts we have and still didn't match */
-            if (opt_err)
+            if (H5_opterr)
                 HDfprintf(stderr, "%s: unknown option \"%s\"\n", argv[0], arg);
 
             opt_opt = '?';
         }
 
-        opt_ind++;
+        H5_optind++;
         sp = 1;
     }
     else {
         register char *cp; /* pointer into current token */
 
         /* short command line option */
-        opt_opt = argv[opt_ind][sp];
+        opt_opt = argv[H5_optind][sp];
 
         if (opt_opt == ':' || (cp = strchr(opts, opt_opt)) == 0) {
 
-            if (opt_err)
+            if (H5_opterr)
                 HDfprintf(stderr, "%s: unknown option \"%c\"\n", argv[0], opt_opt);
 
             /* if no chars left in this token, move to next token */
-            if (argv[opt_ind][++sp] == '\0') {
-                opt_ind++;
+            if (argv[H5_optind][++sp] == '\0') {
+                H5_optind++;
                 sp = 1;
             }
 
@@ -118,32 +118,32 @@ get_option(int argc, const char **argv, const char *opts, const struct long_opti
 
         if (*++cp == ':') {
             /* if a value is expected, get it */
-            if (argv[opt_ind][sp + 1] != '\0') {
+            if (argv[H5_optind][sp + 1] != '\0') {
                 /* flag value is rest of current token */
-                opt_arg = &argv[opt_ind++][sp + 1];
+                H5_optarg = &argv[H5_optind++][sp + 1];
             }
-            else if (++opt_ind >= argc) {
-                if (opt_err)
+            else if (++H5_optind >= argc) {
+                if (H5_opterr)
                     HDfprintf(stderr, "%s: value expected for option \"%c\"\n", argv[0], opt_opt);
 
                 opt_opt = '?';
             }
             else {
                 /* flag value is next token */
-                opt_arg = argv[opt_ind++];
+                H5_optarg = argv[H5_optind++];
             }
 
             sp = 1;
         }
         else {
             /* set up to look at next char in token, next time */
-            if (argv[opt_ind][++sp] == '\0') {
+            if (argv[H5_optind][++sp] == '\0') {
                 /* no more in current token, so setup next token */
-                opt_ind++;
+                H5_optind++;
                 sp = 1;
             }
 
-            opt_arg = NULL;
+            H5_optarg = NULL;
         }
     }
 
diff --git a/tools/test/perform/sio_standalone.h b/tools/test/perform/sio_standalone.h
index ea1a2a1..098b98a 100644
--- a/tools/test/perform/sio_standalone.h
+++ b/tools/test/perform/sio_standalone.h
@@ -469,24 +469,25 @@ void h5_dump_info_object(MPI_Info info);
 
 /** From h5tools_utils.h **/
 
-extern int         opt_err; /* getoption prints errors if this is on    */
-extern int         opt_ind; /* token pointer                            */
-extern const char *opt_arg; /* flag argument (or value)                 */
+extern int         H5_opterr; /* getoption prints errors if this is on    */
+extern int         H5_optind; /* token pointer                            */
+extern const char *H5_optarg; /* flag argument (or value)                 */
 
-enum {
+enum h5_arg_level {
     no_arg = 0,  /* doesn't take an argument     */
     require_arg, /* requires an argument          */
     optional_arg /* argument is optional         */
 };
 
-typedef struct long_options {
-    const char *name;     /* name of the long option              */
-    int         has_arg;  /* whether we should look for an arg    */
-    char        shortval; /* the shortname equivalent of long arg
-                           * this gets returned from get_option   */
-} long_options;
+struct h5_long_options {
+    const char *      name;     /* Name of the long option */
+    enum h5_arg_level has_arg;  /* Whether we should look for an arg */
+    char              shortval; /* The shortname equivalent of long arg
+                                 * this gets returned from get_option
+                                 */
+};
 
-extern int get_option(int argc, const char **argv, const char *opt, const struct long_options *l_opt);
+extern int H5_get_option(int argc, const char **argv, const char *opt, const struct h5_long_options *l_opt);
 
 extern int nCols; /*max number of columns for outputting  */
 
diff --git a/tools/test/perform/zip_perf.c b/tools/test/perform/zip_perf.c
index 517866b..6231587 100644
--- a/tools/test/perform/zip_perf.c
+++ b/tools/test/perform/zip_perf.c
@@ -64,66 +64,66 @@ static void error(const char *fmt, ...);
 static void compress_buffer(Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen);
 
 /* commandline options : long and short form */
-static const char *        s_opts   = "hB:b:c:p:rs:0123456789";
-static struct long_options l_opts[] = {{"help", no_arg, 'h'},
-                                       {"compressability", require_arg, 'c'},
-                                       {"compressabilit", require_arg, 'c'},
-                                       {"compressabili", require_arg, 'c'},
-                                       {"compressabil", require_arg, 'c'},
-                                       {"compressabi", require_arg, 'c'},
-                                       {"compressab", require_arg, 'c'},
-                                       {"compressa", require_arg, 'c'},
-                                       {"compress", require_arg, 'c'},
-                                       {"compres", require_arg, 'c'},
-                                       {"compre", require_arg, 'c'},
-                                       {"compr", require_arg, 'c'},
-                                       {"comp", require_arg, 'c'},
-                                       {"com", require_arg, 'c'},
-                                       {"co", require_arg, 'c'},
-                                       {"file-size", require_arg, 's'},
-                                       {"file-siz", require_arg, 's'},
-                                       {"file-si", require_arg, 's'},
-                                       {"file-s", require_arg, 's'},
-                                       {"file", require_arg, 's'},
-                                       {"fil", require_arg, 's'},
-                                       {"fi", require_arg, 's'},
-                                       {"max-buffer-size", require_arg, 'B'},
-                                       {"max-buffer-siz", require_arg, 'B'},
-                                       {"max-buffer-si", require_arg, 'B'},
-                                       {"max-buffer-s", require_arg, 'B'},
-                                       {"max-buffer", require_arg, 'B'},
-                                       {"max-buffe", require_arg, 'B'},
-                                       {"max-buff", require_arg, 'B'},
-                                       {"max-buf", require_arg, 'B'},
-                                       {"max-bu", require_arg, 'B'},
-                                       {"max-b", require_arg, 'B'},
-                                       {"max", require_arg, 'B'},
-                                       {"min-buffer-size", require_arg, 'b'},
-                                       {"min-buffer-siz", require_arg, 'b'},
-                                       {"min-buffer-si", require_arg, 'b'},
-                                       {"min-buffer-s", require_arg, 'b'},
-                                       {"min-buffer", require_arg, 'b'},
-                                       {"min-buffe", require_arg, 'b'},
-                                       {"min-buff", require_arg, 'b'},
-                                       {"min-buf", require_arg, 'b'},
-                                       {"min-bu", require_arg, 'b'},
-                                       {"min-b", require_arg, 'b'},
-                                       {"min", require_arg, 'b'},
-                                       {"prefix", require_arg, 'p'},
-                                       {"prefi", require_arg, 'p'},
-                                       {"pref", require_arg, 'p'},
-                                       {"pre", require_arg, 'p'},
-                                       {"pr", require_arg, 'p'},
-                                       {"random-test", no_arg, 'r'},
-                                       {"random-tes", no_arg, 'r'},
-                                       {"random-te", no_arg, 'r'},
-                                       {"random-t", no_arg, 'r'},
-                                       {"random", no_arg, 'r'},
-                                       {"rando", no_arg, 'r'},
-                                       {"rand", no_arg, 'r'},
-                                       {"ran", no_arg, 'r'},
-                                       {"ra", no_arg, 'r'},
-                                       {NULL, 0, '\0'}};
+static const char *           s_opts   = "hB:b:c:p:rs:0123456789";
+static struct h5_long_options l_opts[] = {{"help", no_arg, 'h'},
+                                          {"compressability", require_arg, 'c'},
+                                          {"compressabilit", require_arg, 'c'},
+                                          {"compressabili", require_arg, 'c'},
+                                          {"compressabil", require_arg, 'c'},
+                                          {"compressabi", require_arg, 'c'},
+                                          {"compressab", require_arg, 'c'},
+                                          {"compressa", require_arg, 'c'},
+                                          {"compress", require_arg, 'c'},
+                                          {"compres", require_arg, 'c'},
+                                          {"compre", require_arg, 'c'},
+                                          {"compr", require_arg, 'c'},
+                                          {"comp", require_arg, 'c'},
+                                          {"com", require_arg, 'c'},
+                                          {"co", require_arg, 'c'},
+                                          {"file-size", require_arg, 's'},
+                                          {"file-siz", require_arg, 's'},
+                                          {"file-si", require_arg, 's'},
+                                          {"file-s", require_arg, 's'},
+                                          {"file", require_arg, 's'},
+                                          {"fil", require_arg, 's'},
+                                          {"fi", require_arg, 's'},
+                                          {"max-buffer-size", require_arg, 'B'},
+                                          {"max-buffer-siz", require_arg, 'B'},
+                                          {"max-buffer-si", require_arg, 'B'},
+                                          {"max-buffer-s", require_arg, 'B'},
+                                          {"max-buffer", require_arg, 'B'},
+                                          {"max-buffe", require_arg, 'B'},
+                                          {"max-buff", require_arg, 'B'},
+                                          {"max-buf", require_arg, 'B'},
+                                          {"max-bu", require_arg, 'B'},
+                                          {"max-b", require_arg, 'B'},
+                                          {"max", require_arg, 'B'},
+                                          {"min-buffer-size", require_arg, 'b'},
+                                          {"min-buffer-siz", require_arg, 'b'},
+                                          {"min-buffer-si", require_arg, 'b'},
+                                          {"min-buffer-s", require_arg, 'b'},
+                                          {"min-buffer", require_arg, 'b'},
+                                          {"min-buffe", require_arg, 'b'},
+                                          {"min-buff", require_arg, 'b'},
+                                          {"min-buf", require_arg, 'b'},
+                                          {"min-bu", require_arg, 'b'},
+                                          {"min-b", require_arg, 'b'},
+                                          {"min", require_arg, 'b'},
+                                          {"prefix", require_arg, 'p'},
+                                          {"prefi", require_arg, 'p'},
+                                          {"pref", require_arg, 'p'},
+                                          {"pre", require_arg, 'p'},
+                                          {"pr", require_arg, 'p'},
+                                          {"random-test", no_arg, 'r'},
+                                          {"random-tes", no_arg, 'r'},
+                                          {"random-te", no_arg, 'r'},
+                                          {"random-t", no_arg, 'r'},
+                                          {"random", no_arg, 'r'},
+                                          {"rando", no_arg, 'r'},
+                                          {"rand", no_arg, 'r'},
+                                          {"ran", no_arg, 'r'},
+                                          {"ra", no_arg, 'r'},
+                                          {NULL, 0, '\0'}};
 
 /*
  * Function:    error
@@ -551,7 +551,7 @@ main(int argc, const char *argv[])
     /* Initialize h5tools lib */
     h5tools_init();
 
-    while ((opt = get_option(argc, argv, s_opts, l_opts)) > 0) {
+    while ((opt = H5_get_option(argc, argv, s_opts, l_opts)) > 0) {
         switch ((char)opt) {
             case '0':
             case '1':
@@ -566,13 +566,13 @@ main(int argc, const char *argv[])
                 compress_level = opt - '0';
                 break;
             case 'B':
-                max_buf_size = parse_size_directive(opt_arg);
+                max_buf_size = parse_size_directive(H5_optarg);
                 break;
             case 'b':
-                min_buf_size = parse_size_directive(opt_arg);
+                min_buf_size = parse_size_directive(H5_optarg);
                 break;
             case 'c':
-                compress_percent = (int)HDstrtol(opt_arg, NULL, 10);
+                compress_percent = (int)HDstrtol(H5_optarg, NULL, 10);
 
                 if (compress_percent < 0)
                     compress_percent = 0;
@@ -581,13 +581,13 @@ main(int argc, const char *argv[])
 
                 break;
             case 'p':
-                option_prefix = opt_arg;
+                option_prefix = H5_optarg;
                 break;
             case 'r':
                 random_test = TRUE;
                 break;
             case 's':
-                file_size = parse_size_directive(opt_arg);
+                file_size = parse_size_directive(H5_optarg);
                 break;
             case '?':
                 usage();