VFD SWMR: Sync with develop (#811)

* Normalization with develop

* Removes checks and work-arounds for strtoll and strtoull (#769)

* Removes checks for (v)snprintf, which are C99 (#772)

* Update missing release note info. (#776)

* Replaces the H5_OVERRIDE macro with override (#773)

The macro is no longer necessary now that we require C++11.

* Cleans up some POSIX header bits in H5private.h (#783)

* Removes outdated checks for ways inline might be defined (#781)

These are obsolete now that we require C99.

* Removes checks for system(), which is C89/90 (#782)

* Removes C++ dependency on H5private.h (#774)

* Removes C++ dependency on H5private.h

Most C API calls have been removed, aside from a few uses of free,
where we just dropped the 'HD'. A couple of H5_ATTR_UNUSED macros
were also replaced with (void) statements.

* Committing clang-format changes

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

* Further simplifies Autotools type size checks (#789)

Also fixes an issue where clock_gettime and difftime are not detected
due to earlier simplifications of this code.

* Release Note (#784)

* Normalization of CMake H5pubconf.h with Autotools (#791)

Mostly just moving things around and changing the comments to keep the
delta small. The only symbol change is that for curl/curl.h which I
changed to H5_HAVE_CURL_CURL_H to match the Autotools. This symbol
is not used in the library and is just an artifact of the checks.

* Fix tools test (#794)

* Removes ancient Autotools cruft (#790)

* Reorganization of C and POSIX headers in H5public.h & H5private.h (#793)

* Reorganization of C and POSIX headers in H5public.h & H5private.h

Consolidated and removed duplicates

* It turns out Windows has sys/types.h

Co-authored-by: Larry Knox <lrknox@hdfgroup.org>

* Removes checks for signal and set/longjmp, which are C89 (#798)

Also removes checks for setjmp.h and stddef.h

* Assume frexpl/f and fabsl/f, which are C99 (#799)

* Assume the library has C99 types in C++ type code (#806)

* Assume the library has C99 types in C++ type code

* Committing clang-format changes

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

* Removes obsolete equivalents of C99's __func__ (#800)

* Cleans up POSIX/C bits in H5private.h (#804)

* Cleans up POSIX/C bits in H5private.h

* Assume difftime exists (C89)
* Reorg AC_CHECK_HEADERS so headers are in alphabetical order
* Split off networking-related AC_CHECK_HEADERS
* Remove unused UNAME_CYGWIN from configure.ac
* Remove checks for unused sys/timeb.h
* Tidying pass over H5private.h HD prefix macros
* Tidy H5win32defs.h
* Add HD prefix to various scanf calls

* Committing clang-format changes

* Fixes to the alarm(2) code used in the tests to make Windows happy

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

* 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

* Removes type guesses when C99 types are missing (#807)

* Assume C99 types exist in H5detect.c (#808)

* Fixes parallel issues from recent C99 changes

* Adds MPE FUNC --> __func__ changes missed in earlier PRs

* Fix typo

* Fixes parallel issues from recent C99 changes (#809)

* Fixes parallel issues from recent C99 changes

* Adds MPE FUNC --> __func__ changes missed in earlier PRs

* Even more missed FUNC --> __func__ macros

* Removes remaining H5_TIME_WITH_SYS_TIME cruft (#810)

Mostly from CMake

Co-authored-by: github-actions <41898282+github-actions[bot]@users.noreply.github.com>
Co-authored-by: Larry Knox <lrknox@hdfgroup.org>

1 files changed, 164 insertions, 125 deletions

diff --git a/src/H5system.c b/src/H5system.c
index 879c003..dcb77dd 100644
--- a/src/H5system.c
+++ b/src/H5system.c
@@ -97,131 +97,6 @@ HDvasprintf(char **bufp, const char *fmt, va_list _ap)
 #endif /* H5_HAVE_VASPRINTF */
 
 /*-------------------------------------------------------------------------
- * Function:  HDstrtoll
- *
- * Purpose:  Converts the string S to an int64_t value according to the
- *    given BASE, which must be between 2 and 36 inclusive, or be
- *    the special value zero.
- *
- *    The string must begin with an arbitrary amount of white space
- *    (as determined by isspace(3c)) followed by a single optional
- *              `+' or `-' sign.  If BASE is zero or 16 the string may then
- *    include a `0x' or `0X' prefix, and the number will be read in
- *    base 16; otherwise a zero BASE is taken as 10 (decimal)
- *    unless the next character is a `0', in which case it is taken
- *    as 8 (octal).
- *
- *    The remainder of the string is converted to an int64_t in the
- *    obvious manner, stopping at the first character which is not
- *    a valid digit in the given base.  (In bases above 10, the
- *    letter `A' in either upper or lower case represetns 10, `B'
- *    represents 11, and so forth, with `Z' representing 35.)
- *
- *    If REST is not null, the address of the first invalid
- *    character in S is stored in *REST.  If there were no digits
- *    at all, the original value of S is stored in *REST.  Thus, if
- *    *S is not `\0' but **REST is `\0' on return the entire string
- *    was valid.
- *
- * Return:  Success:  The result.
- *
- *    Failure:  If the input string does not contain any
- *        digits then zero is returned and REST points
- *        to the original value of S.  If an overflow
- *        or underflow occurs then the maximum or
- *        minimum possible value is returned and the
- *        global `errno' is set to ERANGE.  If BASE is
- *        incorrect then zero is returned.
- *
- * Programmer:  Robb Matzke
- *              Thursday, April  9, 1998
- *
- *-------------------------------------------------------------------------
- */
-#ifndef HDstrtoll
-int64_t
-HDstrtoll(const char *s, const char **rest, int base)
-{
-    int64_t sign = 1, acc = 0;
-    hbool_t overflow = FALSE;
-
-    errno = 0;
-    if (!s || (base && (base < 2 || base > 36))) {
-        if (rest)
-            *rest = s;
-        return 0;
-    }
-
-    /* Skip white space */
-    while (HDisspace(*s))
-        s++;
-
-    /* Optional minus or plus sign */
-    if ('+' == *s) {
-        s++;
-    }
-    else if ('-' == *s) {
-        sign = -1;
-        s++;
-    }
-
-    /* Zero base prefix */
-    if (0 == base && '0' == *s && ('x' == s[1] || 'X' == s[1])) {
-        base = 16;
-        s += 2;
-    }
-    else if (0 == base && '0' == *s) {
-        base = 8;
-        s++;
-    }
-    else if (0 == base) {
-        base = 10;
-    }
-
-    /* Digits */
-    while ((base <= 10 && *s >= '0' && *s < '0' + base) ||
-           (base > 10 && ((*s >= '0' && *s <= '9') || (*s >= 'a' && *s < 'a' + base - 10) ||
-                          (*s >= 'A' && *s < 'A' + base - 10)))) {
-        if (!overflow) {
-            int64_t digit = 0;
-
-            if (*s >= '0' && *s <= '9')
-                digit = *s - '0';
-            else if (*s >= 'a' && *s <= 'z')
-                digit = (*s - 'a') + 10;
-            else
-                digit = (*s - 'A') + 10;
-
-            if (acc * base + digit < acc) {
-                overflow = TRUE;
-            }
-            else {
-                acc = acc * base + digit;
-            }
-        }
-        s++;
-    }
-
-    /* Overflow */
-    if (overflow) {
-        if (sign > 0) {
-            acc = ((uint64_t)1 << (8 * sizeof(int64_t) - 1)) - 1;
-        }
-        else {
-            acc = (int64_t)((uint64_t)1 << (8 * sizeof(int64_t) - 1));
-        }
-        errno = ERANGE;
-    }
-
-    /* Return values */
-    acc *= sign;
-    if (rest)
-        *rest = s;
-    return acc;
-} /* end HDstrtoll() */
-#endif
-
-/*-------------------------------------------------------------------------
  * Function:  HDrand/HDsrand
  *
  * Purpose:  Wrapper function for rand.  If rand_r exists on this system,
@@ -1201,3 +1076,167 @@ done:
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5_basename() */
+
+/* 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;
+}