1.10 Fix tools incompatibility (#1449)

* fix tools incompatibility with get_option #1443

* Fix get_option function

* Committing clang-format changes

Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>

1 files changed, 165 insertions, 0 deletions

diff --git a/tools/lib/h5tools_utils.c b/tools/lib/h5tools_utils.c
index 36333ec..8b138e7 100644
--- a/tools/lib/h5tools_utils.c
+++ b/tools/lib/h5tools_utils.c
@@ -29,6 +29,10 @@
 unsigned           h5tools_nCols    = 80;
 static int         h5tools_d_status = 0;
 static const char *h5tools_progname = "h5tools";
+/* ``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)               */
 
 /*
  * The output functions need a temporary buffer to hold a piece of the
@@ -158,6 +162,167 @@ help_ref_msg(FILE *output)
     HDfprintf(output, "see the <%s> entry in the 'HDF5 Reference Manual'.\n", h5tools_getprogname());
 }
 
+/*-------------------------------------------------------------------------
+ * Function: get_option
+ *
+ * Purpose:  Determine the command-line options a user specified. We can
+ *           accept both short and long type command-lines.
+ *
+ * Return:  Success:    The short valued "name" of the command line
+ *                      parameter or EOF if there are no more
+ *                      parameters to process.
+ *
+ *          Failure:    A question mark.
+ *-------------------------------------------------------------------------
+ */
+int
+get_option(int argc, const char *const *argv, const char *opts, const struct long_options *l_opts)
+{
+    static int sp      = 1;   /* character index in current token */
+    int        optchar = '?'; /* 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') {
+            return EOF;
+        }
+        else if (HDstrcmp(argv[opt_ind], "--") == 0) {
+            opt_ind++;
+            return EOF;
+        }
+    }
+
+    if (sp == 1 && argv[opt_ind][0] == '-' && argv[opt_ind][1] == '-') {
+        /* long command line option */
+        int        i;
+        const char ch      = '=';
+        char *     arg     = HDstrdup(&argv[opt_ind][2]);
+        size_t     arg_len = 0;
+
+        opt_arg = strchr(&argv[opt_ind][2], ch);
+        arg_len = HDstrlen(&argv[opt_ind][2]);
+        if (opt_arg) {
+            arg_len -= HDstrlen(opt_arg);
+            opt_arg++; /* skip the equal sign */
+        }
+        arg[arg_len] = 0;
+
+        for (i = 0; l_opts && l_opts[i].name; i++) {
+            if (HDstrcmp(arg, l_opts[i].name) == 0) {
+                /* we've found a matching long command line flag */
+                optchar = l_opts[i].shortval;
+
+                if (l_opts[i].has_arg != no_arg) {
+                    if (opt_arg == NULL) {
+                        if (l_opts[i].has_arg != optional_arg) {
+                            if (opt_ind < (argc - 1))
+                                if (argv[opt_ind + 1][0] != '-')
+                                    opt_arg = argv[++opt_ind];
+                        }
+                        else if (l_opts[i].has_arg == require_arg) {
+                            if (opt_err)
+                                HDfprintf(rawerrorstream, "%s: option required for \"--%s\" flag\n", argv[0],
+                                          arg);
+
+                            optchar = '?';
+                        }
+                    }
+                }
+                else {
+                    if (opt_arg) {
+                        if (opt_err)
+                            HDfprintf(rawerrorstream, "%s: no option required for \"%s\" flag\n", argv[0],
+                                      arg);
+
+                        optchar = '?';
+                    }
+                }
+                break;
+            }
+        }
+
+        if (l_opts[i].name == NULL) {
+            /* exhausted all of the l_opts we have and still didn't match */
+            if (opt_err)
+                HDfprintf(rawerrorstream, "%s: unknown option \"%s\"\n", argv[0], arg);
+
+            optchar = '?';
+        }
+
+        opt_ind++;
+        sp = 1;
+
+        HDfree(arg);
+    }
+    else {
+        register char *cp; /* pointer into current token */
+
+        /* short command line option */
+        optchar = argv[opt_ind][sp];
+
+        if (optchar == ':' || (cp = HDstrchr(opts, optchar)) == 0) {
+            if (opt_err)
+                HDfprintf(rawerrorstream, "%s: unknown option \"%c\"\n", argv[0], optchar);
+
+            /* if no chars left in this token, move to next token */
+            if (argv[opt_ind][++sp] == '\0') {
+                opt_ind++;
+                sp = 1;
+            }
+            return '?';
+        }
+
+        if (*++cp == ':') {
+            /* if a value is expected, get it */
+            if (argv[opt_ind][sp + 1] != '\0') {
+                /* flag value is rest of current token */
+                opt_arg = &argv[opt_ind++][sp + 1];
+            }
+            else if (++opt_ind >= argc) {
+                if (opt_err)
+                    HDfprintf(rawerrorstream, "%s: value expected for option \"%c\"\n", argv[0], optchar);
+
+                optchar = '?';
+            }
+            else {
+                /* flag value is next token */
+                opt_arg = argv[opt_ind++];
+            }
+
+            sp = 1;
+        }
+        /* wildcard argument */
+        else if (*cp == '*') {
+            /* check the next argument */
+            opt_ind++;
+            /* we do have an extra argument, check if not last */
+            if ((opt_ind + 1) < argc) {
+                if (argv[opt_ind][0] != '-') {
+                    opt_arg = argv[opt_ind++];
+                }
+                else {
+                    opt_arg = NULL;
+                }
+            }
+            else {
+                opt_arg = NULL;
+            }
+        }
+        else {
+            /* set up to look at next char in token, next time */
+            if (argv[opt_ind][++sp] == '\0') {
+                /* no more in current token, so setup next token */
+                opt_ind++;
+                sp = 1;
+            }
+            opt_arg = NULL;
+        }
+    }
+
+    /* return the current flag character found */
+    return optchar;
+}
+
 /*****************************************************************************
  *
  * Function: parse_tuple()