Merge pull request #593 in HDFFV/hdf5 from hdf5_1_8_19 to 1.8/masterhdf5-1_8_19

* commit 'c15238a38fdb3692466bc1218de4c5aeb420fdcc': (153 commits)
  Commit changes to release version strings in README.txt and RELEASE.txt from release.
  Put back link targets for dynamically loaded libraries in Makefile.ams that avoid linking with libhdf5 dependencies.  Some configurations failed unnecessarily to find and link with lz and lsz when these targets were removed.
  Update URL for obtaining source inINSTALL file.
  Disable building of libdynlib* dynamically loaded plugin test libraries on CYGWIN. Added known problem entry to RELEASE.txt. Set version for 1.8.19 release. Barbara updated contents of README.txt file.
  Moved libdynlib* plugin test libraries to noist_LT_LIBRARIES with added flag '-rpath /nowhere' to stop them being installed while keeping them from linking with libhdf5, etc. Incremented version to 1.8.19-pre1 and ran bin/release to create tar and zip files for testing.
  HDF5 1.8.19-pre1 released.
  Add RELEASE.txt entry for H5Dget_chunk_size.
  Remove test entries
  Ran bin/reconfigure after so number change.
  Update hl lib .so numbers:  new function was added. Update RELEASE.txt:  move H5DOread_chunks entry to new features, clarify entry for HDFFV-10051.
  Updated notes for test fixes and added bug fix for h5diff help text.
  Update h5vers and release scripts for 1.8.19 branch, set version to 1.8.19-pre1.
  Make script name consistent across product versions
  Update version to 1.8.19-pre1.
  Propagate .so number changes to Makefile.ins with bin/reconfigure.
  Add toolset option
  Update so version numbers according to the interface compatibility report.
  Update supported Platforms section. Remove empty sub-sections of New Features and Bugs Fixed sections.
  Add entries for HDFFV-10051 and HDFFV-9934 to RELEASE.txt.
  Correct spelling
  ...

1 files changed, 134 insertions, 111 deletions

diff --git a/config/cmake_ext_mod/ConfigureChecks.cmake b/config/cmake_ext_mod/ConfigureChecks.cmake
index 9589295..7db1ec3 100644
--- a/config/cmake_ext_mod/ConfigureChecks.cmake
+++ b/config/cmake_ext_mod/ConfigureChecks.cmake
@@ -1,3 +1,14 @@
+#
+# Copyright by The HDF Group.
+# All rights reserved.
+#
+# This file is part of HDF5.  The full HDF5 copyright notice, including
+# terms governing use, modification, and redistribution, is contained in
+# the COPYING file, which can be found at the root of the source code
+# distribution tree, or in https://support.hdfgroup.org/ftp/HDF5/releases.
+# If you do not have access to either file, you may request a copy from
+# help@hdfgroup.org.
+
 #-----------------------------------------------------------------------------
 # Include all the necessary files for macros
 #-----------------------------------------------------------------------------
@@ -11,9 +22,9 @@ include (${CMAKE_ROOT}/Modules/CheckTypeSize.cmake)
 include (${CMAKE_ROOT}/Modules/CheckVariableExists.cmake)
 include (${CMAKE_ROOT}/Modules/CheckFortranFunctionExists.cmake)
 include (${CMAKE_ROOT}/Modules/TestBigEndian.cmake)
-if(CMAKE_CXX_COMPILER)
+if (CMAKE_CXX_COMPILER AND CMAKE_CXX_COMPILER_LOADED)
   include (${CMAKE_ROOT}/Modules/TestForSTDNamespace.cmake)
-endif(CMAKE_CXX_COMPILER)
+endif ()
 
 #-----------------------------------------------------------------------------
 # APPLE/Darwin setup
@@ -28,29 +39,29 @@ if (APPLE)
     "variable has been set to a blank value which will build the default architecture for this system.")
   endif ()
   set (${HDF_PREFIX}_AC_APPLE_UNIVERSAL_BUILD 0)
-endif (APPLE)
+endif ()
 
 # Check for Darwin (not just Apple - we also want to catch OpenDarwin)
 if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
     set (${HDF_PREFIX}_HAVE_DARWIN 1)
-endif (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+endif ()
 
 # Check for Solaris
 if (${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
     set (${HDF_PREFIX}_HAVE_SOLARIS 1)
-endif (${CMAKE_SYSTEM_NAME} MATCHES "SunOS")
+endif ()
 
 #-----------------------------------------------------------------------------
 # This MACRO checks IF the symbol exists in the library and IF it
 # does, it appends library to the list.
 #-----------------------------------------------------------------------------
 set (LINK_LIBS "")
-MACRO (CHECK_LIBRARY_EXISTS_CONCAT LIBRARY SYMBOL VARIABLE)
+macro (CHECK_LIBRARY_EXISTS_CONCAT LIBRARY SYMBOL VARIABLE)
   CHECK_LIBRARY_EXISTS ("${LIBRARY};${LINK_LIBS}" ${SYMBOL} "" ${VARIABLE})
   if (${VARIABLE})
     set (LINK_LIBS ${LINK_LIBS} ${LIBRARY})
-  endif (${VARIABLE})
-ENDMACRO (CHECK_LIBRARY_EXISTS_CONCAT)
+  endif ()
+endmacro ()
 
 # ----------------------------------------------------------------------
 # WINDOWS Hard code Values
@@ -62,7 +73,7 @@ if (WIN32)
     set (${HDF_PREFIX}_HAVE_MINGW 1)
     set (WINDOWS 1) # MinGW tries to imitate Windows
     set (CMAKE_REQUIRED_FLAGS "-DWIN32_LEAN_AND_MEAN=1 -DNOGDI=1")
-  endif (MINGW)
+  endif ()
   set (${HDF_PREFIX}_HAVE_WIN32_API 1)
   set (CMAKE_REQUIRED_LIBRARIES "ws2_32.lib;wsock32.lib")
   if (NOT UNIX AND NOT MINGW)
@@ -70,9 +81,9 @@ if (WIN32)
     set (CMAKE_REQUIRED_FLAGS "/DWIN32_LEAN_AND_MEAN=1 /DNOGDI=1")
     if (MSVC)
       set (${HDF_PREFIX}_HAVE_VISUAL_STUDIO 1)
-    endif (MSVC)
-  endif (NOT UNIX AND NOT MINGW)
-endif (WIN32)
+    endif ()
+  endif ()
+endif ()
 
 if (WINDOWS)
   set (${HDF_PREFIX}_HAVE_STDDEF_H 1)
@@ -84,20 +95,20 @@ if (WINDOWS)
   set (${HDF_PREFIX}_HAVE_LONGJMP 1)
   if (NOT MINGW)
     set (${HDF_PREFIX}_HAVE_GETHOSTNAME 1)
-  endif (NOT MINGW)
+  endif ()
   if (NOT UNIX AND NOT CYGWIN AND NOT MINGW)
     set (${HDF_PREFIX}_HAVE_GETCONSOLESCREENBUFFERINFO 1)
-  endif (NOT UNIX AND NOT CYGWIN AND NOT MINGW)
+  endif ()
   set (${HDF_PREFIX}_HAVE_FUNCTION 1)
   set (${HDF_PREFIX}_GETTIMEOFDAY_GIVES_TZ 1)
   set (${HDF_PREFIX}_HAVE_TIMEZONE 1)
   set (${HDF_PREFIX}_HAVE_GETTIMEOFDAY 1)
   if (MINGW)
     set (${HDF_PREFIX}_HAVE_WINSOCK2_H 1)
-  endif (MINGW)
+  endif ()
   set (${HDF_PREFIX}_HAVE_LIBWS2_32 1)
   set (${HDF_PREFIX}_HAVE_LIBWSOCK32 1)
-endif (WINDOWS)
+endif ()
 
 # ----------------------------------------------------------------------
 # END of WINDOWS Hard code Values
@@ -105,7 +116,7 @@ endif (WINDOWS)
 
 if (CYGWIN)
   set (${HDF_PREFIX}_HAVE_LSEEK64 0)
-endif (CYGWIN)
+endif ()
 
 #-----------------------------------------------------------------------------
 #  Check for the math library "m"
@@ -115,7 +126,7 @@ if (NOT WINDOWS)
   CHECK_LIBRARY_EXISTS_CONCAT ("dl" dlopen     ${HDF_PREFIX}_HAVE_LIBDL)
   CHECK_LIBRARY_EXISTS_CONCAT ("ws2_32" WSAStartup  ${HDF_PREFIX}_HAVE_LIBWS2_32)
   CHECK_LIBRARY_EXISTS_CONCAT ("wsock32" gethostbyname ${HDF_PREFIX}_HAVE_LIBWSOCK32)
-endif (NOT WINDOWS)
+endif ()
 
 # UCB (BSD) compatibility library
 CHECK_LIBRARY_EXISTS_CONCAT ("ucb"    gethostname  ${HDF_PREFIX}_HAVE_LIBUCB)
@@ -126,20 +137,20 @@ set (CMAKE_REQUIRED_LIBRARIES ${CMAKE_REQUIRED_LIBRARIES} ${LINK_LIBS})
 set (USE_INCLUDES "")
 if (WINDOWS)
   set (USE_INCLUDES ${USE_INCLUDES} "windows.h")
-endif (WINDOWS)
+endif ()
 
 if (NOT WINDOWS)
   TEST_BIG_ENDIAN (${HDF_PREFIX}_WORDS_BIGENDIAN)
-endif (NOT WINDOWS)
+endif ()
 
 # For other specific tests, use this MACRO.
-MACRO (HDF_FUNCTION_TEST OTHER_TEST)
+macro (HDF_FUNCTION_TEST OTHER_TEST)
   if ("${HDF_PREFIX}_${OTHER_TEST}" MATCHES "^${HDF_PREFIX}_${OTHER_TEST}$")
     set (MACRO_CHECK_FUNCTION_DEFINITIONS "-D${OTHER_TEST} ${CMAKE_REQUIRED_FLAGS}")
     set (OTHER_TEST_ADD_LIBRARIES)
     if (CMAKE_REQUIRED_LIBRARIES)
       set (OTHER_TEST_ADD_LIBRARIES "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
-    endif (CMAKE_REQUIRED_LIBRARIES)
+    endif ()
 
     foreach (def
         HAVE_SYS_TIME_H
@@ -149,14 +160,14 @@ MACRO (HDF_FUNCTION_TEST OTHER_TEST)
     )
       if ("${${HDF_PREFIX}_${def}}")
         set (MACRO_CHECK_FUNCTION_DEFINITIONS "${MACRO_CHECK_FUNCTION_DEFINITIONS} -D${def}")
-      endif ("${${HDF_PREFIX}_${def}}")
-    endforeach (def)
+      endif ()
+    endforeach ()
 
     if (LARGEFILE)
       set (MACRO_CHECK_FUNCTION_DEFINITIONS
           "${MACRO_CHECK_FUNCTION_DEFINITIONS} -D_FILE_OFFSET_BITS=64 -D_LARGEFILE64_SOURCE -D_LARGEFILE_SOURCE"
       )
-    endif (LARGEFILE)
+    endif ()
 
     #message (STATUS "Performing ${OTHER_TEST}")
     TRY_COMPILE (${OTHER_TEST}
@@ -169,16 +180,16 @@ MACRO (HDF_FUNCTION_TEST OTHER_TEST)
     if (${OTHER_TEST})
       set (${HDF_PREFIX}_${OTHER_TEST} 1 CACHE INTERNAL "Other test ${FUNCTION}")
       message (STATUS "Performing Other Test ${OTHER_TEST} - Success")
-    else (${OTHER_TEST})
+    else ()
       message (STATUS "Performing Other Test ${OTHER_TEST} - Failed")
       set (${HDF_PREFIX}_${OTHER_TEST} "" CACHE INTERNAL "Other test ${FUNCTION}")
       file (APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
           "Performing Other Test ${OTHER_TEST} failed with the following output:\n"
           "${OUTPUT}\n"
       )
-    endif (${OTHER_TEST})
-  endif ("${HDF_PREFIX}_${OTHER_TEST}" MATCHES "^${HDF_PREFIX}_${OTHER_TEST}$")
-ENDMACRO (HDF_FUNCTION_TEST)
+    endif ()
+  endif ()
+endmacro ()
 
 #-----------------------------------------------------------------------------
 # Check for these functions before the time headers are checked
@@ -188,28 +199,29 @@ HDF_FUNCTION_TEST (STDC_HEADERS)
 #-----------------------------------------------------------------------------
 # Check IF header file exists and add it to the list.
 #-----------------------------------------------------------------------------
-MACRO (CHECK_INCLUDE_FILE_CONCAT FILE VARIABLE)
+macro (CHECK_INCLUDE_FILE_CONCAT FILE VARIABLE)
   CHECK_INCLUDE_FILES ("${USE_INCLUDES};${FILE}" ${VARIABLE})
   if (${VARIABLE})
     set (USE_INCLUDES ${USE_INCLUDES} ${FILE})
-  endif (${VARIABLE})
-ENDMACRO (CHECK_INCLUDE_FILE_CONCAT)
+  endif ()
+endmacro ()
 
 #-----------------------------------------------------------------------------
 #  Check for the existence of certain header files
 #-----------------------------------------------------------------------------
-CHECK_INCLUDE_FILE_CONCAT ("sys/resource.h"  ${HDF_PREFIX}_HAVE_SYS_RESOURCE_H)
-CHECK_INCLUDE_FILE_CONCAT ("sys/time.h"      ${HDF_PREFIX}_HAVE_SYS_TIME_H)
-CHECK_INCLUDE_FILE_CONCAT ("unistd.h"        ${HDF_PREFIX}_HAVE_UNISTD_H)
+CHECK_INCLUDE_FILE_CONCAT ("sys/file.h"      ${HDF_PREFIX}_HAVE_SYS_FILE_H)
 CHECK_INCLUDE_FILE_CONCAT ("sys/ioctl.h"     ${HDF_PREFIX}_HAVE_SYS_IOCTL_H)
-CHECK_INCLUDE_FILE_CONCAT ("sys/stat.h"      ${HDF_PREFIX}_HAVE_SYS_STAT_H)
+CHECK_INCLUDE_FILE_CONCAT ("sys/resource.h"  ${HDF_PREFIX}_HAVE_SYS_RESOURCE_H)
 CHECK_INCLUDE_FILE_CONCAT ("sys/socket.h"    ${HDF_PREFIX}_HAVE_SYS_SOCKET_H)
+CHECK_INCLUDE_FILE_CONCAT ("sys/stat.h"      ${HDF_PREFIX}_HAVE_SYS_STAT_H)
+CHECK_INCLUDE_FILE_CONCAT ("sys/time.h"      ${HDF_PREFIX}_HAVE_SYS_TIME_H)
 CHECK_INCLUDE_FILE_CONCAT ("sys/types.h"     ${HDF_PREFIX}_HAVE_SYS_TYPES_H)
-CHECK_INCLUDE_FILE_CONCAT ("stddef.h"        ${HDF_PREFIX}_HAVE_STDDEF_H)
-CHECK_INCLUDE_FILE_CONCAT ("setjmp.h"        ${HDF_PREFIX}_HAVE_SETJMP_H)
 CHECK_INCLUDE_FILE_CONCAT ("features.h"      ${HDF_PREFIX}_HAVE_FEATURES_H)
 CHECK_INCLUDE_FILE_CONCAT ("dirent.h"        ${HDF_PREFIX}_HAVE_DIRENT_H)
+CHECK_INCLUDE_FILE_CONCAT ("setjmp.h"        ${HDF_PREFIX}_HAVE_SETJMP_H)
+CHECK_INCLUDE_FILE_CONCAT ("stddef.h"        ${HDF_PREFIX}_HAVE_STDDEF_H)
 CHECK_INCLUDE_FILE_CONCAT ("stdint.h"        ${HDF_PREFIX}_HAVE_STDINT_H)
+CHECK_INCLUDE_FILE_CONCAT ("unistd.h"        ${HDF_PREFIX}_HAVE_UNISTD_H)
 
 # IF the c compiler found stdint, check the C++ as well. On some systems this
 # file will be found by C but not C++, only do this test IF the C++ compiler
@@ -219,8 +231,8 @@ if (${HDF_PREFIX}_HAVE_STDINT_H AND CMAKE_CXX_COMPILER_LOADED)
   if (NOT ${HDF_PREFIX}_HAVE_STDINT_H_CXX)
     set (${HDF_PREFIX}_HAVE_STDINT_H "" CACHE INTERNAL "Have includes HAVE_STDINT_H")
     set (USE_INCLUDES ${USE_INCLUDES} "stdint.h")
-  endif (NOT ${HDF_PREFIX}_HAVE_STDINT_H_CXX)
-endif (${HDF_PREFIX}_HAVE_STDINT_H AND CMAKE_CXX_COMPILER_LOADED)
+  endif ()
+endif ()
 
 # Darwin
 CHECK_INCLUDE_FILE_CONCAT ("mach/mach_time.h" ${HDF_PREFIX}_HAVE_MACH_MACH_TIME_H)
@@ -229,16 +241,16 @@ CHECK_INCLUDE_FILE_CONCAT ("mach/mach_time.h" ${HDF_PREFIX}_HAVE_MACH_MACH_TIME_
 CHECK_INCLUDE_FILE_CONCAT ("io.h"            ${HDF_PREFIX}_HAVE_IO_H)
 if (NOT CYGWIN)
   CHECK_INCLUDE_FILE_CONCAT ("winsock2.h"      ${HDF_PREFIX}_HAVE_WINSOCK2_H)
-endif (NOT CYGWIN)
+endif ()
 CHECK_INCLUDE_FILE_CONCAT ("sys/timeb.h"     ${HDF_PREFIX}_HAVE_SYS_TIMEB_H)
 
 if (CMAKE_SYSTEM_NAME MATCHES "OSF")
   CHECK_INCLUDE_FILE_CONCAT ("sys/sysinfo.h" ${HDF_PREFIX}_HAVE_SYS_SYSINFO_H)
   CHECK_INCLUDE_FILE_CONCAT ("sys/proc.h"    ${HDF_PREFIX}_HAVE_SYS_PROC_H)
-else (CMAKE_SYSTEM_NAME MATCHES "OSF")
+else ()
   set (${HDF_PREFIX}_HAVE_SYS_SYSINFO_H "" CACHE INTERNAL "" FORCE)
   set (${HDF_PREFIX}_HAVE_SYS_PROC_H    "" CACHE INTERNAL "" FORCE)
-endif (CMAKE_SYSTEM_NAME MATCHES "OSF")
+endif ()
 
 CHECK_INCLUDE_FILE_CONCAT ("globus/common.h" ${HDF_PREFIX}_HAVE_GLOBUS_COMMON_H)
 CHECK_INCLUDE_FILE_CONCAT ("pdb.h"           ${HDF_PREFIX}_HAVE_PDB_H)
@@ -295,29 +307,29 @@ if (NOT WINDOWS)
     # check should be generalized for all POSIX systems as it
     # is in the Autotools.
     if (TEST_LFS_WORKS_COMPILE)
-      if (TEST_LFS_WORKS_RUN  MATCHES 0)
+      if (TEST_LFS_WORKS_RUN MATCHES 0)
         set (TEST_LFS_WORKS 1 CACHE INTERNAL ${msg})
         set (LARGEFILE 1)
         set (HDF_EXTRA_FLAGS ${HDF_EXTRA_FLAGS} -D_FILE_OFFSET_BITS=64 -D_LARGEFILE64_SOURCE -D_LARGEFILE_SOURCE)
         message (STATUS "${msg}... yes")
-      else (TEST_LFS_WORKS_RUN  MATCHES 0)
+      else ()
         set (TEST_LFS_WORKS "" CACHE INTERNAL ${msg})
         message (STATUS "${msg}... no")
         file (APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
               "Test TEST_LFS_WORKS Run failed with the following output and exit code:\n ${OUTPUT}\n"
         )
-      endif (TEST_LFS_WORKS_RUN  MATCHES 0)
-    else (TEST_LFS_WORKS_COMPILE )
+      endif ()
+    else ()
       set (TEST_LFS_WORKS "" CACHE INTERNAL ${msg})
       message (STATUS "${msg}... no")
       file (APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
           "Test TEST_LFS_WORKS Compile failed with the following output:\n ${OUTPUT}\n"
       )
-    endif (TEST_LFS_WORKS_COMPILE)
-  endif (HDF_ENABLE_LARGE_FILE)
+    endif ()
+  endif ()
   set (CMAKE_REQUIRED_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} ${HDF_EXTRA_FLAGS})
-  endif (NOT ${HDF_PREFIX}_HAVE_SOLARIS AND NOT ${HDF_PREFIX}_HAVE_DARWIN)
-endif (NOT WINDOWS)
+  endif ()
+endif ()
 
 add_definitions (${HDF_EXTRA_FLAGS})
 
@@ -331,7 +343,7 @@ if (NOT WINDOWS OR MINGW)
     CHECK_FUNCTION_EXISTS (fseeko64           ${HDF_PREFIX}_HAVE_FSEEKO64)
     CHECK_FUNCTION_EXISTS (ftello64           ${HDF_PREFIX}_HAVE_FTELLO64)
     CHECK_FUNCTION_EXISTS (ftruncate64        ${HDF_PREFIX}_HAVE_FTRUNCATE64)
-  endif (${HDF_PREFIX}_HAVE_OFF64_T)
+  endif ()
 
   CHECK_FUNCTION_EXISTS (fseeko               ${HDF_PREFIX}_HAVE_FSEEKO)
   CHECK_FUNCTION_EXISTS (ftello               ${HDF_PREFIX}_HAVE_FTELLO)
@@ -340,13 +352,13 @@ if (NOT WINDOWS OR MINGW)
   if (HAVE_STAT64_STRUCT)
     CHECK_FUNCTION_EXISTS (fstat64            ${HDF_PREFIX}_HAVE_FSTAT64)
     CHECK_FUNCTION_EXISTS (stat64             ${HDF_PREFIX}_HAVE_STAT64)
-  endif (HAVE_STAT64_STRUCT)
-endif (NOT WINDOWS OR MINGW)
+  endif ()
+endif ()
 
 #-----------------------------------------------------------------------------
 #  Check the size in bytes of all the int and float types
 #-----------------------------------------------------------------------------
-MACRO (HDF_CHECK_TYPE_SIZE type var)
+macro (HDF_CHECK_TYPE_SIZE type var)
   set (aType ${type})
   set (aVar  ${var})
 #  message (STATUS "Checking size of ${aType} and storing into ${aVar}")
@@ -354,8 +366,8 @@ MACRO (HDF_CHECK_TYPE_SIZE type var)
   if (NOT ${aVar})
     set (${aVar} 0 CACHE INTERNAL "SizeOf for ${aType}")
 #    message (STATUS "Size of ${aType} was NOT Found")
-  endif (NOT ${aVar})
-ENDMACRO (HDF_CHECK_TYPE_SIZE)
+  endif ()
+endmacro ()
 
 HDF_CHECK_TYPE_SIZE (char           ${HDF_PREFIX}_SIZEOF_CHAR)
 HDF_CHECK_TYPE_SIZE (short          ${HDF_PREFIX}_SIZEOF_SHORT)
@@ -363,12 +375,12 @@ HDF_CHECK_TYPE_SIZE (int            ${HDF_PREFIX}_SIZEOF_INT)
 HDF_CHECK_TYPE_SIZE (unsigned       ${HDF_PREFIX}_SIZEOF_UNSIGNED)
 if (NOT APPLE)
   HDF_CHECK_TYPE_SIZE (long         ${HDF_PREFIX}_SIZEOF_LONG)
-endif (NOT APPLE)
+endif ()
 HDF_CHECK_TYPE_SIZE ("long long"    ${HDF_PREFIX}_SIZEOF_LONG_LONG)
 HDF_CHECK_TYPE_SIZE (__int64        ${HDF_PREFIX}_SIZEOF___INT64)
 if (NOT ${HDF_PREFIX}_SIZEOF___INT64)
   set (${HDF_PREFIX}_SIZEOF___INT64 0)
-endif (NOT ${HDF_PREFIX}_SIZEOF___INT64)
+endif ()
 
 HDF_CHECK_TYPE_SIZE (float          ${HDF_PREFIX}_SIZEOF_FLOAT)
 HDF_CHECK_TYPE_SIZE (double         ${HDF_PREFIX}_SIZEOF_DOUBLE)
@@ -407,17 +419,17 @@ if (NOT APPLE)
   HDF_CHECK_TYPE_SIZE (ssize_t      ${HDF_PREFIX}_SIZEOF_SSIZE_T)
   if (NOT ${HDF_PREFIX}_SIZEOF_SSIZE_T)
     set (${HDF_PREFIX}_SIZEOF_SSIZE_T 0)
-  endif (NOT ${HDF_PREFIX}_SIZEOF_SSIZE_T)
+  endif ()
   if (NOT WINDOWS)
     HDF_CHECK_TYPE_SIZE (ptrdiff_t    ${HDF_PREFIX}_SIZEOF_PTRDIFF_T)
-  endif (NOT WINDOWS)
-endif (NOT APPLE)
+  endif ()
+endif ()
 
 HDF_CHECK_TYPE_SIZE (off_t          ${HDF_PREFIX}_SIZEOF_OFF_T)
 HDF_CHECK_TYPE_SIZE (off64_t        ${HDF_PREFIX}_SIZEOF_OFF64_T)
 if (NOT ${HDF_PREFIX}_SIZEOF_OFF64_T)
   set (${HDF_PREFIX}_SIZEOF_OFF64_T 0)
-endif (NOT ${HDF_PREFIX}_SIZEOF_OFF64_T)
+endif ()
 
 #-----------------------------------------------------------------------------
 # Extra C99 types
@@ -428,9 +440,9 @@ CHECK_INCLUDE_FILE_CONCAT (stdbool.h    ${HDF_PREFIX}_HAVE_STDBOOL_H)
 if (HAVE_STDBOOL_H)
   set (CMAKE_EXTRA_INCLUDE_FILES stdbool.h)
   HDF_CHECK_TYPE_SIZE (bool         ${HDF_PREFIX}_SIZEOF_BOOL)
-else (HAVE_STDBOOL_H)
+else ()
   HDF_CHECK_TYPE_SIZE (_Bool        ${HDF_PREFIX}_SIZEOF_BOOL)
-endif (HAVE_STDBOOL_H)
+endif ()
 
 if (NOT WINDOWS)
   #-----------------------------------------------------------------------------
@@ -459,11 +471,11 @@ if (NOT WINDOWS)
       HAVE_STRUCT_TM_TM_ZONE
   )
     HDF_FUNCTION_TEST (${test})
-  endforeach (test)
+  endforeach ()
   if (NOT CYGWIN AND NOT MINGW)
       HDF_FUNCTION_TEST (HAVE_TIMEZONE)
 #      HDF_FUNCTION_TEST (HAVE_STAT_ST_BLOCKS)
-  endif (NOT CYGWIN AND NOT MINGW)
+  endif ()
 
   # ----------------------------------------------------------------------
   # Does the struct stat have the st_blocks field?  This field is not Posix.
@@ -481,7 +493,7 @@ if (NOT WINDOWS)
   CHECK_FUNCTION_EXISTS (_scrsize          ${HDF_PREFIX}_HAVE__SCRSIZE)
   if (NOT CYGWIN AND NOT MINGW)
     CHECK_FUNCTION_EXISTS (GetConsoleScreenBufferInfo    ${HDF_PREFIX}_HAVE_GETCONSOLESCREENBUFFERINFO)
-  endif (NOT CYGWIN AND NOT MINGW)
+  endif ()
   CHECK_SYMBOL_EXISTS (TIOCGWINSZ "sys/ioctl.h" ${HDF_PREFIX}_HAVE_TIOCGWINSZ)
   CHECK_SYMBOL_EXISTS (TIOCGETD   "sys/ioctl.h" ${HDF_PREFIX}_HAVE_TIOCGETD)
 
@@ -490,23 +502,31 @@ if (NOT WINDOWS)
   #
   if (NOT CYGWIN AND NOT MINGW)
     CHECK_FUNCTION_EXISTS (getpwuid        ${HDF_PREFIX}_HAVE_GETPWUID)
-  endif (NOT CYGWIN AND NOT MINGW)
-endif (NOT WINDOWS)
+  endif ()
+endif ()
 
 #-----------------------------------------------------------------------------
 # Check for some functions that are used
 #
 CHECK_FUNCTION_EXISTS (alarm             ${HDF_PREFIX}_HAVE_ALARM)
+CHECK_FUNCTION_EXISTS (fcntl             ${HDF_PREFIX}_HAVE_FCNTL)
+CHECK_FUNCTION_EXISTS (flock             ${HDF_PREFIX}_HAVE_FLOCK)
 CHECK_FUNCTION_EXISTS (fork              ${HDF_PREFIX}_HAVE_FORK)
 CHECK_FUNCTION_EXISTS (frexpf            ${HDF_PREFIX}_HAVE_FREXPF)
 CHECK_FUNCTION_EXISTS (frexpl            ${HDF_PREFIX}_HAVE_FREXPL)
 
 CHECK_FUNCTION_EXISTS (gethostname       ${HDF_PREFIX}_HAVE_GETHOSTNAME)
 CHECK_FUNCTION_EXISTS (getrusage         ${HDF_PREFIX}_HAVE_GETRUSAGE)
+CHECK_FUNCTION_EXISTS (llround           ${HDF_PREFIX}_HAVE_LLROUND)
+CHECK_FUNCTION_EXISTS (llroundf          ${HDF_PREFIX}_HAVE_LLROUNDF)
+CHECK_FUNCTION_EXISTS (lround            ${HDF_PREFIX}_HAVE_LROUND)
+CHECK_FUNCTION_EXISTS (lroundf           ${HDF_PREFIX}_HAVE_LROUNDF)
 CHECK_FUNCTION_EXISTS (lstat             ${HDF_PREFIX}_HAVE_LSTAT)
 
 CHECK_FUNCTION_EXISTS (rand_r            ${HDF_PREFIX}_HAVE_RAND_R)
 CHECK_FUNCTION_EXISTS (random            ${HDF_PREFIX}_HAVE_RANDOM)
+CHECK_FUNCTION_EXISTS (round             ${HDF_PREFIX}_HAVE_ROUND)
+CHECK_FUNCTION_EXISTS (roundf            ${HDF_PREFIX}_HAVE_ROUNDF)
 CHECK_FUNCTION_EXISTS (setsysinfo        ${HDF_PREFIX}_HAVE_SETSYSINFO)
 
 CHECK_FUNCTION_EXISTS (signal            ${HDF_PREFIX}_HAVE_SIGNAL)
@@ -519,6 +539,8 @@ CHECK_FUNCTION_EXISTS (sigprocmask       ${HDF_PREFIX}_HAVE_SIGPROCMASK)
 CHECK_FUNCTION_EXISTS (snprintf          ${HDF_PREFIX}_HAVE_SNPRINTF)
 CHECK_FUNCTION_EXISTS (srandom           ${HDF_PREFIX}_HAVE_SRANDOM)
 CHECK_FUNCTION_EXISTS (strdup            ${HDF_PREFIX}_HAVE_STRDUP)
+CHECK_FUNCTION_EXISTS (strtoll           ${HDF_PREFIX}_HAVE_STRTOLL)
+CHECK_FUNCTION_EXISTS (strtoull          ${HDF_PREFIX}_HAVE_STRTOULL)
 CHECK_FUNCTION_EXISTS (symlink           ${HDF_PREFIX}_HAVE_SYMLINK)
 CHECK_FUNCTION_EXISTS (system            ${HDF_PREFIX}_HAVE_SYSTEM)
 
@@ -531,8 +553,8 @@ CHECK_FUNCTION_EXISTS (vsnprintf         ${HDF_PREFIX}_HAVE_VSNPRINTF)
 if (NOT WINDOWS)
   if (${HDF_PREFIX}_HAVE_VSNPRINTF)
     HDF_FUNCTION_TEST (VSNPRINTF_WORKS)
-  endif (${HDF_PREFIX}_HAVE_VSNPRINTF)
-endif (NOT WINDOWS)
+  endif ()
+endif ()
 
 #-----------------------------------------------------------------------------
 # sigsetjmp is special; may actually be a macro
@@ -542,9 +564,9 @@ if (NOT ${HDF_PREFIX}_HAVE_SIGSETJMP)
     CHECK_SYMBOL_EXISTS (sigsetjmp "setjmp.h" ${HDF_PREFIX}_HAVE_MACRO_SIGSETJMP)
     if (${HDF_PREFIX}_HAVE_MACRO_SIGSETJMP)
       set (${HDF_PREFIX}_HAVE_SIGSETJMP 1)
-    endif (${HDF_PREFIX}_HAVE_MACRO_SIGSETJMP)
-  endif (${HDF_PREFIX}_HAVE_SETJMP_H)
-endif (NOT ${HDF_PREFIX}_HAVE_SIGSETJMP)
+    endif ()
+  endif ()
+endif ()
 
 #-----------------------------------------------------------------------------
 # Check a bunch of other functions
@@ -558,37 +580,37 @@ if (NOT WINDOWS)
       HAVE_C99_DESIGNATED_INITIALIZER
       SYSTEM_SCOPE_THREADS
       HAVE_SOCKLEN_T
-      CXX_HAVE_OFFSETOF
   )
     HDF_FUNCTION_TEST (${test})
-  endforeach (test)
-endif (NOT WINDOWS)
+  endforeach ()
+endif ()
 
 # For other CXX specific tests, use this MACRO.
-MACRO (HDF_CXX_FUNCTION_TEST OTHER_TEST)
+macro (HDF_CXX_FUNCTION_TEST OTHER_TEST)
   if ("${OTHER_TEST}" MATCHES "^${OTHER_TEST}$")
     set (MACRO_CHECK_FUNCTION_DEFINITIONS "-D${OTHER_TEST} ${CMAKE_REQUIRED_FLAGS}")
     set (OTHER_TEST_ADD_LIBRARIES)
     if (CMAKE_REQUIRED_LIBRARIES)
       set (OTHER_TEST_ADD_LIBRARIES "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
-    endif (CMAKE_REQUIRED_LIBRARIES)
+    endif ()
 
     foreach (def
         HAVE_SYS_TIME_H
         HAVE_UNISTD_H
         HAVE_SYS_TYPES_H
         HAVE_SYS_SOCKET_H
+        HAVE_SYS_FILE_H
     )
       if ("${${HDF_PREFIX}_${def}}")
         set (MACRO_CHECK_FUNCTION_DEFINITIONS "${MACRO_CHECK_FUNCTION_DEFINITIONS} -D${def}")
-      endif ("${${HDF_PREFIX}_${def}}")
-    endforeach (def)
+      endif ()
+    endforeach ()
 
     if (LARGEFILE)
       set (MACRO_CHECK_FUNCTION_DEFINITIONS
           "${MACRO_CHECK_FUNCTION_DEFINITIONS} -D_FILE_OFFSET_BITS=64 -D_LARGEFILE64_SOURCE -D_LARGEFILE_SOURCE"
       )
-    endif (LARGEFILE)
+    endif ()
 
     #message (STATUS "Performing ${OTHER_TEST}")
     TRY_COMPILE (${OTHER_TEST}
@@ -601,16 +623,16 @@ MACRO (HDF_CXX_FUNCTION_TEST OTHER_TEST)
     if (${OTHER_TEST} EQUAL 0)
       set (${OTHER_TEST} 1 CACHE INTERNAL "CXX test ${FUNCTION}")
       message (STATUS "Performing CXX Test ${OTHER_TEST} - Success")
-    else (${OTHER_TEST} EQUAL 0)
+    else ()
       message (STATUS "Performing CXX Test ${OTHER_TEST} - Failed")
       set (${OTHER_TEST} "" CACHE INTERNAL "CXX test ${FUNCTION}")
       file (APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
           "Performing CXX Test ${OTHER_TEST} failed with the following output:\n"
           "${OUTPUT}\n"
       )
-    endif (${OTHER_TEST} EQUAL 0)
-  endif ("${OTHER_TEST}" MATCHES "^${OTHER_TEST}$")
-ENDMACRO (HDF_CXX_FUNCTION_TEST)
+    endif ()
+  endif ()
+endmacro ()
 
 #-----------------------------------------------------------------------------
 # Check a bunch of cxx functions
@@ -622,10 +644,11 @@ if (CMAKE_CXX_COMPILER_LOADED)
       ${HDF_PREFIX}_NO_STD
       BOOL_NOTDEFINED
       NO_STATIC_CAST
+      CXX_HAVE_OFFSETOF
   )
     HDF_CXX_FUNCTION_TEST (${test})
-  endforeach (test)
-endif (CMAKE_CXX_COMPILER_LOADED)
+  endforeach ()
+endif ()
 
 #-----------------------------------------------------------------------------
 # Check if InitOnceExecuteOnce is available
@@ -638,21 +661,21 @@ if (WINDOWS)
       set (CMAKE_REQUIRED_DEFINITIONS
           "${CURRENT_TEST_DEFINITIONS} -D_FILE_OFFSET_BITS=64 -D_LARGEFILE64_SOURCE -D_LARGEFILE_SOURCE"
       )
-    endif (LARGEFILE)
+    endif ()
     set (MACRO_CHECK_FUNCTION_DEFINITIONS
       "-DHAVE_IOEO ${CMAKE_REQUIRED_FLAGS}")
     if (CMAKE_REQUIRED_LIBRARIES)
       set (CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES
         "-DLINK_LIBRARIES:STRING=${CMAKE_REQUIRED_LIBRARIES}")
-    else (CMAKE_REQUIRED_LIBRARIES)
+    else ()
       set (CHECK_C_SOURCE_COMPILES_ADD_LIBRARIES)
-    endif (CMAKE_REQUIRED_LIBRARIES)
+    endif ()
     if (CMAKE_REQUIRED_INCLUDES)
       set (CHECK_C_SOURCE_COMPILES_ADD_INCLUDES
         "-DINCLUDE_DIRECTORIES:STRING=${CMAKE_REQUIRED_INCLUDES}")
-    else (CMAKE_REQUIRED_INCLUDES)
+    else ()
       set (CHECK_C_SOURCE_COMPILES_ADD_INCLUDES)
-    endif (CMAKE_REQUIRED_INCLUDES)
+    endif ()
 
     TRY_RUN(HAVE_IOEO_EXITCODE HAVE_IOEO_COMPILED
       ${CMAKE_BINARY_DIR}
@@ -666,7 +689,7 @@ if (WINDOWS)
     # if it did not compile make the return value fail code of 1
     if (NOT HAVE_IOEO_COMPILED)
       set (HAVE_IOEO_EXITCODE 1)
-    endif (NOT HAVE_IOEO_COMPILED)
+    endif ()
     # if the return value was 0 then it worked
     if ("${HAVE_IOEO_EXITCODE}" EQUAL 0)
       set (${HDF_PREFIX}_HAVE_IOEO 1 CACHE INTERNAL "Test InitOnceExecuteOnce")
@@ -675,22 +698,22 @@ if (WINDOWS)
         "Performing C SOURCE FILE Test InitOnceExecuteOnce succeded with the following output:\n"
         "${OUTPUT}\n"
         "Return value: ${HAVE_IOEO}\n")
-    else ("${HAVE_IOEO_EXITCODE}" EQUAL 0)
+    else ()
       if (CMAKE_CROSSCOMPILING AND "${HAVE_IOEO_EXITCODE}" MATCHES  "FAILED_TO_RUN")
         set (${HDF_PREFIX}_HAVE_IOEO "${HAVE_IOEO_EXITCODE}")
-      else (CMAKE_CROSSCOMPILING AND "${HAVE_IOEO_EXITCODE}" MATCHES  "FAILED_TO_RUN")
+      else ()
         set (${HDF_PREFIX}_HAVE_IOEO "" CACHE INTERNAL "Test InitOnceExecuteOnce")
-      endif (CMAKE_CROSSCOMPILING AND "${HAVE_IOEO_EXITCODE}" MATCHES  "FAILED_TO_RUN")
+      endif ()
 
       message (STATUS "Performing Test InitOnceExecuteOnce - Failed")
       file (APPEND ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
         "Performing InitOnceExecuteOnce Test  failed with the following output:\n"
         "${OUTPUT}\n"
         "Return value: ${HAVE_IOEO_EXITCODE}\n")
-    endif ("${HAVE_IOEO_EXITCODE}" EQUAL 0)
-  endif ("${${HDF_PREFIX}_HAVE_IOEO}" MATCHES "^${${HDF_PREFIX}_HAVE_IOEO}$")
-  endif (NOT HDF_NO_IOEO_TEST)
-endif (WINDOWS)
+    endif ()
+  endif ()
+  endif ()
+endif ()
 
 #-----------------------------------------------------------------------------
 # Determine how 'inline' is used
@@ -698,7 +721,7 @@ endif (WINDOWS)
 foreach (inline_test inline __inline__ __inline)
   string (TOUPPER ${inline_test} INLINE_TEST_MACRO)
   HDF_FUNCTION_TEST (HAVE_${INLINE_TEST_MACRO})
-endforeach (inline_test)
+endforeach ()
 
 #-----------------------------------------------------------------------------
 # Check how to print a Long Long integer
@@ -709,7 +732,7 @@ if (NOT ${HDF_PREFIX}_PRINTF_LL_WIDTH OR ${HDF_PREFIX}_PRINTF_LL_WIDTH MATCHES "
   set (CURRENT_TEST_DEFINITIONS "-DPRINTF_LL_WIDTH")
   if (${HDF_PREFIX}_SIZEOF_LONG_LONG)
     set (CURRENT_TEST_DEFINITIONS "${CURRENT_TEST_DEFINITIONS} -DHAVE_LONG_LONG")
-  endif (${HDF_PREFIX}_SIZEOF_LONG_LONG)
+  endif ()
   TRY_RUN (${HDF_PREFIX}_PRINTF_LL_TEST_RUN   ${HDF_PREFIX}_PRINTF_LL_TEST_COMPILE
       ${CMAKE_BINARY_DIR}
       ${HDF_RESOURCES_EXT_DIR}/HDFTests.c
@@ -721,24 +744,24 @@ if (NOT ${HDF_PREFIX}_PRINTF_LL_WIDTH OR ${HDF_PREFIX}_PRINTF_LL_WIDTH MATCHES "
       string(REGEX REPLACE ".*PRINTF_LL_WIDTH=\\[(.*)\\].*" "\\1" ${HDF_PREFIX}_PRINTF_LL "${OUTPUT}")
       set (${HDF_PREFIX}_PRINTF_LL_WIDTH "\"${${HDF_PREFIX}_PRINTF_LL}\"" CACHE INTERNAL "Width for printf for type `long long' or `__int64', us. `ll")
       set (PRINT_LL_FOUND 1)
-    else (${HDF_PREFIX}_PRINTF_LL_TEST_RUN MATCHES 0)
+    else ()
       message ("Width test failed with result: ${${HDF_PREFIX}_PRINTF_LL_TEST_RUN}")
-    endif (${HDF_PREFIX}_PRINTF_LL_TEST_RUN MATCHES 0)
-  else (${HDF_PREFIX}_PRINTF_LL_TEST_COMPILE)
+    endif ()
+  else ()
     file (APPEND ${CMAKE_BINARY_DIR}/CMakeFiles/CMakeError.log
         "Test ${HDF_PREFIX}_PRINTF_LL_WIDTH failed with the following output:\n ${OUTPUT}\n"
     )
-  endif (${HDF_PREFIX}_PRINTF_LL_TEST_COMPILE)
+  endif ()
 
   if (PRINT_LL_FOUND)
     message (STATUS "Checking for appropriate format for 64 bit long: found ${${HDF_PREFIX}_PRINTF_LL_WIDTH}")
-  else (PRINT_LL_FOUND)
+  else ()
     message (STATUS "Checking for appropriate format for 64 bit long: not found")
     set (${HDF_PREFIX}_PRINTF_LL_WIDTH "\"unknown\"" CACHE INTERNAL
         "Width for printf for type `long long' or `__int64', us. `ll"
     )
-  endif (PRINT_LL_FOUND)
-endif (NOT ${HDF_PREFIX}_PRINTF_LL_WIDTH OR ${HDF_PREFIX}_PRINTF_LL_WIDTH MATCHES "unknown")
+  endif ()
+endif ()
 
 # ----------------------------------------------------------------------
 # Set the flag to indicate that the machine can handle converting