1.12 Tools merges from develop (#949)

* Tools merges from develop

Brings the tools getopt(3) replacement into the main library (#803)
Perform option arg variables (#834)
Removes unused commented-out code from h5jamgentest.c (#851)
Reorg tools perform to provide h5perf for installation (#884)

* Fix missing files

* Remove empty files

* Remove empty file

* Resync defines

* Fix endif typo

* Add Makfile to list

* Fix typo

* Remove H5_GCC_DIAG_ON line to match removal of H5_GCC_DIAG_OFF line in
sio_engine.c/

Co-authored-by: Dana Robinson <43805+derobins@users.noreply.github.com>
Co-authored-by: Larry Knox <lrknox@hdfgroup.org>

3 files changed, 711 insertions, 460 deletions

diff --git a/src/H5private.h b/src/H5private.h
index ec33898..c9b4ab3 100644
--- a/src/H5private.h
+++ b/src/H5private.h
@@ -58,10 +58,10 @@
 #include <string.h>
 #endif
 
-/*
- * If _POSIX_VERSION is defined in unistd.h then this system is Posix.1
- * compliant. Otherwise all bets are off.
- */
+/* POSIX headers */
+#ifdef H5_HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
 #ifdef H5_HAVE_UNISTD_H
 #ifdef H5_HAVE_PWD_H
 #include <pwd.h>
@@ -84,9 +84,9 @@
 #endif
 
 /*
- * The `struct stat' data type for stat() and fstat(). This is a Posix file
- * but often apears on non-Posix systems also.  The `struct stat' is required
- * for hdf5 to compile, although only a few fields are actually used.
+ * The `struct stat' data type for stat() and fstat(). This is a POSIX file
+ * but often apears on non-POSIX systems also.  The `struct stat' is required
+ * for HDF5 to compile, although only a few fields are actually used.
  */
 #ifdef H5_HAVE_SYS_STAT_H
 #include <sys/stat.h>
@@ -176,10 +176,14 @@
 #define H5_DEFAULT_VOL H5VL_NATIVE
 
 #ifdef H5_HAVE_WIN32_API
+
 /* The following two defines must be before any windows headers are included */
 #define WIN32_LEAN_AND_MEAN /* Exclude rarely-used stuff from Windows headers */
 #define NOGDI               /* Exclude Graphic Display Interface macros */
 
+#include <windows.h>
+
+#include <direct.h> /* For _getcwd() */
 #ifdef H5_HAVE_WINSOCK2_H
 #include <winsock2.h>
 #endif
@@ -188,9 +192,6 @@
 #include <process.h> /* For _beginthread() */
 #endif
 
-#include <windows.h>
-#include <direct.h> /* For _getcwd() */
-
 #endif /*H5_HAVE_WIN32_API*/
 
 #ifndef F_OK
@@ -636,228 +637,245 @@ typedef struct {
     haddr_t       addr;   /* The unique address of the object's header in that file */
 } H5_obj_t;
 
-/*
- * Redefine all the POSIX functions.  We should never see a POSIX
- * function (or any other non-HDF5 function) in the source!
+#define H5_SIZEOF_H5_STAT_SIZE_T H5_SIZEOF_OFF_T
+
+/* Put all Windows-specific definitions in H5win32defs.h so we
+ * can (mostly) assume a POSIX platform. Not all of the POSIX calls
+ * will have a Windows equivalent so some #ifdef protection is still
+ * necessary (e.g., fork()).
+ */
+#include "H5win32defs.h"
+
+/* Platform-independent definitions for struct stat and off_t */
+#ifndef H5_HAVE_WIN32_API
+/* These definitions differ in Windows and are defined in
+ * H5win32defs for that platform.
  */
+typedef struct stat h5_stat_t;
+typedef off_t       h5_stat_size_t;
+#define HDoff_t off_t
+#endif
 
-/* Put all platform-specific definitions in the following file */
-/* so that the following definitions are platform free. */
-#include "H5win32defs.h" /* For Windows-specific definitions */
+/* Redefine all the POSIX and C functions.  We should never see an
+ * undecorated POSIX or C function (or any other non-HDF5 function)
+ * in the source.
+ */
 
 #ifndef HDabort
 #define HDabort() abort()
-#endif /* HDabort */
+#endif
 #ifndef HDabs
 #define HDabs(X) abs(X)
-#endif /* HDabs */
+#endif
 #ifndef HDaccept
-#define HDaccept(A, B, C) accept((A), (B), (C)) /* mirror VFD */
-#endif                                          /* HDaccept */
+#define HDaccept(A, B, C) accept((A), (B), (C))
+#endif
 #ifndef HDaccess
 #define HDaccess(F, M) access(F, M)
-#endif /* HDaccess */
+#endif
 #ifndef HDacos
 #define HDacos(X) acos(X)
-#endif /* HDacos */
+#endif
 #ifndef HDalarm
 #ifdef H5_HAVE_ALARM
 #define HDalarm(N) alarm(N)
-#else /* H5_HAVE_ALARM */
+#else
 #define HDalarm(N) (0)
-#endif /* H5_HAVE_ALARM */
-#endif /* HDalarm */
+#endif
+#endif
 #ifndef HDasctime
 #define HDasctime(T) asctime(T)
-#endif /* HDasctime */
+#endif
 #ifndef HDasin
 #define HDasin(X) asin(X)
-#endif /* HDasin */
+#endif
 #ifndef HDasprintf
 #define HDasprintf asprintf /*varargs*/
-#endif                      /* HDasprintf */
+#endif
 #ifndef HDassert
 #define HDassert(X) assert(X)
-#endif /* HDassert */
+#endif
 #ifndef HDatan
 #define HDatan(X) atan(X)
-#endif /* HDatan */
+#endif
 #ifndef HDatan2
 #define HDatan2(X, Y) atan2(X, Y)
-#endif /* HDatan2 */
+#endif
 #ifndef HDatexit
 #define HDatexit(F) atexit(F)
-#endif /* HDatexit */
+#endif
 #ifndef HDatof
 #define HDatof(S) atof(S)
-#endif /* HDatof */
+#endif
 #ifndef HDatoi
 #define HDatoi(S) atoi(S)
-#endif /* HDatoi */
+#endif
 #ifndef HDatol
 #define HDatol(S) atol(S)
-#endif /* HDatol */
+#endif
 #ifndef HDatoll
 #define HDatoll(S) atoll(S)
-#endif /* HDatol */
+#endif
 #ifndef HDbind
-#define HDbind(A, B, C) bind((A), (B), (C)) /* mirror VFD */
-#endif                                      /* HDbind */
+#define HDbind(A, B, C) bind((A), (B), (C))
+#endif
 #ifndef HDbsearch
 #define HDbsearch(K, B, N, Z, F) bsearch(K, B, N, Z, F)
-#endif /* HDbsearch */
+#endif
 #ifndef HDcalloc
 #define HDcalloc(N, Z) calloc(N, Z)
-#endif /* HDcalloc */
+#endif
 #ifndef HDceil
 #define HDceil(X) ceil(X)
-#endif /* HDceil */
+#endif
 #ifndef HDcfgetispeed
 #define HDcfgetispeed(T) cfgetispeed(T)
-#endif /* HDcfgetispeed */
+#endif
 #ifndef HDcfgetospeed
 #define HDcfgetospeed(T) cfgetospeed(T)
-#endif /* HDcfgetospeed */
+#endif
 #ifndef HDcfsetispeed
 #define HDcfsetispeed(T, S) cfsetispeed(T, S)
-#endif /* HDcfsetispeed */
+#endif
 #ifndef HDcfsetospeed
 #define HDcfsetospeed(T, S) cfsetospeed(T, S)
-#endif /* HDcfsetospeed */
+#endif
 #ifndef HDchdir
 #define HDchdir(S) chdir(S)
-#endif /* HDchdir */
+#endif
 #ifndef HDchmod
 #define HDchmod(S, M) chmod(S, M)
-#endif /* HDchmod */
+#endif
 #ifndef HDchown
 #define HDchown(S, O, G) chown(S, O, G)
-#endif /* HDchown */
+#endif
 #ifndef HDclearerr
 #define HDclearerr(F) clearerr(F)
-#endif /* HDclearerr */
+#endif
 #ifndef HDclock
 #define HDclock() clock()
-#endif /* HDclock */
+#endif
 #ifndef HDclock_gettime
 #define HDclock_gettime(CID, TS) clock_gettime(CID, TS)
-#endif /* HDclock_gettime */
+#endif
 #ifndef HDclose
 #define HDclose(F) close(F)
-#endif /* HDclose */
+#endif
 #ifndef HDclosedir
 #define HDclosedir(D) closedir(D)
-#endif /* HDclosedir */
+#endif
 #ifndef HDconnect
-#define HDconnect(A, B, C) connect((A), (B), (C)) /* mirror VFD */
-#endif                                            /* HDconnect */
+#define HDconnect(A, B, C) connect((A), (B), (C))
+#endif
 #ifndef HDcos
 #define HDcos(X) cos(X)
-#endif /* HDcos */
+#endif
 #ifndef HDcosh
 #define HDcosh(X) cosh(X)
-#endif /* HDcosh */
+#endif
 #ifndef HDcreat
 #define HDcreat(S, M) creat(S, M)
-#endif /* HDcreat */
+#endif
 #ifndef HDctermid
 #define HDctermid(S) ctermid(S)
-#endif /* HDctermid */
+#endif
 #ifndef HDctime
 #define HDctime(T) ctime(T)
-#endif /* HDctime */
+#endif
 #ifndef HDcuserid
 #define HDcuserid(S) cuserid(S)
-#endif /* HDcuserid */
+#endif
 #ifndef HDdifftime
 #ifdef H5_HAVE_DIFFTIME
 #define HDdifftime(X, Y) difftime(X, Y)
-#else /* H5_HAVE_DIFFTIME */
+#else
 #define HDdifftime(X, Y) ((double)(X) - (double)(Y))
-#endif /* H5_HAVE_DIFFTIME */
-#endif /* HDdifftime */
+#endif
+#endif
 #ifndef HDdiv
 #define HDdiv(X, Y) div(X, Y)
-#endif /* HDdiv */
+#endif
 #ifndef HDdup
 #define HDdup(F) dup(F)
-#endif /* HDdup */
+#endif
 #ifndef HDdup2
 #define HDdup2(F, I) dup2(F, I)
-#endif /* HDdup2 */
+#endif
 /* execl() variable arguments */
 /* execle() variable arguments */
 /* execlp() variable arguments */
 #ifndef HDexecv
 #define HDexecv(S, AV) execv(S, AV)
-#endif /* HDexecv */
+#endif
 #ifndef HDexecve
 #define HDexecve(S, AV, E) execve(S, AV, E)
-#endif /* HDexecve */
+#endif
 #ifndef HDexecvp
 #define HDexecvp(S, AV) execvp(S, AV)
-#endif /* HDexecvp */
+#endif
 #ifndef HDexit
 #define HDexit(N) exit(N)
-#endif /* HDexit */
+#endif
 #ifndef HD_exit
 #define HD_exit(N) _exit(N)
-#endif /* HD_exit */
+#endif
 #ifndef HDexp
 #define HDexp(X) exp(X)
-#endif /* HDexp */
+#endif
 #ifndef HDexp2
 #define HDexp2(X) exp2(X)
-#endif /* HDexp2 */
+#endif
 #ifndef HDfabs
 #define HDfabs(X) fabs(X)
-#endif /* HDfabs */
+#endif
 /* use ABS() because fabsf() fabsl() are not common yet. */
 #ifndef HDfabsf
 #define HDfabsf(X) ABS(X)
-#endif /* HDfabsf */
+#endif
 #ifndef HDfabsl
 #define HDfabsl(X) ABS(X)
-#endif /* HDfabsl */
+#endif
 #ifndef HDfclose
 #define HDfclose(F) fclose(F)
-#endif /* HDfclose */
+#endif
 #ifdef H5_HAVE_FCNTL
 #ifndef HDfcntl
 #define HDfcntl(F, C, ...) fcntl(F, C, __VA_ARGS__)
-#endif /* HDfcntl */
-#endif /* H5_HAVE_FCNTL */
+#endif
+#endif
 #ifndef HDfdopen
 #define HDfdopen(N, S) fdopen(N, S)
-#endif /* HDfdopen */
+#endif
 #ifndef HDfeof
 #define HDfeof(F) feof(F)
-#endif /* HDfeof */
+#endif
 #ifndef HDferror
 #define HDferror(F) ferror(F)
-#endif /* HDferror */
+#endif
 #ifndef HDfflush
 #define HDfflush(F) fflush(F)
-#endif /* HDfflush */
+#endif
 #ifndef HDfgetc
 #define HDfgetc(F) fgetc(F)
-#endif /* HDfgetc */
+#endif
 #ifndef HDfgetpos
 #define HDfgetpos(F, P) fgetpos(F, P)
-#endif /* HDfgetpos */
+#endif
 #ifndef HDfgets
 #define HDfgets(S, N, F) fgets(S, N, F)
-#endif /* HDfgets */
+#endif
 #ifndef HDfileno
 #define HDfileno(F) fileno(F)
-#endif /* HDfileno */
+#endif
+
 /* Since flock is so prevalent, always build these functions
  * when possible to avoid them becoming dead code.
  */
 #ifdef H5_HAVE_FCNTL
 H5_DLL int Pflock(int fd, int operation);
-#endif /* H5_HAVE_FCNTL */
+#endif
 H5_DLL H5_ATTR_CONST int Nflock(int fd, int operation);
+
 #ifndef HDflock
 /* NOTE: flock(2) is not present on all POSIX systems.
  * If it is not present, we try a flock() equivalent based on
@@ -871,760 +889,764 @@ H5_DLL H5_ATTR_CONST int Nflock(int fd, int operation);
 #define HDflock(F, L) Pflock(F, L)
 #else
 #define HDflock(F, L) Nflock(F, L)
-#endif /* H5_HAVE_FLOCK */
+#endif
+
 #endif /* HDflock */
+
 #ifndef HDfloor
 #define HDfloor(X) floor(X)
-#endif /* HDfloor */
+#endif
 #ifndef HDfmod
 #define HDfmod(X, Y) fmod(X, Y)
-#endif /* HDfmod */
+#endif
 #ifndef HDfopen
 #define HDfopen(S, M) fopen(S, M)
-#endif /* HDfopen */
+#endif
 #ifndef HDfork
 #define HDfork() fork()
-#endif /* HDfork */
+#endif
 #ifndef HDfprintf
 #define HDfprintf fprintf
 #endif
 #ifndef HDfpathconf
 #define HDfpathconf(F, N) fpathconf(F, N)
-#endif /* HDfpathconf */
+#endif
 #ifndef HDfputc
 #define HDfputc(C, F) fputc(C, F)
-#endif /* HDfputc */
+#endif
 #ifndef HDfputs
 #define HDfputs(S, F) fputs(S, F)
-#endif /* HDfputs */
+#endif
 #ifndef HDfread
 #define HDfread(M, Z, N, F) fread(M, Z, N, F)
-#endif /* HDfread */
+#endif
 #ifndef HDfree
 #define HDfree(M) free(M)
-#endif /* HDfree */
+#endif
 #ifndef HDfreopen
 #define HDfreopen(S, M, F) freopen(S, M, F)
-#endif /* HDfreopen */
+#endif
 #ifndef HDfrexp
 #define HDfrexp(X, N) frexp(X, N)
-#endif /* HDfrexp */
+#endif
 /* Check for Cray-specific 'frexpf()' and 'frexpl()' routines */
 #ifndef HDfrexpf
 #ifdef H5_HAVE_FREXPF
 #define HDfrexpf(X, N) frexpf(X, N)
-#else /* H5_HAVE_FREXPF */
+#else
 #define HDfrexpf(X, N) frexp(X, N)
-#endif /* H5_HAVE_FREXPF */
-#endif /* HDfrexpf */
+#endif
+#endif
 #ifndef HDfrexpl
 #ifdef H5_HAVE_FREXPL
 #define HDfrexpl(X, N) frexpl(X, N)
-#else /* H5_HAVE_FREXPL */
+#else
 #define HDfrexpl(X, N) frexp(X, N)
-#endif /* H5_HAVE_FREXPL */
-#endif /* HDfrexpl */
-/* fscanf() variable arguments */
+#endif
+#endif
+#ifndef HDfscanf
+#define HDfscanf fscanf
+#endif
 #ifndef HDfseek
 #define HDfseek(F, O, W) fseeko(F, O, W)
-#endif /* HDfseek */
+#endif
 #ifndef HDfsetpos
 #define HDfsetpos(F, P) fsetpos(F, P)
-#endif /* HDfsetpos */
+#endif
 #ifndef HDfstat
 #define HDfstat(F, B) fstat(F, B)
-#endif /* HDfstat */
-#ifndef HDlstat
-#define HDlstat(S, B) lstat(S, B)
-#endif /* HDlstat */
-#ifndef HDstat
-#define HDstat(S, B) stat(S, B)
-#endif /* HDstat */
-
-#ifndef H5_HAVE_WIN32_API
-/* These definitions differ in Windows and are defined in
- * H5win32defs for that platform.
- */
-typedef struct stat h5_stat_t;
-typedef off_t       h5_stat_size_t;
-#define HDoff_t off_t
-#endif /* H5_HAVE_WIN32_API */
-
-#define H5_SIZEOF_H5_STAT_SIZE_T H5_SIZEOF_OFF_T
-
+#endif
 #ifndef HDftell
 #define HDftell(F) ftell(F)
-#endif /* HDftell */
+#endif
 #ifndef HDftruncate
 #define HDftruncate(F, L) ftruncate(F, L)
-#endif /* HDftruncate */
+#endif
 #ifndef HDfwrite
 #define HDfwrite(M, Z, N, F) fwrite(M, Z, N, F)
-#endif /* HDfwrite */
+#endif
 #ifndef HDgetc
 #define HDgetc(F) getc(F)
-#endif /* HDgetc */
+#endif
 #ifndef HDgetchar
 #define HDgetchar() getchar()
-#endif /* HDgetchar */
+#endif
 #ifndef HDgetcwd
 #define HDgetcwd(S, Z) getcwd(S, Z)
-#endif /* HDgetcwd */
+#endif
 #ifndef HDgetdcwd
 #define HDgetdcwd(D, S, Z) getcwd(S, Z)
-#endif /* HDgetdcwd */
+#endif
+
+/* Windows only - set to zero on other systems */
 #ifndef HDgetdrive
 #define HDgetdrive() 0
-#endif /* HDgetdrive */
+#endif
+
 #ifndef HDgetegid
 #define HDgetegid() getegid()
-#endif /* HDgetegid() */
+#endif
 #ifndef HDgetenv
 #define HDgetenv(S) getenv(S)
-#endif /* HDgetenv */
+#endif
 #ifndef HDgeteuid
 #define HDgeteuid() geteuid()
-#endif /* HDgeteuid */
+#endif
 #ifndef HDgetgid
 #define HDgetgid() getgid()
-#endif /* HDgetgid */
+#endif
 #ifndef HDgetgrgid
 #define HDgetgrgid(G) getgrgid(G)
-#endif /* HDgetgrgid */
+#endif
 #ifndef HDgetgrnam
 #define HDgetgrnam(S) getgrnam(S)
-#endif /* HDgetgrnam */
+#endif
 #ifndef HDgetgroups
 #define HDgetgroups(Z, G) getgroups(Z, G)
-#endif /* HDgetgroups */
+#endif
 #ifndef HDgethostbyaddr
-#define HDgethostbyaddr(A, B, C) gethostbyaddr((A), (B), (C)) /* mirror VFD */
-#endif                                                        /* HDgethostbyaddr */
+#define HDgethostbyaddr(A, B, C) gethostbyaddr((A), (B), (C))
+#endif
 #ifndef HDgethostname
 #define HDgethostname(N, L) gethostname(N, L)
-#endif /* HDgethostname */
+#endif
 #ifndef HDgetlogin
 #define HDgetlogin() getlogin()
-#endif /* HDgetlogin */
+#endif
 #ifndef HDgetpgrp
 #define HDgetpgrp() getpgrp()
-#endif /* HDgetpgrp */
+#endif
 #ifndef HDgetpid
 #define HDgetpid() getpid()
-#endif /* HDgetpid */
+#endif
 #ifndef HDgetppid
 #define HDgetppid() getppid()
-#endif /* HDgetppid */
+#endif
 #ifndef HDgetpwnam
 #define HDgetpwnam(S) getpwnam(S)
-#endif /* HDgetpwnam */
+#endif
 #ifndef HDgetpwuid
 #define HDgetpwuid(U) getpwuid(U)
-#endif /* HDgetpwuid */
+#endif
 #ifndef HDgetrusage
 #define HDgetrusage(X, S) getrusage(X, S)
-#endif /* HDgetrusage */
+#endif
 
 /* Don't define HDgets - gets() was deprecated in C99 and removed in C11 */
 #ifdef HDgets
 #undef HDgets
-#endif /* HDgets */
+#endif
 
 #ifndef HDgettimeofday
 #define HDgettimeofday(S, P) gettimeofday(S, P)
-#endif /* HDgettimeofday */
+#endif
 #ifndef HDgetuid
 #define HDgetuid() getuid()
-#endif /* HDgetuid */
+#endif
 #ifndef HDgmtime
 #define HDgmtime(T) gmtime(T)
-#endif /* HDgmtime */
+#endif
 #ifndef HDhtonl
-#define HDhtonl(X) htonl((X)) /* mirror VFD */
-#endif                        /* HDhtonl */
+#define HDhtonl(X) htonl((X))
+#endif
 #ifndef HDhtons
-#define HDhtons(X) htons((X)) /* mirror VFD */
-#endif                        /* HDhtons */
+#define HDhtons(X) htons((X))
+#endif
 #ifndef HDinet_addr
-#define HDinet_addr(C) inet_addr((C)) /* mirror VFD */
-#endif                                /* HDinet_addr */
+#define HDinet_addr(C) inet_addr((C))
+#endif
 #ifndef HDinet_ntoa
-#define HDinet_ntoa(C) inet_ntoa((C)) /* mirror VFD */
-#endif                                /* HDinet_ntoa */
+#define HDinet_ntoa(C) inet_ntoa((C))
+#endif
 #ifndef HDisalnum
-#define HDisalnum(C) isalnum((int)(C)) /*cast for solaris warning*/
-#endif                                 /* HDisalnum */
+#define HDisalnum(C) isalnum((int)(C)) /* Cast for Solaris warning */
+#endif
 #ifndef HDisalpha
-#define HDisalpha(C) isalpha((int)(C)) /*cast for solaris warning*/
-#endif                                 /* HDisalpha */
+#define HDisalpha(C) isalpha((int)(C)) /* Cast for Solaris warning */
+#endif
 #ifndef HDisatty
 #define HDisatty(F) isatty(F)
-#endif /* HDisatty */
+#endif
 #ifndef HDiscntrl
-#define HDiscntrl(C) iscntrl((int)(C)) /*cast for solaris warning*/
-#endif                                 /* HDiscntrl */
+#define HDiscntrl(C) iscntrl((int)(C)) /* Cast for solaris warning */
+#endif
 #ifndef HDisdigit
-#define HDisdigit(C) isdigit((int)(C)) /*cast for solaris warning*/
-#endif                                 /* HDisdigit */
+#define HDisdigit(C) isdigit((int)(C)) /* Cast for Solaris warning */
+#endif
 #ifndef HDisgraph
-#define HDisgraph(C) isgraph((int)(C)) /*cast for solaris warning*/
-#endif                                 /* HDisgraph */
+#define HDisgraph(C) isgraph((int)(C)) /* Cast for Solaris warning*/
+#endif
 #ifndef HDislower
-#define HDislower(C) islower((int)(C)) /*cast for solaris warning*/
-#endif                                 /* HDislower */
+#define HDislower(C) islower((int)(C)) /* Cast for Solaris warning */
+#endif
 #ifndef HDisnan
 #define HDisnan(X) isnan(X)
-#endif /* HDisnan */
+#endif
 #ifndef HDisprint
-#define HDisprint(C) isprint((int)(C)) /*cast for solaris warning*/
-#endif                                 /* HDisprint */
+#define HDisprint(C) isprint((int)(C)) /* Cast for Solaris warning */
+#endif
 #ifndef HDispunct
-#define HDispunct(C) ispunct((int)(C)) /*cast for solaris warning*/
-#endif                                 /* HDispunct */
+#define HDispunct(C) ispunct((int)(C)) /* Cast for Solaris warning */
+#endif
 #ifndef HDisspace
-#define HDisspace(C) isspace((int)(C)) /*cast for solaris warning*/
-#endif                                 /* HDisspace */
+#define HDisspace(C) isspace((int)(C)) /* Cast for Solaris warning */
+#endif
 #ifndef HDisupper
-#define HDisupper(C) isupper((int)(C)) /*cast for solaris warning*/
-#endif                                 /* HDisupper */
+#define HDisupper(C) isupper((int)(C)) /* Cast for Solaris warning */
+#endif
 #ifndef HDisxdigit
-#define HDisxdigit(C) isxdigit((int)(C)) /*cast for solaris warning*/
-#endif                                   /* HDisxdigit */
+#define HDisxdigit(C) isxdigit((int)(C)) /* Cast for Solaris warning */
+#endif
 #ifndef HDkill
 #define HDkill(P, S) kill(P, S)
-#endif /* HDkill */
+#endif
 #ifndef HDlabs
 #define HDlabs(X) labs(X)
-#endif /* HDlabs */
+#endif
 #ifndef HDldexp
 #define HDldexp(X, N) ldexp(X, N)
-#endif /* HDldexp */
+#endif
 #ifndef HDldiv
 #define HDldiv(X, Y) ldiv(X, Y)
-#endif /* HDldiv */
+#endif
 #ifndef HDlink
 #define HDlink(OLD, NEW) link(OLD, NEW)
-#endif /* HDlink */
+#endif
 #ifndef HDlisten
-#define HDlisten(A, B) listen((A), (B)) /* mirror VFD */
-#endif                                  /* HDlisten */
+#define HDlisten(A, B) listen((A), (B))
+#endif
 #ifndef HDllround
 #define HDllround(V) llround(V)
-#endif /* HDround */
+#endif
 #ifndef HDllroundf
 #define HDllroundf(V) llroundf(V)
-#endif /* HDllroundf */
+#endif
 #ifndef HDllroundl
 #define HDllroundl(V) llroundl(V)
-#endif /* HDllroundl */
+#endif
 #ifndef HDlocaleconv
 #define HDlocaleconv() localeconv()
-#endif /* HDlocaleconv */
+#endif
 #ifndef HDlocaltime
 #define HDlocaltime(T) localtime(T)
-#endif /* HDlocaltime */
+#endif
 #ifndef HDlog
 #define HDlog(X) log(X)
-#endif /* HDlog */
+#endif
 #ifndef HDlog10
 #define HDlog10(X) log10(X)
-#endif /* HDlog10 */
+#endif
 #ifndef HDlongjmp
 #define HDlongjmp(J, N) longjmp(J, N)
-#endif /* HDlongjmp */
+#endif
 #ifndef HDlround
 #define HDlround(V) lround(V)
-#endif /* HDround */
+#endif
 #ifndef HDlroundf
 #define HDlroundf(V) lroundf(V)
-#endif /* HDlroundf */
+#endif
 #ifndef HDlroundl
 #define HDlroundl(V) lroundl(V)
-#endif /* HDroundl */
+#endif
 #ifndef HDlseek
 #define HDlseek(F, O, W) lseek(F, O, W)
-#endif /* HDlseek */
+#endif
+#ifndef HDlstat
+#define HDlstat(S, B) lstat(S, B)
+#endif
 #ifndef HDmalloc
 #define HDmalloc(Z) malloc(Z)
-#endif /* HDmalloc */
+#endif
 #ifndef HDposix_memalign
 #define HDposix_memalign(P, A, Z) posix_memalign(P, A, Z)
-#endif /* HDposix_memalign */
+#endif
 #ifndef HDmblen
 #define HDmblen(S, N) mblen(S, N)
-#endif /* HDmblen */
+#endif
 #ifndef HDmbstowcs
 #define HDmbstowcs(P, S, Z) mbstowcs(P, S, Z)
-#endif /* HDmbstowcs */
+#endif
 #ifndef HDmbtowc
 #define HDmbtowc(P, S, Z) mbtowc(P, S, Z)
-#endif /* HDmbtowc */
+#endif
 #ifndef HDmemchr
 #define HDmemchr(S, C, Z) memchr(S, C, Z)
-#endif /* HDmemchr */
+#endif
 #ifndef HDmemcmp
 #define HDmemcmp(X, Y, Z) memcmp(X, Y, Z)
-#endif /* HDmemcmp */
+#endif
 #ifndef HDmemcpy
 #define HDmemcpy(X, Y, Z) memcpy(X, Y, Z)
-#endif /* HDmemcpy */
+#endif
 #ifndef HDmemmove
 #define HDmemmove(X, Y, Z) memmove((char *)(X), (const char *)(Y), Z)
-#endif /* HDmemmove */
+#endif
 #ifndef HDmemset
 #define HDmemset(X, C, Z) memset(X, C, Z)
-#endif /* HDmemset */
+#endif
 #ifndef HDmkdir
 #define HDmkdir(S, M) mkdir(S, M)
-#endif /* HDmkdir */
+#endif
 #ifndef HDmkfifo
 #define HDmkfifo(S, M) mkfifo(S, M)
-#endif /* HDmkfifo */
+#endif
 #ifndef HDmktime
 #define HDmktime(T) mktime(T)
-#endif /* HDmktime */
+#endif
 #ifndef HDmodf
 #define HDmodf(X, Y) modf(X, Y)
-#endif /* HDmodf */
+#endif
 #ifndef HDnanosleep
 #define HDnanosleep(N, O) nanosleep(N, O)
-#endif /* HDnanosleep */
+#endif
 #ifndef HDntohl
-#define HDntohl(A) ntohl((A)) /* mirror VFD */
-#endif                        /* HDntohl */
+#define HDntohl(A) ntohl((A))
+#endif
 #ifndef HDntohs
-#define HDntohs(A) ntohs((A)) /* mirror VFD */
-#endif                        /* HDntohs */
+#define HDntohs(A) ntohs((A))
+#endif
 #ifndef HDopen
 #define HDopen(F, ...) open(F, __VA_ARGS__)
-#endif /* HDopen */
+#endif
 #ifndef HDopendir
 #define HDopendir(S) opendir(S)
-#endif /* HDopendir */
+#endif
 #ifndef HDpathconf
 #define HDpathconf(S, N) pathconf(S, N)
-#endif /* HDpathconf */
+#endif
 #ifndef HDpause
 #define HDpause() pause()
-#endif /* HDpause */
+#endif
 #ifndef HDperror
 #define HDperror(S) perror(S)
-#endif /* HDperror */
+#endif
 #ifndef HDpipe
 #define HDpipe(F) pipe(F)
-#endif /* HDpipe */
+#endif
 #ifndef HDpow
 #define HDpow(X, Y) pow(X, Y)
-#endif /* HDpow */
+#endif
 #ifndef HDpowf
 #define HDpowf(X, Y) powf(X, Y)
-#endif /* HDpowf */
+#endif
 #ifndef HDpread
 #define HDpread(F, B, C, O) pread(F, B, C, O)
-#endif /* HDpread */
+#endif
 #ifndef HDprintf
-#define HDprintf printf
-#endif /* HDprintf */
+#define HDprintf printf /*varargs*/
+#endif
 #ifndef HDputc
 #define HDputc(C, F) putc(C, F)
-#endif /* HDputc*/
+#endif
 #ifndef HDputchar
 #define HDputchar(C) putchar(C)
-#endif /* HDputchar */
+#endif
 #ifndef HDputs
 #define HDputs(S) puts(S)
-#endif /* HDputs */
+#endif
 #ifndef HDpwrite
 #define HDpwrite(F, B, C, O) pwrite(F, B, C, O)
-#endif /* HDpwrite */
+#endif
 #ifndef HDqsort
 #define HDqsort(M, N, Z, F) qsort(M, N, Z, F)
-#endif /* HDqsort*/
+#endif
 #ifndef HDraise
 #define HDraise(N) raise(N)
-#endif /* HDraise */
+#endif
 
+/* clang-format off */
 #ifdef H5_HAVE_RAND_R
-#ifndef HDrandom
-#define HDrandom() HDrand()
-#endif /* HDrandom */
-H5_DLL int HDrand(void);
-#ifndef HDsrandom
-#define HDsrandom(S) HDsrand(S)
-#endif /* HDsrandom */
-H5_DLL void HDsrand(unsigned int seed);
+#   ifndef HDrandom
+#   define HDrandom() HDrand()
+#   endif
+    H5_DLL int HDrand(void);
+#   ifndef HDsrandom
+#   define HDsrandom(S) HDsrand(S)
+#   endif
+    H5_DLL void HDsrand(unsigned int seed);
 #elif defined(H5_HAVE_RANDOM)
-#ifndef HDrand
-#define HDrand() random()
-#endif /* HDrand */
-#ifndef HDrandom
-#define HDrandom() random()
-#endif /* HDrandom */
-#ifndef HDsrand
-#define HDsrand(S) srandom(S)
-#endif /* HDsrand */
-#ifndef HDsrandom
-#define HDsrandom(S) srandom(S)
-#endif /* HDsrandom */
-#else  /* H5_HAVE_RANDOM */
-#ifndef HDrand
-#define HDrand() rand()
-#endif /* HDrand */
-#ifndef HDrandom
-#define HDrandom() rand()
-#endif /* HDrandom */
-#ifndef HDsrand
-#define HDsrand(S) srand(S)
-#endif /* HDsrand */
-#ifndef HDsrandom
-#define HDsrandom(S) srand(S)
-#endif /* HDsrandom */
-#endif /* H5_HAVE_RANDOM */
+#   ifndef HDrand
+#   define HDrand() random()
+#   endif
+#   ifndef HDrandom
+#   define HDrandom() random()
+#   endif
+#   ifndef HDsrand
+#   define HDsrand(S) srandom(S)
+#   endif
+#   ifndef HDsrandom
+#   define HDsrandom(S) srandom(S)
+#   endif
+#else
+#   ifndef HDrand
+#   define HDrand() rand()
+#   endif
+#   ifndef HDrandom
+#   define HDrandom() rand()
+#   endif
+#   ifndef HDsrand
+#   define HDsrand(S) srand(S)
+#   endif
+#   ifndef HDsrandom
+#   define HDsrandom(S) srand(S)
+#   endif
+#endif
+/* clang-format on */
 
 #ifndef HDread
 #define HDread(F, M, Z) read(F, M, Z)
-#endif /* HDread */
+#endif
 #ifndef HDreaddir
 #define HDreaddir(D) readdir(D)
-#endif /* HDreaddir */
+#endif
 #ifndef HDrealloc
 #define HDrealloc(M, Z) realloc(M, Z)
-#endif /* HDrealloc */
+#endif
 #ifndef HDrealpath
 #define HDrealpath(F1, F2) realpath(F1, F2)
-#endif /* HDrealloc */
+#endif
 #ifndef HDremove
 #define HDremove(S) remove(S)
-#endif /* HDremove */
+#endif
 #ifndef HDrename
 #define HDrename(OLD, NEW) rename(OLD, NEW)
-#endif /* HDrename */
+#endif
 #ifndef HDrewind
 #define HDrewind(F) rewind(F)
-#endif /* HDrewind */
+#endif
 #ifndef HDrewinddir
 #define HDrewinddir(D) rewinddir(D)
-#endif /* HDrewinddir */
+#endif
 #ifndef HDround
 #define HDround(V) round(V)
-#endif /* HDround */
+#endif
 #ifndef HDroundf
 #define HDroundf(V) roundf(V)
-#endif /* HDroundf */
+#endif
 #ifndef HDroundl
 #define HDroundl(V) roundl(V)
-#endif /* HDroundl */
+#endif
 #ifndef HDrmdir
 #define HDrmdir(S) rmdir(S)
-#endif /* HDrmdir */
-/* scanf() variable arguments */
+#endif
+#ifndef HDscanf
+#define HDscanf scanf /*varargs*/
+#endif
 #ifndef HDselect
 #define HDselect(N, RD, WR, ER, T) select(N, RD, WR, ER, T)
-#endif /* HDsetbuf */
+#endif
 #ifndef HDsetbuf
 #define HDsetbuf(F, S) setbuf(F, S)
-#endif /* HDsetbuf */
+#endif
 #ifndef HDsetenv
 #define HDsetenv(N, V, O) setenv(N, V, O)
-#endif /* HDsetenv */
+#endif
 #ifndef HDsetgid
 #define HDsetgid(G) setgid(G)
-#endif /* HDsetgid */
+#endif
 #ifndef HDsetjmp
 #define HDsetjmp(J) setjmp(J)
-#endif /* HDsetjmp */
+#endif
 #ifndef HDsetlocale
 #define HDsetlocale(N, S) setlocale(N, S)
-#endif /* HDsetlocale */
+#endif
 #ifndef HDsetpgid
 #define HDsetpgid(P, PG) setpgid(P, PG)
-#endif /* HDsetpgid */
+#endif
 #ifndef HDsetsid
 #define HDsetsid() setsid()
-#endif /* HDsetsid */
+#endif
 #ifndef HDsetsockopt
-#define HDsetsockopt(A, B, C, D, E) setsockopt((A), (B), (C), (D), (E)) /* mirror VFD */
-#endif                                                                  /* HDsetsockopt */
+#define HDsetsockopt(A, B, C, D, E) setsockopt((A), (B), (C), (D), (E))
+#endif
 #ifndef HDsetuid
 #define HDsetuid(U) setuid(U)
-#endif /* HDsetuid */
+#endif
 #ifndef HDsetvbuf
 #define HDsetvbuf(F, S, M, Z) setvbuf(F, S, M, Z)
-#endif /* HDsetvbuf */
+#endif
 #ifndef HDshutdown
-#define HDshutdown(A, B) shutdown((A), (B)) /* mirror VFD */
-#endif                                      /* HDshutdown */
+#define HDshutdown(A, B) shutdown((A), (B))
+#endif
 #ifndef HDsigaction
 #define HDsigaction(S, A, O) sigaction((S), (A), (O))
-#endif /* HDsigaction */
+#endif
 #ifndef HDsigaddset
 #define HDsigaddset(S, N) sigaddset(S, N)
-#endif /* HDsigaddset */
+#endif
 #ifndef HDsigdelset
 #define HDsigdelset(S, N) sigdelset(S, N)
-#endif /* HDsigdelset */
+#endif
 #ifndef HDsigemptyset
 #define HDsigemptyset(S) sigemptyset(S)
-#endif /* HDsigemptyset */
+#endif
 #ifndef HDsigfillset
 #define HDsigfillset(S) sigfillset(S)
-#endif /* HDsigfillset */
+#endif
 #ifndef HDsigismember
 #define HDsigismember(S, N) sigismember(S, N)
-#endif /* HDsigismember */
+#endif
 #ifndef HDsiglongjmp
 #define HDsiglongjmp(J, N) siglongjmp(J, N)
-#endif /* HDsiglongjmp */
+#endif
 #ifndef HDsignal
 #define HDsignal(N, F) signal(N, F)
-#endif /* HDsignal */
+#endif
 #ifndef HDsigpending
 #define HDsigpending(S) sigpending(S)
-#endif /* HDsigpending */
+#endif
 #ifndef HDsigprocmask
 #define HDsigprocmask(H, S, O) sigprocmask(H, S, O)
-#endif /* HDsigprocmask */
+#endif
 #ifndef HDsigsetjmp
 #define HDsigsetjmp(J, N) sigsetjmp(J, N)
-#endif /* HDsigsetjmp */
+#endif
 #ifndef HDsigsuspend
 #define HDsigsuspend(S) sigsuspend(S)
-#endif /* HDsigsuspend */
+#endif
 #ifndef HDsin
 #define HDsin(X) sin(X)
-#endif /* HDsin */
+#endif
 #ifndef HDsinh
 #define HDsinh(X) sinh(X)
-#endif /* HDsinh */
+#endif
 #ifndef HDsleep
 #define HDsleep(N) sleep(N)
-#endif /* HDsleep */
+#endif
 #ifndef HDsnprintf
 #define HDsnprintf snprintf /*varargs*/
-#endif                      /* HDsnprintf */
+#endif
 #ifndef HDsocket
-#define HDsocket(A, B, C) socket((A), (B), (C)) /* mirror VFD */
-#endif                                          /* HDsocket */
+#define HDsocket(A, B, C) socket((A), (B), (C))
+#endif
 #ifndef HDsprintf
 #define HDsprintf sprintf /*varargs*/
-#endif                    /* HDsprintf */
+#endif
 #ifndef HDsqrt
 #define HDsqrt(X) sqrt(X)
-#endif /* HDsqrt */
+#endif
 #ifndef HDsscanf
-#define HDsscanf(S, FMT, ...) sscanf(S, FMT, __VA_ARGS__)
-#endif /* HDsscanf */
+#define HDsscanf sscanf /*varargs*/
+#endif
+#ifndef HDstat
+#define HDstat(S, B) stat(S, B)
+#endif
 #ifndef HDstrcat
 #define HDstrcat(X, Y) strcat(X, Y)
-#endif /* HDstrcat */
+#endif
 #ifndef HDstrchr
 #define HDstrchr(S, C) strchr(S, C)
-#endif /* HDstrchr */
+#endif
 #ifndef HDstrcmp
 #define HDstrcmp(X, Y) strcmp(X, Y)
-#endif /* HDstrcmp */
+#endif
 #ifndef HDstrcasecmp
 #define HDstrcasecmp(X, Y) strcasecmp(X, Y)
-#endif /* HDstrcasecmp */
+#endif
 #ifndef HDstrcoll
 #define HDstrcoll(X, Y) strcoll(X, Y)
-#endif /* HDstrcoll */
+#endif
 #ifndef HDstrcpy
 #define HDstrcpy(X, Y) strcpy(X, Y)
-#endif /* HDstrcpy */
+#endif
 #ifndef HDstrcspn
 #define HDstrcspn(X, Y) strcspn(X, Y)
-#endif /* HDstrcspn */
+#endif
 #ifndef HDstrdup
 #define HDstrdup(S) strdup(S)
-#endif /* HDstrdup */
+#endif
 #ifndef HDstrerror
 #define HDstrerror(N) strerror(N)
-#endif /* HDstrerror */
+#endif
 #ifndef HDstrftime
 #define HDstrftime(S, Z, F, T) strftime(S, Z, F, T)
-#endif /* HDstrftime */
+#endif
 #ifndef HDstrlen
 #define HDstrlen(S) strlen(S)
-#endif /* HDstrlen */
+#endif
 #ifndef HDstrncat
 #define HDstrncat(X, Y, Z) strncat(X, Y, Z)
-#endif /* HDstrncat */
+#endif
 #ifndef HDstrncmp
 #define HDstrncmp(X, Y, Z) strncmp(X, Y, Z)
-#endif /* HDstrncmp */
+#endif
 #ifndef HDstrncpy
 #define HDstrncpy(X, Y, Z) strncpy(X, Y, Z)
-#endif /* HDstrncpy */
+#endif
 #ifndef HDstrpbrk
 #define HDstrpbrk(X, Y) strpbrk(X, Y)
-#endif /* HDstrpbrk */
+#endif
 #ifndef HDstrrchr
 #define HDstrrchr(S, C) strrchr(S, C)
-#endif /* HDstrrchr */
+#endif
 #ifndef HDstrspn
 #define HDstrspn(X, Y) strspn(X, Y)
-#endif /* HDstrspn */
+#endif
 #ifndef HDstrstr
 #define HDstrstr(X, Y) strstr(X, Y)
-#endif /* HDstrstr */
+#endif
 #ifndef HDstrtod
 #define HDstrtod(S, R) strtod(S, R)
-#endif /* HDstrtod */
+#endif
 #ifndef HDstrtok
 #define HDstrtok(X, Y) strtok(X, Y)
-#endif /* HDstrtok */
+#endif
 #ifndef HDstrtok_r
 #define HDstrtok_r(X, Y, Z) strtok_r(X, Y, Z)
-#endif /* HDstrtok */
+#endif
 #ifndef HDstrtol
 #define HDstrtol(S, R, N) strtol(S, R, N)
-#endif /* HDstrtol */
+#endif
 #ifndef HDstrtoll
 #ifdef H5_HAVE_STRTOLL
 #define HDstrtoll(S, R, N) strtoll(S, R, N)
 #else
 H5_DLL int64_t HDstrtoll(const char *s, const char **rest, int base);
-#endif /* H5_HAVE_STRTOLL */
-#endif /* HDstrtoll */
+#endif
+#endif
 #ifndef HDstrtoul
 #define HDstrtoul(S, R, N) strtoul(S, R, N)
-#endif /* HDstrtoul */
+#endif
 #ifndef HDstrtoull
 #define HDstrtoull(S, R, N) strtoull(S, R, N)
-#endif /* HDstrtoul */
+#endif
 #ifndef HDstrtoumax
 #define HDstrtoumax(S, R, N) strtoumax(S, R, N)
-#endif /* HDstrtoumax */
+#endif
 #ifndef HDstrxfrm
 #define HDstrxfrm(X, Y, Z) strxfrm(X, Y, Z)
-#endif /* HDstrxfrm */
+#endif
 #ifdef H5_HAVE_SYMLINK
 #ifndef HDsymlink
 #define HDsymlink(F1, F2) symlink(F1, F2)
-#endif /* HDsymlink */
-#endif /* H5_HAVE_SYMLINK */
+#endif
+#endif
 #ifndef HDsysconf
 #define HDsysconf(N) sysconf(N)
-#endif /* HDsysconf */
+#endif
 #ifndef HDsystem
 #define HDsystem(S) system(S)
-#endif /* HDsystem */
+#endif
 #ifndef HDtan
 #define HDtan(X) tan(X)
-#endif /* HDtan */
+#endif
 #ifndef HDtanh
 #define HDtanh(X) tanh(X)
-#endif /* HDtanh */
+#endif
 #ifndef HDtcdrain
 #define HDtcdrain(F) tcdrain(F)
-#endif /* HDtcdrain */
+#endif
 #ifndef HDtcflow
 #define HDtcflow(F, A) tcflow(F, A)
-#endif /* HDtcflow */
+#endif
 #ifndef HDtcflush
 #define HDtcflush(F, N) tcflush(F, N)
-#endif /* HDtcflush */
+#endif
 #ifndef HDtcgetattr
 #define HDtcgetattr(F, T) tcgetattr(F, T)
-#endif /* HDtcgetattr */
+#endif
 #ifndef HDtcgetpgrp
 #define HDtcgetpgrp(F) tcgetpgrp(F)
-#endif /* HDtcgetpgrp */
+#endif
 #ifndef HDtcsendbreak
 #define HDtcsendbreak(F, N) tcsendbreak(F, N)
-#endif /* HDtcsendbreak */
+#endif
 #ifndef HDtcsetattr
 #define HDtcsetattr(F, O, T) tcsetattr(F, O, T)
-#endif /* HDtcsetattr */
+#endif
 #ifndef HDtcsetpgrp
 #define HDtcsetpgrp(F, N) tcsetpgrp(F, N)
-#endif /* HDtcsetpgrp */
+#endif
 #ifndef HDtime
 #define HDtime(T) time(T)
-#endif /* HDtime */
+#endif
 #ifndef HDtimes
 #define HDtimes(T) times(T)
-#endif /* HDtimes*/
+#endif
 #ifndef HDtmpfile
 #define HDtmpfile() tmpfile()
-#endif /* HDtmpfile */
+#endif
 #ifndef HDtmpnam
 #define HDtmpnam(S) tmpnam(S)
-#endif /* HDtmpnam */
+#endif
 #ifndef HDtolower
 #define HDtolower(C) tolower(C)
-#endif /* HDtolower */
+#endif
 #ifndef HDtoupper
 #define HDtoupper(C) toupper(C)
-#endif /* HDtoupper */
+#endif
 #ifndef HDttyname
 #define HDttyname(F) ttyname(F)
-#endif /* HDttyname */
+#endif
 #ifndef HDtzset
 #define HDtzset() tzset()
-#endif /* HDtzset */
+#endif
 #ifndef HDumask
 #define HDumask(N) umask(N)
-#endif /* HDumask */
+#endif
 #ifndef HDuname
 #define HDuname(S) uname(S)
-#endif /* HDuname */
+#endif
 #ifndef HDungetc
 #define HDungetc(C, F) ungetc(C, F)
-#endif /* HDungetc */
+#endif
 #ifndef HDunlink
 #define HDunlink(S) unlink(S)
-#endif /* HDunlink */
+#endif
+#ifndef HDunsetenv
+#define HDunsetenv(S) unsetenv(S)
+#endif
 #ifndef HDutime
 #define HDutime(S, T) utime(S, T)
-#endif /* HDutime */
+#endif
+
 #ifndef HDvasprintf
 #ifdef H5_HAVE_VASPRINTF
 #define HDvasprintf(RET, FMT, A) vasprintf(RET, FMT, A)
 #else
 H5_DLL int     HDvasprintf(char **bufp, const char *fmt, va_list _ap);
-#endif /* H5_HAVE_VASPRINTF */
-#endif /* HDvasprintf */
+#endif
+#endif
+
 #ifndef HDva_arg
 #define HDva_arg(A, T) va_arg(A, T)
-#endif /* HDva_arg */
+#endif
 #ifndef HDva_copy
 #define HDva_copy(D, S) va_copy(D, S)
-#endif /* HDva_copy */
+#endif
 #ifndef HDva_end
 #define HDva_end(A) va_end(A)
-#endif /* HDva_end */
+#endif
 #ifndef HDva_start
 #define HDva_start(A, P) va_start(A, P)
-#endif /* HDva_start */
+#endif
 #ifndef HDvfprintf
 #define HDvfprintf(F, FMT, A) vfprintf(F, FMT, A)
-#endif /* HDvfprintf */
+#endif
 #ifndef HDvprintf
 #define HDvprintf(FMT, A) vprintf(FMT, A)
-#endif /* HDvprintf */
+#endif
 #ifndef HDvsprintf
 #define HDvsprintf(S, FMT, A) vsprintf(S, FMT, A)
-#endif /* HDvsprintf */
+#endif
 #ifndef HDvsnprintf
 #define HDvsnprintf(S, N, FMT, A) vsnprintf(S, N, FMT, A)
-#endif /* HDvsnprintf */
+#endif
 #ifndef HDwait
 #define HDwait(W) wait(W)
-#endif /* HDwait */
+#endif
 #ifndef HDwaitpid
 #define HDwaitpid(P, W, O) waitpid(P, W, O)
-#endif /* HDwaitpid */
+#endif
 #ifndef HDwcstombs
 #define HDwcstombs(S, P, Z) wcstombs(S, P, Z)
-#endif /* HDwcstombs */
+#endif
 #ifndef HDwctomb
 #define HDwctomb(S, C) wctomb(S, C)
-#endif /* HDwctomb */
+#endif
 #ifndef HDwrite
 #define HDwrite(F, M, Z) write(F, M, Z)
-#endif /* HDwrite */
+#endif
 
 /* Macro for "stringizing" an integer in the C preprocessor (use H5_TOSTRING) */
 /* (use H5_TOSTRING, H5_STRINGIZE is just part of the implementation) */
@@ -2009,7 +2031,8 @@ typedef struct H5_api_struct {
 
 /* Macros for thread cancellation-safe mechanism */
 #define H5_API_UNSET_CANCEL H5TS_cancel_count_inc();
-#define H5_API_SET_CANCEL   H5TS_cancel_count_dec();
+
+#define H5_API_SET_CANCEL H5TS_cancel_count_dec();
 
 extern H5_api_t H5_g;
 
@@ -2569,6 +2592,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 144e0bc..5cbc480 100644
--- a/src/H5system.c
+++ b/src/H5system.c
@@ -460,6 +460,9 @@ Wgettimeofday(struct timeval *tv, struct timezone *tz)
  *              Interestingly, getenv *is* available in the Windows
  *              POSIX layer, just not setenv.
  *
+ * Note:        Passing an empty string ("") for the value will remove
+ *              the variable from the environment (like unsetenv(3))
+ *
  * Return:      Success:    0
  *              Failure:    non-zero error code
  *
@@ -471,14 +474,14 @@ Wgettimeofday(struct timeval *tv, struct timezone *tz)
 int
 Wsetenv(const char *name, const char *value, int overwrite)
 {
-    size_t  bufsize;
-    errno_t err;
-
     /* If we're not overwriting, check if the environment variable exists.
      * If it does (i.e.: the required buffer size to store the variable's
      * value is non-zero), then return an error code.
      */
     if (!overwrite) {
+        size_t  bufsize;
+        errno_t err;
+
         err = getenv_s(&bufsize, NULL, 0, name);
         if (err || bufsize)
             return (int)err;
@@ -487,7 +490,7 @@ Wsetenv(const char *name, const char *value, int overwrite)
     return (int)_putenv_s(name, value);
 } /* end Wsetenv() */
 
-#ifdef H5_HAVE_WINSOCK2_H
+#ifdef H5_HAVE_WIN32_API
 #pragma comment(lib, "advapi32.lib")
 #endif
 
@@ -572,12 +575,12 @@ char *
 Wgetlogin(void)
 {
 
-#ifdef H5_HAVE_WINSOCK2_H
+#ifdef H5_HAVE_WIN32_API
     DWORD bufferCount = WloginBuffer_count;
     if (GetUserName(Wlogin_buffer, &bufferCount) != 0)
         return (Wlogin_buffer);
     else
-#endif /* H5_HAVE_WINSOCK2_H */
+#endif
         return NULL;
 }
 
@@ -964,10 +967,7 @@ done:
  *              Note that commodity hardware is probably going to have a
  *              resolution of milliseconds, not nanoseconds.
  *
- * Return:      SUCCEED/FAIL
- *
- * Programmer:  Quincey Koziol
- *              October 01, 2016
+ * Return:      void
  *--------------------------------------------------------------------------
  */
 void
@@ -976,21 +976,40 @@ H5_nanosleep(uint64_t nanosec)
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
 #ifdef H5_HAVE_WIN32_API
+    DWORD dwMilliseconds = (DWORD)HDceil(nanosec / 1.0e6);
+    DWORD ignore;
 
-    /* On Windows, Sleep() is in milliseconds. Passing 0 to Sleep()
-     * causes the thread to relinquish the rest of its time slice.
+    /* Windows can't sleep at a ns resolution. Best we can do is ~1 ms. We
+     * don't care about the return value since the second parameter
+     * (bAlertable) is FALSE, so it will always be zero.
      */
-    Sleep(nanosec / (1000 * 1000));
+    ignore = SleepEx(dwMilliseconds, FALSE);
 
 #else
-    {
-        struct timespec sleeptime; /* Struct to hold time to sleep */
 
-        /* Set up time to sleep */
-        sleeptime.tv_sec  = 0;
-        sleeptime.tv_nsec = (long)nanosec;
+    const uint64_t  nanosec_per_sec = 1000 * 1000 * 1000;
+    struct timespec sleeptime; /* Struct to hold time to sleep */
+
+    /* Set up time to sleep
+     *
+     * Assuming ILP32 or LP64 or wider architecture, (long)operand
+     * satisfies 0 <= operand < nanosec_per_sec < LONG_MAX.
+     *
+     * It's harder to be sure that we don't overflow time_t.
+     */
+    sleeptime.tv_sec  = (time_t)(nanosec / nanosec_per_sec);
+    sleeptime.tv_nsec = (long)(nanosec % nanosec_per_sec);
 
-        HDnanosleep(&sleeptime, NULL);
+    /* Sleep for up to `sleeptime` and, in the event of an interruption,
+     * save the unslept time back to `sleeptime`.
+     */
+    while (HDnanosleep(&sleeptime, &sleeptime) == -1) {
+        /* If we were just interrupted, sleep for the remaining time.
+         * Otherwise, the error was essentially impossible, so just stop
+         * sleeping.
+         */
+        if (errno != EINTR)
+            break;
     }
 #endif
 
@@ -1042,3 +1061,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;
+}
diff --git a/src/H5win32defs.h b/src/H5win32defs.h
index 88911b0..985ad3c 100644
--- a/src/H5win32defs.h
+++ b/src/H5win32defs.h
@@ -29,24 +29,36 @@
 typedef struct _stati64 h5_stat_t;
 typedef __int64         h5_stat_size_t;
 
-#define HDaccess(F, M) _access(F, M)
-#define HDchdir(S)     _chdir(S)
-#define HDclose(F)     _close(F)
-#define HDcreat(S, M)  Wopen_utf8(S, O_CREAT | O_TRUNC | O_RDWR, M)
-#define HDdup(F)       _dup(F)
-#define HDfdopen(N, S) _fdopen(N, S)
-#define HDfileno(F)    _fileno(F)
-#define HDfstat(F, B)  _fstati64(F, B)
-#define HDisatty(F)    _isatty(F)
+#ifdef H5_HAVE_VISUAL_STUDIO
 
-#define HDgetcwd(S, Z)     _getcwd(S, Z)
-#define HDgetdcwd(D, S, Z) _getdcwd(D, S, Z)
-#define HDgetdrive()       _getdrive()
-#define HDlseek(F, O, W)   _lseeki64(F, O, W)
-#define HDlstat(S, B)      _lstati64(S, B)
-#define HDmkdir(S, M)      _mkdir(S)
-#define HDnanosleep(N, O)  Wnanosleep(N, O)
-#define HDoff_t            __int64
+struct timezone {
+    int tz_minuteswest;
+    int tz_dsttime;
+};
+
+#endif /* H5_HAVE_VISUAL_STUDIO */
+
+#define HDaccess(F, M)       _access(F, M)
+#define HDchdir(S)           _chdir(S)
+#define HDclose(F)           _close(F)
+#define HDcreat(S, M)        Wopen_utf8(S, O_CREAT | O_TRUNC | O_RDWR, M)
+#define HDdup(F)             _dup(F)
+#define HDfdopen(N, S)       _fdopen(N, S)
+#define HDfileno(F)          _fileno(F)
+#define HDflock(F, L)        Wflock(F, L)
+#define HDfstat(F, B)        _fstati64(F, B)
+#define HDgetcwd(S, Z)       _getcwd(S, Z)
+#define HDgetdcwd(D, S, Z)   _getdcwd(D, S, Z)
+#define HDgetdrive()         _getdrive()
+#define HDgetlogin()         Wgetlogin()
+#define HDgettimeofday(V, Z) Wgettimeofday(V, Z)
+#define HDisatty(F)          _isatty(F)
+#define HDlseek(F, O, W)     _lseeki64(F, O, W)
+#define HDlstat(S, B)        _lstati64(S, B)
+#define HDmemset(X, C, Z)    memset((void *)(X), C, Z) /* Cast avoids MSVC warning */
+#define HDmkdir(S, M)        _mkdir(S)
+#define HDnanosleep(N, O)    Wnanosleep(N, O)
+#define HDoff_t              __int64
 
 /* Note that the variadic HDopen macro is using a VC++ extension
  * where the comma is dropped if nothing is passed to the ellipsis.
@@ -56,9 +68,11 @@ typedef __int64         h5_stat_size_t;
 #else
 #define HDopen(S, F, ...) Wopen_utf8(S, F, ##__VA_ARGS__)
 #endif
+
 #define HDread(F, M, Z)       _read(F, M, Z)
 #define HDremove(S)           Wremove_utf8(S)
 #define HDrmdir(S)            _rmdir(S)
+#define HDsetenv(N, V, O)     Wsetenv(N, V, O)
 #define HDsetvbuf(F, S, M, Z) setvbuf(F, S, M, (Z > 1 ? Z : 2))
 #define HDsleep(S)            Sleep(S * 1000)
 #define HDstat(S, B)          _stati64(S, B)
@@ -67,21 +81,13 @@ typedef __int64         h5_stat_size_t;
 #define HDstrtok_r(X, Y, Z)   strtok_s(X, Y, Z)
 #define HDtzset()             _tzset()
 #define HDunlink(S)           _unlink(S)
+#define HDunsetenv(N)         Wsetenv(N, "", 1)
 #define HDwrite(F, M, Z)      _write(F, M, Z)
 
-#ifdef H5_HAVE_VISUAL_STUDIO
-
-/*
- * The (void*) cast just avoids a compiler warning in MSVC
- */
-#define HDmemset(X, C, Z) memset((void *)(X), C, Z)
-
-struct timezone {
-    int tz_minuteswest;
-    int tz_dsttime;
-};
-
-#endif /* H5_HAVE_VISUAL_STUDIO */
+#ifndef H5_HAVE_MINGW
+#define HDftruncate(F, L) _chsize_s(F, L)
+#define HDfseek(F, O, W)  _fseeki64(F, O, W)
+#endif /* H5_HAVE_MINGW */
 
 #ifdef __cplusplus
 extern "C" {
@@ -99,16 +105,4 @@ H5_DLL int      H5_get_win32_times(H5_timevals_t *tvs);
 }
 #endif /* __cplusplus */
 
-#define HDgettimeofday(V, Z) Wgettimeofday(V, Z)
-#define HDsetenv(N, V, O)    Wsetenv(N, V, O)
-#define HDflock(F, L)        Wflock(F, L)
-#define HDgetlogin()         Wgetlogin()
-
-/* Non-POSIX functions */
-
-#ifndef H5_HAVE_MINGW
-#define HDftruncate(F, L) _chsize_s(F, L)
-#define HDfseek(F, O, W)  _fseeki64(F, O, W)
-#endif /* H5_HAVE_MINGW */
-
 #endif /* H5_HAVE_WIN32_API */