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

2 files changed, 215 insertions, 0 deletions

diff --git a/src/H5private.h b/src/H5private.h
index 4bd0685..d11b15b 100644
--- a/src/H5private.h
+++ b/src/H5private.h
@@ -2634,6 +2634,57 @@ H5_DLL double H5_get_time(void);
 H5_DLL herr_t H5_build_extpath(const char *name, char **extpath /*out*/);
 H5_DLL herr_t H5_combine_path(const char *path1, const char *path2, char **full_name /*out*/);
 
+/* getopt(3) equivalent that papers over the lack of long options on BSD
+ * and lack of Windows support.
+ */
+H5_DLLVAR int         H5_opterr; /* get_option prints errors if this is on */
+H5_DLLVAR int         H5_optind; /* token pointer */
+H5_DLLVAR const char *H5_optarg; /* flag argument (or value) */
+
+enum h5_arg_level {
+    no_arg = 0,  /* doesn't take an argument     */
+    require_arg, /* requires an argument          */
+    optional_arg /* argument is optional         */
+};
+
+/*
+ * get_option determines which options are specified on the command line and
+ * returns a pointer to any arguments possibly associated with the option in
+ * the ``H5_optarg'' variable. get_option returns the shortname equivalent of
+ * the option. The long options are specified in the following way:
+ *
+ * struct h5_long_options foo[] = {
+ *   { "filename", require_arg, 'f' },
+ *   { "append", no_arg, 'a' },
+ *   { "width", require_arg, 'w' },
+ *   { NULL, 0, 0 }
+ * };
+ *
+ * Long named options can have arguments specified as either:
+ *
+ *   ``--param=arg'' or ``--param arg''
+ *
+ * Short named options can have arguments specified as either:
+ *
+ *   ``-w80'' or ``-w 80''
+ *
+ * and can have more than one short named option specified at one time:
+ *
+ *   -aw80
+ *
+ * in which case those options which expect an argument need to come at the
+ * end.
+ */
+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
+                                 */
+};
+
+H5_DLL int H5_get_option(int argc, const char **argv, const char *opt, const struct h5_long_options *l_opt);
+
 #ifdef H5_HAVE_PARALLEL
 /* Generic MPI functions */
 H5_DLL hsize_t H5_mpi_set_bigio_count(hsize_t new_count);
diff --git a/src/H5system.c b/src/H5system.c
index 7a87a65..0849373 100644
--- a/src/H5system.c
+++ b/src/H5system.c
@@ -936,3 +936,167 @@ done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5_expand_windows_env_vars() */
 #endif /* H5_HAVE_WIN32_API */
+
+/* Global variables */
+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)               */
+
+/*-------------------------------------------------------------------------
+ * Function: H5_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
+H5_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        optopt = '?'; /* option character passed back to user */
+
+    if (sp == 1) {
+        /* check for more flag-like tokens */
+        if (H5_optind >= argc || argv[H5_optind][0] != '-' || argv[H5_optind][1] == '\0') {
+            return EOF;
+        }
+        else if (HDstrcmp(argv[H5_optind], "--") == 0) {
+            H5_optind++;
+            return EOF;
+        }
+    }
+
+    if (sp == 1 && argv[H5_optind][0] == '-' && argv[H5_optind][1] == '-') {
+        /* long command line option */
+        int        i;
+        const char ch      = '=';
+        char *     arg     = HDstrdup(&argv[H5_optind][2]);
+        size_t     arg_len = 0;
+
+        H5_optarg = strchr(&argv[H5_optind][2], ch);
+        arg_len   = HDstrlen(&argv[H5_optind][2]);
+        if (H5_optarg) {
+            arg_len -= HDstrlen(H5_optarg);
+            H5_optarg++; /* 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 */
+                optopt = l_opts[i].shortval;
+
+                if (l_opts[i].has_arg != no_arg) {
+                    if (H5_optarg == NULL) {
+                        if (l_opts[i].has_arg != optional_arg) {
+                            if (H5_optind < (argc - 1))
+                                if (argv[H5_optind + 1][0] != '-')
+                                    H5_optarg = argv[++H5_optind];
+                        }
+                        else if (l_opts[i].has_arg == require_arg) {
+                            if (H5_opterr)
+                                HDfprintf(stderr, "%s: option required for \"--%s\" flag\n", argv[0], arg);
+
+                            optopt = '?';
+                        }
+                    }
+                }
+                else {
+                    if (H5_optarg) {
+                        if (H5_opterr)
+                            HDfprintf(stderr, "%s: no option required for \"%s\" flag\n", argv[0], arg);
+
+                        optopt = '?';
+                    }
+                }
+                break;
+            }
+        }
+
+        if (l_opts[i].name == NULL) {
+            /* exhausted all of the l_opts we have and still didn't match */
+            if (H5_opterr)
+                HDfprintf(stderr, "%s: unknown option \"%s\"\n", argv[0], arg);
+
+            optopt = '?';
+        }
+
+        H5_optind++;
+        sp = 1;
+
+        HDfree(arg);
+    }
+    else {
+        register char *cp; /* pointer into current token */
+
+        /* short command line option */
+        optopt = argv[H5_optind][sp];
+
+        if (optopt == ':' || (cp = HDstrchr(opts, optopt)) == 0) {
+            if (H5_opterr)
+                HDfprintf(stderr, "%s: unknown option \"%c\"\n", argv[0], optopt);
+
+            /* if no chars left in this token, move to next token */
+            if (argv[H5_optind][++sp] == '\0') {
+                H5_optind++;
+                sp = 1;
+            }
+            return '?';
+        }
+
+        if (*++cp == ':') {
+            /* if a value is expected, get it */
+            if (argv[H5_optind][sp + 1] != '\0') {
+                /* flag value is rest of current token */
+                H5_optarg = &argv[H5_optind++][sp + 1];
+            }
+            else if (++H5_optind >= argc) {
+                if (H5_opterr)
+                    HDfprintf(stderr, "%s: value expected for option \"%c\"\n", argv[0], optopt);
+
+                optopt = '?';
+            }
+            else {
+                /* flag value is next token */
+                H5_optarg = argv[H5_optind++];
+            }
+
+            sp = 1;
+        }
+        /* wildcard argument */
+        else if (*cp == '*') {
+            /* check the next argument */
+            H5_optind++;
+            /* we do have an extra argument, check if not last */
+            if ((H5_optind + 1) < argc) {
+                if (argv[H5_optind][0] != '-') {
+                    H5_optarg = argv[H5_optind++];
+                }
+                else {
+                    H5_optarg = NULL;
+                }
+            }
+            else {
+                H5_optarg = NULL;
+            }
+        }
+        else {
+            /* set up to look at next char in token, next time */
+            if (argv[H5_optind][++sp] == '\0') {
+                /* no more in current token, so setup next token */
+                H5_optind++;
+                sp = 1;
+            }
+            H5_optarg = NULL;
+        }
+    }
+
+    /* return the current flag character found */
+    return optopt;
+}