Merge branch 'upstream-KWSys' into update-kwsys

# By KWSys Upstream
* upstream-KWSys:
  KWSys 2020-03-04 (6af2e592)

19 files changed, 998 insertions, 967 deletions

diff --git a/Source/kwsys/CMakeLists.txt b/Source/kwsys/CMakeLists.txt
index aa788e9..5de2776 100644
--- a/Source/kwsys/CMakeLists.txt
+++ b/Source/kwsys/CMakeLists.txt
@@ -11,9 +11,9 @@
 # be used.  All classes are disabled by default.  The CMake listfile
 # above this one configures the library as follows:
 #
-#  SET(KWSYS_NAMESPACE foosys)
-#  SET(KWSYS_USE_Directory 1)    # Enable Directory class.
-#  SUBDIRS(kwsys)
+#  set(KWSYS_NAMESPACE foosys)
+#  set(KWSYS_USE_Directory 1)    # Enable Directory class.
+#  add_subdirectory(kwsys)
 #
 # Optional settings are as follows:
 #
@@ -39,8 +39,8 @@
 #
 #    Example:
 #
-#      SET(KWSYS_HEADER_ROOT ${PROJECT_BINARY_DIR})
-#      INCLUDE_DIRECTORIES(${PROJECT_BINARY_DIR})
+#      set(KWSYS_HEADER_ROOT ${PROJECT_BINARY_DIR})
+#      include_directories(${PROJECT_BINARY_DIR})
 #
 #  KWSYS_CXX_STANDARD         = A value for CMAKE_CXX_STANDARD within KWSys.
 #                               Set to empty string to use no default value.
@@ -65,11 +65,11 @@
 #
 #    Example:
 #
-#      SET(KWSYS_INSTALL_BIN_DIR bin)
-#      SET(KWSYS_INSTALL_LIB_DIR lib)
-#      SET(KWSYS_INSTALL_INCLUDE_DIR include)
-#      SET(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME Runtime)
-#      SET(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT Development)
+#      set(KWSYS_INSTALL_BIN_DIR bin)
+#      set(KWSYS_INSTALL_LIB_DIR lib)
+#      set(KWSYS_INSTALL_INCLUDE_DIR include)
+#      set(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME Runtime)
+#      set(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT Development)
 
 # Once configured, kwsys should be used as follows from C or C++ code:
 #
@@ -86,33 +86,33 @@
 # any outside mailing list and no documentation of the change will be
 # written.
 
-CMAKE_MINIMUM_REQUIRED(VERSION 3.1 FATAL_ERROR)
-FOREACH(p
+cmake_minimum_required(VERSION 3.1 FATAL_ERROR)
+foreach(p
     CMP0056 # CMake 3.2, Honor link flags in try_compile() source-file signature.
     CMP0063 # CMake 3.3, Honor visibility properties for all target types.
     CMP0067 # CMake 3.8, Honor language standard in try_compile source-file signature.
     CMP0069 # CMake 3.9, INTERPROCEDURAL_OPTIMIZATION is enforced when enabled.
     )
-  IF(POLICY ${p})
-    CMAKE_POLICY(SET ${p} NEW)
-  ENDIF()
-ENDFOREACH()
+  if(POLICY ${p})
+    cmake_policy(SET ${p} NEW)
+  endif()
+endforeach()
 
 #-----------------------------------------------------------------------------
 # If a namespace is not specified, use "kwsys" and enable testing.
 # This should be the case only when kwsys is not included inside
 # another project and is being tested.
-IF(NOT KWSYS_NAMESPACE)
-  SET(KWSYS_NAMESPACE "kwsys")
-  SET(KWSYS_STANDALONE 1)
-ENDIF()
+if(NOT KWSYS_NAMESPACE)
+  set(KWSYS_NAMESPACE "kwsys")
+  set(KWSYS_STANDALONE 1)
+endif()
 
 #-----------------------------------------------------------------------------
 # The project name is that of the specified namespace.
-PROJECT(${KWSYS_NAMESPACE})
+project(${KWSYS_NAMESPACE})
 
 # Tell CMake how to follow dependencies of sources in this directory.
-SET_PROPERTY(DIRECTORY
+set_property(DIRECTORY
   PROPERTY IMPLICIT_DEPENDS_INCLUDE_TRANSFORM
   "KWSYS_HEADER(%)=<${KWSYS_NAMESPACE}/%>"
   )
@@ -131,229 +131,229 @@ elseif(NOT DEFINED CMAKE_CXX_STANDARD AND NOT DEFINED KWSYS_CXX_STANDARD)
 endif()
 
 # Select library components.
-IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
-  SET(KWSYS_ENABLE_C 1)
+if(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
+  set(KWSYS_ENABLE_C 1)
   # Enable all components.
-  SET(KWSYS_USE_Base64 1)
-  SET(KWSYS_USE_Directory 1)
-  SET(KWSYS_USE_DynamicLoader 1)
-  SET(KWSYS_USE_Encoding 1)
-  SET(KWSYS_USE_Glob 1)
-  SET(KWSYS_USE_MD5 1)
-  SET(KWSYS_USE_Process 1)
-  SET(KWSYS_USE_RegularExpression 1)
-  SET(KWSYS_USE_System 1)
-  SET(KWSYS_USE_SystemTools 1)
-  SET(KWSYS_USE_CommandLineArguments 1)
-  SET(KWSYS_USE_Terminal 1)
-  SET(KWSYS_USE_IOStream 1)
-  SET(KWSYS_USE_FStream 1)
-  SET(KWSYS_USE_String 1)
-  SET(KWSYS_USE_SystemInformation 1)
-  SET(KWSYS_USE_ConsoleBuf 1)
-ENDIF()
+  set(KWSYS_USE_Base64 1)
+  set(KWSYS_USE_Directory 1)
+  set(KWSYS_USE_DynamicLoader 1)
+  set(KWSYS_USE_Encoding 1)
+  set(KWSYS_USE_Glob 1)
+  set(KWSYS_USE_MD5 1)
+  set(KWSYS_USE_Process 1)
+  set(KWSYS_USE_RegularExpression 1)
+  set(KWSYS_USE_System 1)
+  set(KWSYS_USE_SystemTools 1)
+  set(KWSYS_USE_CommandLineArguments 1)
+  set(KWSYS_USE_Terminal 1)
+  set(KWSYS_USE_IOStream 1)
+  set(KWSYS_USE_FStream 1)
+  set(KWSYS_USE_String 1)
+  set(KWSYS_USE_SystemInformation 1)
+  set(KWSYS_USE_ConsoleBuf 1)
+endif()
 
 # Enforce component dependencies.
-IF(KWSYS_USE_SystemTools)
-  SET(KWSYS_USE_Directory 1)
-  SET(KWSYS_USE_FStream 1)
-  SET(KWSYS_USE_Encoding 1)
-ENDIF()
-IF(KWSYS_USE_Glob)
-  SET(KWSYS_USE_Directory 1)
-  SET(KWSYS_USE_SystemTools 1)
-  SET(KWSYS_USE_RegularExpression 1)
-  SET(KWSYS_USE_FStream 1)
-  SET(KWSYS_USE_Encoding 1)
-ENDIF()
-IF(KWSYS_USE_Process)
-  SET(KWSYS_USE_System 1)
-  SET(KWSYS_USE_Encoding 1)
-ENDIF()
-IF(KWSYS_USE_SystemInformation)
-  SET(KWSYS_USE_Process 1)
-ENDIF()
-IF(KWSYS_USE_System)
-  SET(KWSYS_USE_Encoding 1)
-ENDIF()
-IF(KWSYS_USE_Directory)
-  SET(KWSYS_USE_Encoding 1)
-ENDIF()
-IF(KWSYS_USE_DynamicLoader)
-  SET(KWSYS_USE_Encoding 1)
-ENDIF()
-IF(KWSYS_USE_FStream)
-  SET(KWSYS_USE_Encoding 1)
-ENDIF()
-IF(KWSYS_USE_ConsoleBuf)
-  SET(KWSYS_USE_Encoding 1)
-ENDIF()
+if(KWSYS_USE_SystemTools)
+  set(KWSYS_USE_Directory 1)
+  set(KWSYS_USE_FStream 1)
+  set(KWSYS_USE_Encoding 1)
+endif()
+if(KWSYS_USE_Glob)
+  set(KWSYS_USE_Directory 1)
+  set(KWSYS_USE_SystemTools 1)
+  set(KWSYS_USE_RegularExpression 1)
+  set(KWSYS_USE_FStream 1)
+  set(KWSYS_USE_Encoding 1)
+endif()
+if(KWSYS_USE_Process)
+  set(KWSYS_USE_System 1)
+  set(KWSYS_USE_Encoding 1)
+endif()
+if(KWSYS_USE_SystemInformation)
+  set(KWSYS_USE_Process 1)
+endif()
+if(KWSYS_USE_System)
+  set(KWSYS_USE_Encoding 1)
+endif()
+if(KWSYS_USE_Directory)
+  set(KWSYS_USE_Encoding 1)
+endif()
+if(KWSYS_USE_DynamicLoader)
+  set(KWSYS_USE_Encoding 1)
+endif()
+if(KWSYS_USE_FStream)
+  set(KWSYS_USE_Encoding 1)
+endif()
+if(KWSYS_USE_ConsoleBuf)
+  set(KWSYS_USE_Encoding 1)
+endif()
 
 # Specify default 8 bit encoding for Windows
-IF(NOT KWSYS_ENCODING_DEFAULT_CODEPAGE)
-  SET(KWSYS_ENCODING_DEFAULT_CODEPAGE CP_ACP)
-ENDIF()
+if(NOT KWSYS_ENCODING_DEFAULT_CODEPAGE)
+  set(KWSYS_ENCODING_DEFAULT_CODEPAGE CP_ACP)
+endif()
 
 # Enable testing if building standalone.
-IF(KWSYS_STANDALONE)
-  INCLUDE(Dart)
-  MARK_AS_ADVANCED(BUILD_TESTING DART_ROOT TCL_TCLSH)
-  IF(BUILD_TESTING)
-    ENABLE_TESTING()
-  ENDIF()
-ENDIF()
+if(KWSYS_STANDALONE)
+  include(Dart)
+  mark_as_advanced(BUILD_TESTING DART_ROOT TCL_TCLSH)
+  if(BUILD_TESTING)
+    enable_testing()
+  endif()
+endif()
 
 # Choose default shared/static build if not specified.
-IF(NOT DEFINED KWSYS_BUILD_SHARED)
-  SET(KWSYS_BUILD_SHARED ${BUILD_SHARED_LIBS})
-ENDIF()
+if(NOT DEFINED KWSYS_BUILD_SHARED)
+  set(KWSYS_BUILD_SHARED ${BUILD_SHARED_LIBS})
+endif()
 
 # Include helper macros.
-INCLUDE(${CMAKE_CURRENT_SOURCE_DIR}/kwsysPlatformTests.cmake)
-INCLUDE(CheckTypeSize)
+include(${CMAKE_CURRENT_SOURCE_DIR}/kwsysPlatformTests.cmake)
+include(CheckTypeSize)
 
 # Do full dependency headers.
-INCLUDE_REGULAR_EXPRESSION("^.*$")
+include_regular_expression("^.*$")
 
 # Use new KWSYS_INSTALL_*_DIR variable names to control installation.
 # Take defaults from the old names.  Note that there was no old name
 # for the bin dir, so we take the old lib dir name so DLLs will be
 # installed in a compatible way for old code.
-IF(NOT KWSYS_INSTALL_INCLUDE_DIR)
-  STRING(REGEX REPLACE "^/" "" KWSYS_INSTALL_INCLUDE_DIR
+if(NOT KWSYS_INSTALL_INCLUDE_DIR)
+  string(REGEX REPLACE "^/" "" KWSYS_INSTALL_INCLUDE_DIR
     "${KWSYS_HEADER_INSTALL_DIR}")
-ENDIF()
-IF(NOT KWSYS_INSTALL_LIB_DIR)
-  STRING(REGEX REPLACE "^/" "" KWSYS_INSTALL_LIB_DIR
+endif()
+if(NOT KWSYS_INSTALL_LIB_DIR)
+  string(REGEX REPLACE "^/" "" KWSYS_INSTALL_LIB_DIR
     "${KWSYS_LIBRARY_INSTALL_DIR}")
-ENDIF()
-IF(NOT KWSYS_INSTALL_BIN_DIR)
-  STRING(REGEX REPLACE "^/" "" KWSYS_INSTALL_BIN_DIR
+endif()
+if(NOT KWSYS_INSTALL_BIN_DIR)
+  string(REGEX REPLACE "^/" "" KWSYS_INSTALL_BIN_DIR
     "${KWSYS_LIBRARY_INSTALL_DIR}")
-ENDIF()
+endif()
 
 # Setup header install rules.
-SET(KWSYS_INSTALL_INCLUDE_OPTIONS)
-IF(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT)
-  SET(KWSYS_INSTALL_INCLUDE_OPTIONS ${KWSYS_INSTALL_INCLUDE_OPTIONS}
+set(KWSYS_INSTALL_INCLUDE_OPTIONS)
+if(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT)
+  set(KWSYS_INSTALL_INCLUDE_OPTIONS ${KWSYS_INSTALL_INCLUDE_OPTIONS}
     COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT}
     )
-ENDIF()
+endif()
 
 # Setup library install rules.
-SET(KWSYS_INSTALL_LIBRARY_RULE)
-SET(KWSYS_INSTALL_NAMELINK_RULE)
-IF(KWSYS_INSTALL_LIB_DIR)
-  IF(KWSYS_INSTALL_EXPORT_NAME)
-    LIST(APPEND KWSYS_INSTALL_LIBRARY_RULE EXPORT ${KWSYS_INSTALL_EXPORT_NAME})
-  ENDIF()
+set(KWSYS_INSTALL_LIBRARY_RULE)
+set(KWSYS_INSTALL_NAMELINK_RULE)
+if(KWSYS_INSTALL_LIB_DIR)
+  if(KWSYS_INSTALL_EXPORT_NAME)
+    list(APPEND KWSYS_INSTALL_LIBRARY_RULE EXPORT ${KWSYS_INSTALL_EXPORT_NAME})
+  endif()
   # Install the shared library to the lib directory.
-  SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
+  set(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
     LIBRARY DESTINATION ${KWSYS_INSTALL_LIB_DIR} NAMELINK_SKIP
     )
   # Assign the shared library to the runtime component.
-  IF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
-    SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
+  if(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
+    set(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
       COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_RUNTIME}
       )
-  ENDIF()
-  IF(KWSYS_BUILD_SHARED)
-    SET(KWSYS_INSTALL_NAMELINK_RULE ${KWSYS_INSTALL_NAMELINK_RULE}
+  endif()
+  if(KWSYS_BUILD_SHARED)
+    set(KWSYS_INSTALL_NAMELINK_RULE ${KWSYS_INSTALL_NAMELINK_RULE}
       LIBRARY DESTINATION ${KWSYS_INSTALL_LIB_DIR} NAMELINK_ONLY
       )
     # Assign the namelink to the development component.
-    IF(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT)
-      SET(KWSYS_INSTALL_NAMELINK_RULE ${KWSYS_INSTALL_NAMELINK_RULE}
+    if(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT)
+      set(KWSYS_INSTALL_NAMELINK_RULE ${KWSYS_INSTALL_NAMELINK_RULE}
         COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT}
         )
-    ENDIF()
-  ENDIF()
+    endif()
+  endif()
 
   # Install the archive to the lib directory.
-  SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
+  set(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
     ARCHIVE DESTINATION ${KWSYS_INSTALL_LIB_DIR}
     )
   # Assign the archive to the development component.
-  IF(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT)
-    SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
+  if(KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT)
+    set(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
       COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_DEVELOPMENT}
       )
-  ENDIF()
-ENDIF()
-IF(KWSYS_INSTALL_BIN_DIR)
+  endif()
+endif()
+if(KWSYS_INSTALL_BIN_DIR)
   # Install the runtime library to the bin directory.
-  SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
+  set(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
     RUNTIME DESTINATION ${KWSYS_INSTALL_BIN_DIR}
     )
   # Assign the runtime library to the runtime component.
-  IF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
-    SET(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
+  if(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
+    set(KWSYS_INSTALL_LIBRARY_RULE ${KWSYS_INSTALL_LIBRARY_RULE}
       COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_RUNTIME}
       )
-  ENDIF()
-ENDIF()
+  endif()
+endif()
 
 # Do not support old KWSYS_*a_INSTALL_DIR variable names.
-SET(KWSYS_HEADER_INSTALL_DIR)
-SET(KWSYS_LIBRARY_INSTALL_DIR)
+set(KWSYS_HEADER_INSTALL_DIR)
+set(KWSYS_LIBRARY_INSTALL_DIR)
 
 # Generated source files will need this header.
-STRING(COMPARE EQUAL "${PROJECT_SOURCE_DIR}" "${PROJECT_BINARY_DIR}"
+string(COMPARE EQUAL "${PROJECT_SOURCE_DIR}" "${PROJECT_BINARY_DIR}"
   KWSYS_IN_SOURCE_BUILD)
-IF(NOT KWSYS_IN_SOURCE_BUILD)
-  CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/kwsysPrivate.h
+if(NOT KWSYS_IN_SOURCE_BUILD)
+  configure_file(${PROJECT_SOURCE_DIR}/kwsysPrivate.h
     ${PROJECT_BINARY_DIR}/kwsysPrivate.h COPYONLY IMMEDIATE)
-ENDIF()
+endif()
 
 # Select plugin module file name convention.
-IF(NOT KWSYS_DynamicLoader_PREFIX)
-  SET(KWSYS_DynamicLoader_PREFIX ${CMAKE_SHARED_MODULE_PREFIX})
-ENDIF()
-IF(NOT KWSYS_DynamicLoader_SUFFIX)
-  SET(KWSYS_DynamicLoader_SUFFIX ${CMAKE_SHARED_MODULE_SUFFIX})
-ENDIF()
+if(NOT KWSYS_DynamicLoader_PREFIX)
+  set(KWSYS_DynamicLoader_PREFIX ${CMAKE_SHARED_MODULE_PREFIX})
+endif()
+if(NOT KWSYS_DynamicLoader_SUFFIX)
+  set(KWSYS_DynamicLoader_SUFFIX ${CMAKE_SHARED_MODULE_SUFFIX})
+endif()
 
 #-----------------------------------------------------------------------------
 # We require ANSI support from the C compiler.  Add any needed flags.
-IF(CMAKE_ANSI_CFLAGS)
-  SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_ANSI_CFLAGS}")
-ENDIF()
+if(CMAKE_ANSI_CFLAGS)
+  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CMAKE_ANSI_CFLAGS}")
+endif()
 
 #-----------------------------------------------------------------------------
 # Adjust compiler flags for some platforms.
-IF(NOT CMAKE_COMPILER_IS_GNUCXX)
-  IF(CMAKE_SYSTEM MATCHES "OSF1-V.*")
-    STRING(REGEX MATCH "-timplicit_local"
+if(NOT CMAKE_COMPILER_IS_GNUCXX)
+  if(CMAKE_SYSTEM MATCHES "OSF1-V.*")
+    string(REGEX MATCH "-timplicit_local"
       KWSYS_CXX_FLAGS_HAVE_IMPLICIT_LOCAL "${CMAKE_CXX_FLAGS}")
-    STRING(REGEX MATCH "-no_implicit_include"
+    string(REGEX MATCH "-no_implicit_include"
       KWSYS_CXX_FLAGS_HAVE_NO_IMPLICIT_INCLUDE "${CMAKE_CXX_FLAGS}")
-    IF(NOT KWSYS_CXX_FLAGS_HAVE_IMPLICIT_LOCAL)
-      SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -timplicit_local")
-    ENDIF()
-    IF(NOT KWSYS_CXX_FLAGS_HAVE_NO_IMPLICIT_INCLUDE)
-      SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -no_implicit_include")
-    ENDIF()
-  ENDIF()
-  IF(CMAKE_SYSTEM MATCHES "HP-UX")
-    SET(KWSYS_PLATFORM_CXX_TEST_EXTRA_FLAGS "+p")
-    IF(CMAKE_CXX_COMPILER_ID MATCHES "HP")
+    if(NOT KWSYS_CXX_FLAGS_HAVE_IMPLICIT_LOCAL)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -timplicit_local")
+    endif()
+    if(NOT KWSYS_CXX_FLAGS_HAVE_NO_IMPLICIT_INCLUDE)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -no_implicit_include")
+    endif()
+  endif()
+  if(CMAKE_SYSTEM MATCHES "HP-UX")
+    set(KWSYS_PLATFORM_CXX_TEST_EXTRA_FLAGS "+p")
+    if(CMAKE_CXX_COMPILER_ID MATCHES "HP")
       # it is known that version 3.85 fails and 6.25 works without these flags
-      IF(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4)
+      if(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 4)
         # use new C++ library and improved template support
-        SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -AA +hpxstd98")
-      ENDIF()
-    ENDIF()
-  ENDIF()
-ENDIF()
-IF(KWSYS_STANDALONE)
-  IF(CMAKE_CXX_COMPILER_ID STREQUAL SunPro)
-    IF(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.13)
-      SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++03")
-    ELSE()
-      SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -library=stlport4")
-    ENDIF()
-  ENDIF()
-ENDIF()
+        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -AA +hpxstd98")
+      endif()
+    endif()
+  endif()
+endif()
+if(KWSYS_STANDALONE)
+  if(CMAKE_CXX_COMPILER_ID STREQUAL SunPro)
+    if(NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 5.13)
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++03")
+    else()
+      set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -library=stlport4")
+    endif()
+  endif()
+endif()
 
 #-----------------------------------------------------------------------------
 # Configure the standard library header wrappers based on compiler's
@@ -365,75 +365,75 @@ KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_LONG_LONG
   "Checking whether C++ compiler has 'long long'" DIRECT)
 KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS___INT64
   "Checking whether C++ compiler has '__int64'" DIRECT)
-IF(KWSYS_CXX_HAS___INT64)
+if(KWSYS_CXX_HAS___INT64)
   KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_SAME_LONG_AND___INT64
     "Checking whether long and __int64 are the same type" DIRECT)
-  IF(KWSYS_CXX_HAS_LONG_LONG)
+  if(KWSYS_CXX_HAS_LONG_LONG)
     KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_SAME_LONG_LONG_AND___INT64
       "Checking whether long long and __int64 are the same type" DIRECT)
-  ENDIF()
-ENDIF()
+  endif()
+endif()
 
 # Enable the "long long" type if it is available.  It is standard in
 # C99 and C++03 but not in earlier standards.
-IF(KWSYS_CXX_HAS_LONG_LONG)
-  SET(KWSYS_USE_LONG_LONG 1)
-ELSE()
-  SET(KWSYS_USE_LONG_LONG 0)
-ENDIF()
+if(KWSYS_CXX_HAS_LONG_LONG)
+  set(KWSYS_USE_LONG_LONG 1)
+else()
+  set(KWSYS_USE_LONG_LONG 0)
+endif()
 
 # Enable the "__int64" type if it is available and unique.  It is not
 # standard.
-SET(KWSYS_USE___INT64 0)
-IF(KWSYS_CXX_HAS___INT64)
-  IF(NOT KWSYS_CXX_SAME_LONG_AND___INT64)
-    IF(NOT KWSYS_CXX_SAME_LONG_LONG_AND___INT64)
-      SET(KWSYS_USE___INT64 1)
-    ENDIF()
-  ENDIF()
-ENDIF()
-
-IF(KWSYS_USE_Encoding)
+set(KWSYS_USE___INT64 0)
+if(KWSYS_CXX_HAS___INT64)
+  if(NOT KWSYS_CXX_SAME_LONG_AND___INT64)
+    if(NOT KWSYS_CXX_SAME_LONG_LONG_AND___INT64)
+      set(KWSYS_USE___INT64 1)
+    endif()
+  endif()
+endif()
+
+if(KWSYS_USE_Encoding)
   # Look for type size helper macros.
   KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_WSTRING
     "Checking whether wstring is available" DIRECT)
-ENDIF()
+endif()
 
-IF(KWSYS_USE_IOStream)
+if(KWSYS_USE_IOStream)
   # Determine whether iostreams support long long.
-  IF(KWSYS_CXX_HAS_LONG_LONG)
+  if(KWSYS_CXX_HAS_LONG_LONG)
     KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_HAS_ISTREAM_LONG_LONG
       "Checking if istream supports long long" DIRECT)
     KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_HAS_OSTREAM_LONG_LONG
       "Checking if ostream supports long long" DIRECT)
-  ELSE()
-    SET(KWSYS_IOS_HAS_ISTREAM_LONG_LONG 0)
-    SET(KWSYS_IOS_HAS_OSTREAM_LONG_LONG 0)
-  ENDIF()
-  IF(KWSYS_CXX_HAS___INT64)
+  else()
+    set(KWSYS_IOS_HAS_ISTREAM_LONG_LONG 0)
+    set(KWSYS_IOS_HAS_OSTREAM_LONG_LONG 0)
+  endif()
+  if(KWSYS_CXX_HAS___INT64)
     KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_HAS_ISTREAM___INT64
       "Checking if istream supports __int64" DIRECT)
     KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_HAS_OSTREAM___INT64
       "Checking if ostream supports __int64" DIRECT)
-  ELSE()
-    SET(KWSYS_IOS_HAS_ISTREAM___INT64 0)
-    SET(KWSYS_IOS_HAS_OSTREAM___INT64 0)
-  ENDIF()
-ENDIF()
-
-IF(KWSYS_NAMESPACE MATCHES "^kwsys$")
-  SET(KWSYS_NAME_IS_KWSYS 1)
-ELSE()
-  SET(KWSYS_NAME_IS_KWSYS 0)
-ENDIF()
-
-IF(KWSYS_BUILD_SHARED)
-  SET(KWSYS_BUILD_SHARED 1)
-  SET(KWSYS_LIBRARY_TYPE SHARED)
-ELSE()
-  SET(KWSYS_BUILD_SHARED 0)
-  SET(KWSYS_LIBRARY_TYPE STATIC)
-ENDIF()
+  else()
+    set(KWSYS_IOS_HAS_ISTREAM___INT64 0)
+    set(KWSYS_IOS_HAS_OSTREAM___INT64 0)
+  endif()
+endif()
+
+if(KWSYS_NAMESPACE MATCHES "^kwsys$")
+  set(KWSYS_NAME_IS_KWSYS 1)
+else()
+  set(KWSYS_NAME_IS_KWSYS 0)
+endif()
+
+if(KWSYS_BUILD_SHARED)
+  set(KWSYS_BUILD_SHARED 1)
+  set(KWSYS_LIBRARY_TYPE SHARED)
+else()
+  set(KWSYS_BUILD_SHARED 0)
+  set(KWSYS_LIBRARY_TYPE STATIC)
+endif()
 
 if(NOT DEFINED KWSYS_BUILD_PIC)
   set(KWSYS_BUILD_PIC 0)
@@ -446,32 +446,32 @@ KWSYS_PLATFORM_C_TEST(KWSYS_C_HAS_PTRDIFF_T
   "Checking whether C compiler has ptrdiff_t in stddef.h" DIRECT)
 KWSYS_PLATFORM_C_TEST(KWSYS_C_HAS_SSIZE_T
   "Checking whether C compiler has ssize_t in unistd.h" DIRECT)
-IF(KWSYS_USE_Process)
+if(KWSYS_USE_Process)
   KWSYS_PLATFORM_C_TEST(KWSYS_C_HAS_CLOCK_GETTIME_MONOTONIC
     "Checking whether C compiler has clock_gettime" DIRECT)
-ENDIF()
+endif()
 
-SET_SOURCE_FILES_PROPERTIES(ProcessUNIX.c System.c PROPERTIES
+set_source_files_properties(ProcessUNIX.c System.c PROPERTIES
   COMPILE_FLAGS "-DKWSYS_C_HAS_PTRDIFF_T=${KWSYS_C_HAS_PTRDIFF_T} -DKWSYS_C_HAS_SSIZE_T=${KWSYS_C_HAS_SSIZE_T} -DKWSYS_C_HAS_CLOCK_GETTIME_MONOTONIC=${KWSYS_C_HAS_CLOCK_GETTIME_MONOTONIC}"
   )
 
-IF(DEFINED KWSYS_PROCESS_USE_SELECT)
-  GET_PROPERTY(ProcessUNIX_FLAGS SOURCE ProcessUNIX.c PROPERTY COMPILE_FLAGS)
-  SET_PROPERTY(SOURCE ProcessUNIX.c PROPERTY COMPILE_FLAGS "${ProcessUNIX_FLAGS} -DKWSYSPE_USE_SELECT=${KWSYSPE_USE_SELECT}")
-ENDIF()
-
-IF(KWSYS_USE_DynamicLoader)
-  GET_PROPERTY(KWSYS_SUPPORTS_SHARED_LIBS GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS)
-  IF(KWSYS_SUPPORTS_SHARED_LIBS)
-    SET(KWSYS_SUPPORTS_SHARED_LIBS 1)
-  ELSE()
-    SET(KWSYS_SUPPORTS_SHARED_LIBS 0)
-  ENDIF()
-  SET_PROPERTY(SOURCE DynamicLoader.cxx APPEND PROPERTY COMPILE_DEFINITIONS
+if(DEFINED KWSYS_PROCESS_USE_SELECT)
+  get_property(ProcessUNIX_FLAGS SOURCE ProcessUNIX.c PROPERTY COMPILE_FLAGS)
+  set_property(SOURCE ProcessUNIX.c PROPERTY COMPILE_FLAGS "${ProcessUNIX_FLAGS} -DKWSYSPE_USE_SELECT=${KWSYSPE_USE_SELECT}")
+endif()
+
+if(KWSYS_USE_DynamicLoader)
+  get_property(KWSYS_SUPPORTS_SHARED_LIBS GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS)
+  if(KWSYS_SUPPORTS_SHARED_LIBS)
+    set(KWSYS_SUPPORTS_SHARED_LIBS 1)
+  else()
+    set(KWSYS_SUPPORTS_SHARED_LIBS 0)
+  endif()
+  set_property(SOURCE DynamicLoader.cxx APPEND PROPERTY COMPILE_DEFINITIONS
     KWSYS_SUPPORTS_SHARED_LIBS=${KWSYS_SUPPORTS_SHARED_LIBS})
-ENDIF()
+endif()
 
-IF(KWSYS_USE_SystemTools)
+if(KWSYS_USE_SystemTools)
   if (NOT DEFINED KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP)
     set(KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP 1)
   endif ()
@@ -494,7 +494,7 @@ IF(KWSYS_USE_SystemTools)
     "Checking whether CXX compiler struct stat has st_mtim member" DIRECT)
   KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_STAT_HAS_ST_MTIMESPEC
     "Checking whether CXX compiler struct stat has st_mtimespec member" DIRECT)
-  SET_PROPERTY(SOURCE SystemTools.cxx APPEND PROPERTY COMPILE_DEFINITIONS
+  set_property(SOURCE SystemTools.cxx APPEND PROPERTY COMPILE_DEFINITIONS
     KWSYS_CXX_HAS_SETENV=${KWSYS_CXX_HAS_SETENV}
     KWSYS_CXX_HAS_UNSETENV=${KWSYS_CXX_HAS_UNSETENV}
     KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H=${KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H}
@@ -503,623 +503,623 @@ IF(KWSYS_USE_SystemTools)
     KWSYS_CXX_STAT_HAS_ST_MTIM=${KWSYS_CXX_STAT_HAS_ST_MTIM}
     KWSYS_CXX_STAT_HAS_ST_MTIMESPEC=${KWSYS_CXX_STAT_HAS_ST_MTIMESPEC}
     )
-  IF(NOT WIN32)
-    IF(KWSYS_STANDALONE)
-      OPTION(KWSYS_SYSTEMTOOLS_SUPPORT_WINDOWS_SLASHES "If true, Windows paths will be supported on Unix as well" ON)
-    ENDIF()
-    IF(KWSYS_SYSTEMTOOLS_SUPPORT_WINDOWS_SLASHES)
-      SET_PROPERTY(SOURCE SystemTools.cxx testSystemTools.cxx APPEND PROPERTY COMPILE_DEFINITIONS
+  if(NOT WIN32)
+    if(KWSYS_STANDALONE)
+      option(KWSYS_SYSTEMTOOLS_SUPPORT_WINDOWS_SLASHES "If true, Windows paths will be supported on Unix as well" ON)
+    endif()
+    if(KWSYS_SYSTEMTOOLS_SUPPORT_WINDOWS_SLASHES)
+      set_property(SOURCE SystemTools.cxx testSystemTools.cxx APPEND PROPERTY COMPILE_DEFINITIONS
         KWSYS_SYSTEMTOOLS_SUPPORT_WINDOWS_SLASHES
         )
-    ENDIF()
-  ENDIF()
+    endif()
+  endif()
 
   # Disable getpwnam for static linux builds since it depends on shared glibc
-  GET_PROPERTY(SHARED_LIBS_SUPPORTED GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS)
-  IF(CMAKE_SYSTEM_NAME MATCHES "Linux" AND NOT SHARED_LIBS_SUPPORTED)
-    SET_PROPERTY(SOURCE SystemTools.cxx APPEND PROPERTY COMPILE_DEFINITIONS
+  get_property(SHARED_LIBS_SUPPORTED GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS)
+  if(CMAKE_SYSTEM_NAME MATCHES "Linux" AND NOT SHARED_LIBS_SUPPORTED)
+    set_property(SOURCE SystemTools.cxx APPEND PROPERTY COMPILE_DEFINITIONS
       HAVE_GETPWNAM=0
       )
-  ENDIF()
-ENDIF()
+  endif()
+endif()
 
-IF(KWSYS_USE_SystemInformation)
-  SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
+if(KWSYS_USE_SystemInformation)
+  set_property(SOURCE SystemInformation.cxx APPEND PROPERTY
     COMPILE_DEFINITIONS SIZEOF_VOID_P=${CMAKE_SIZEOF_VOID_P})
-  IF(NOT CYGWIN)
-    INCLUDE(CheckIncludeFiles)
+  if(NOT CYGWIN)
+    include(CheckIncludeFiles)
     CHECK_INCLUDE_FILES("sys/types.h;ifaddrs.h" KWSYS_SYS_HAS_IFADDRS_H)
-    IF(KWSYS_SYS_HAS_IFADDRS_H)
-      SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
+    if(KWSYS_SYS_HAS_IFADDRS_H)
+      set_property(SOURCE SystemInformation.cxx APPEND PROPERTY
         COMPILE_DEFINITIONS KWSYS_SYS_HAS_IFADDRS_H=1)
-    ENDIF()
-  ENDIF()
-  IF(WIN32)
-    INCLUDE(CheckSymbolExists)
-    SET(CMAKE_REQUIRED_LIBRARIES psapi)
+    endif()
+  endif()
+  if(WIN32)
+    include(CheckSymbolExists)
+    set(CMAKE_REQUIRED_LIBRARIES psapi)
     CHECK_SYMBOL_EXISTS(GetProcessMemoryInfo "windows.h;psapi.h" KWSYS_SYS_HAS_PSAPI)
-    UNSET(CMAKE_REQUIRED_LIBRARIES)
-    IF(KWSYS_SYS_HAS_PSAPI)
-      SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
+    unset(CMAKE_REQUIRED_LIBRARIES)
+    if(KWSYS_SYS_HAS_PSAPI)
+      set_property(SOURCE SystemInformation.cxx APPEND PROPERTY
         COMPILE_DEFINITIONS KWSYS_SYS_HAS_PSAPI=1)
-      IF(MSVC70 OR MSVC71)
+      if(MSVC70 OR MSVC71)
         # Suppress LNK4089: all references to 'PSAPI.DLL' discarded by /OPT:REF
-        SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /IGNORE:4089")
-      ENDIF()
-    ENDIF()
-  ENDIF()
-  IF(CMAKE_SYSTEM MATCHES "HP-UX")
+        set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} /IGNORE:4089")
+      endif()
+    endif()
+  endif()
+  if(CMAKE_SYSTEM MATCHES "HP-UX")
     CHECK_INCLUDE_FILES("sys/mpctl.h" KWSYS_SYS_HAS_MPCTL_H)
-    IF(KWSYS_SYS_HAS_MPCTL_H)
-      SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
+    if(KWSYS_SYS_HAS_MPCTL_H)
+      set_property(SOURCE SystemInformation.cxx APPEND PROPERTY
         COMPILE_DEFINITIONS KWSYS_SYS_HAS_MPCTL_H=1)
-    ENDIF()
-  ENDIF()
-  IF(CMAKE_SYSTEM MATCHES "BSD")
+    endif()
+  endif()
+  if(CMAKE_SYSTEM MATCHES "BSD")
     CHECK_INCLUDE_FILES("machine/cpu.h" KWSYS_SYS_HAS_MACHINE_CPU_H)
-    IF(KWSYS_SYS_HAS_MACHINE_CPU_H)
-      SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
+    if(KWSYS_SYS_HAS_MACHINE_CPU_H)
+      set_property(SOURCE SystemInformation.cxx APPEND PROPERTY
         COMPILE_DEFINITIONS KWSYS_SYS_HAS_MACHINE_CPU_H=1)
-    ENDIF()
-  ENDIF()
+    endif()
+  endif()
   KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_RLIMIT64
     "Checking whether CXX compiler has rlimit64" DIRECT)
-  SET(KWSYS_PLATFORM_CXX_TEST_DEFINES)
-  IF(KWSYS_CXX_HAS_RLIMIT64)
-    SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
+  set(KWSYS_PLATFORM_CXX_TEST_DEFINES)
+  if(KWSYS_CXX_HAS_RLIMIT64)
+    set_property(SOURCE SystemInformation.cxx APPEND PROPERTY
       COMPILE_DEFINITIONS KWSYS_CXX_HAS_RLIMIT64=1)
-  ENDIF()
+  endif()
   KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_ATOL
     "Checking whether CXX compiler has atol" DIRECT)
-  IF(KWSYS_CXX_HAS_ATOL)
-    SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
+  if(KWSYS_CXX_HAS_ATOL)
+    set_property(SOURCE SystemInformation.cxx APPEND PROPERTY
       COMPILE_DEFINITIONS KWSYS_CXX_HAS_ATOL=1)
-  ENDIF()
+  endif()
   KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_ATOLL
     "Checking whether CXX compiler has atoll" DIRECT)
-  IF(KWSYS_CXX_HAS_ATOLL)
-    SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
+  if(KWSYS_CXX_HAS_ATOLL)
+    set_property(SOURCE SystemInformation.cxx APPEND PROPERTY
       COMPILE_DEFINITIONS KWSYS_CXX_HAS_ATOLL=1)
-  ENDIF()
+  endif()
   KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS__ATOI64
     "Checking whether CXX compiler has _atoi64" DIRECT)
-  IF(KWSYS_CXX_HAS__ATOI64)
-    SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
+  if(KWSYS_CXX_HAS__ATOI64)
+    set_property(SOURCE SystemInformation.cxx APPEND PROPERTY
       COMPILE_DEFINITIONS KWSYS_CXX_HAS__ATOI64=1)
-  ENDIF()
-  IF(UNIX)
-    INCLUDE(CheckIncludeFileCXX)
+  endif()
+  if(UNIX)
+    include(CheckIncludeFileCXX)
     # check for simple stack trace
     # usually it's in libc but on FreeBSD
     # it's in libexecinfo
-    FIND_LIBRARY(EXECINFO_LIB "execinfo")
-    MARK_AS_ADVANCED(EXECINFO_LIB)
-    IF (NOT EXECINFO_LIB)
-      SET(EXECINFO_LIB "")
-    ENDIF()
+    find_library(EXECINFO_LIB "execinfo")
+    mark_as_advanced(EXECINFO_LIB)
+    if (NOT EXECINFO_LIB)
+      set(EXECINFO_LIB "")
+    endif()
     CHECK_INCLUDE_FILE_CXX("execinfo.h" KWSYS_CXX_HAS_EXECINFOH)
-    IF (KWSYS_CXX_HAS_EXECINFOH)
+    if (KWSYS_CXX_HAS_EXECINFOH)
       # we have the backtrace header check if it
       # can be used with this compiler
-      SET(KWSYS_PLATFORM_CXX_TEST_LINK_LIBRARIES ${EXECINFO_LIB})
+      set(KWSYS_PLATFORM_CXX_TEST_LINK_LIBRARIES ${EXECINFO_LIB})
       KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_BACKTRACE
          "Checking whether backtrace works with this C++ compiler" DIRECT)
-      SET(KWSYS_PLATFORM_CXX_TEST_LINK_LIBRARIES)
-      IF (KWSYS_CXX_HAS_BACKTRACE)
+      set(KWSYS_PLATFORM_CXX_TEST_LINK_LIBRARIES)
+      if (KWSYS_CXX_HAS_BACKTRACE)
         # backtrace is supported by this system and compiler.
         # now check for the more advanced capabilities.
-        SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
+        set_property(SOURCE SystemInformation.cxx APPEND PROPERTY
           COMPILE_DEFINITIONS KWSYS_SYSTEMINFORMATION_HAS_BACKTRACE=1)
         # check for symbol lookup using dladdr
         CHECK_INCLUDE_FILE_CXX("dlfcn.h" KWSYS_CXX_HAS_DLFCNH)
-        IF (KWSYS_CXX_HAS_DLFCNH)
+        if (KWSYS_CXX_HAS_DLFCNH)
           # we have symbol lookup libraries and headers
           # check if they can be used with this compiler
-          SET(KWSYS_PLATFORM_CXX_TEST_LINK_LIBRARIES ${CMAKE_DL_LIBS})
+          set(KWSYS_PLATFORM_CXX_TEST_LINK_LIBRARIES ${CMAKE_DL_LIBS})
             KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_DLADDR
             "Checking whether dladdr works with this C++ compiler" DIRECT)
-          SET(KWSYS_PLATFORM_CXX_TEST_LINK_LIBRARIES)
-          IF (KWSYS_CXX_HAS_DLADDR)
+          set(KWSYS_PLATFORM_CXX_TEST_LINK_LIBRARIES)
+          if (KWSYS_CXX_HAS_DLADDR)
             # symbol lookup is supported by this system
             # and compiler.
-            SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
+            set_property(SOURCE SystemInformation.cxx APPEND PROPERTY
               COMPILE_DEFINITIONS KWSYS_SYSTEMINFORMATION_HAS_SYMBOL_LOOKUP=1)
-          ENDIF()
-        ENDIF()
+          endif()
+        endif()
         # c++ demangling support
         # check for cxxabi headers
         CHECK_INCLUDE_FILE_CXX("cxxabi.h" KWSYS_CXX_HAS_CXXABIH)
-        IF (KWSYS_CXX_HAS_CXXABIH)
+        if (KWSYS_CXX_HAS_CXXABIH)
           # check if cxxabi can be used with this
           # system and compiler.
           KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_CXXABI
             "Checking whether cxxabi works with this C++ compiler" DIRECT)
-          IF (KWSYS_CXX_HAS_CXXABI)
+          if (KWSYS_CXX_HAS_CXXABI)
             # c++ demangle using cxxabi is supported with
             # this system and compiler
-            SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
+            set_property(SOURCE SystemInformation.cxx APPEND PROPERTY
               COMPILE_DEFINITIONS KWSYS_SYSTEMINFORMATION_HAS_CPP_DEMANGLE=1)
-          ENDIF()
-        ENDIF()
+          endif()
+        endif()
         # basic backtrace works better with release build
         # don't bother with advanced features for release
-        SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
+        set_property(SOURCE SystemInformation.cxx APPEND PROPERTY
           COMPILE_DEFINITIONS_DEBUG KWSYS_SYSTEMINFORMATION_HAS_DEBUG_BUILD=1)
-        SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
+        set_property(SOURCE SystemInformation.cxx APPEND PROPERTY
           COMPILE_DEFINITIONS_RELWITHDEBINFO KWSYS_SYSTEMINFORMATION_HAS_DEBUG_BUILD=1)
-      ENDIF()
-    ENDIF()
-  ENDIF()
-  IF(BORLAND)
+      endif()
+    endif()
+  endif()
+  if(BORLAND)
     KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_BORLAND_ASM
       "Checking whether Borland CXX compiler supports assembler instructions" DIRECT)
-    IF(KWSYS_CXX_HAS_BORLAND_ASM)
-      SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
+    if(KWSYS_CXX_HAS_BORLAND_ASM)
+      set_property(SOURCE SystemInformation.cxx APPEND PROPERTY
         COMPILE_DEFINITIONS KWSYS_CXX_HAS_BORLAND_ASM=1)
       KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_BORLAND_ASM_CPUID
         "Checking whether Borland CXX compiler supports CPUID assembler instruction" DIRECT)
-      IF(KWSYS_CXX_HAS_BORLAND_ASM_CPUID)
-        SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
+      if(KWSYS_CXX_HAS_BORLAND_ASM_CPUID)
+        set_property(SOURCE SystemInformation.cxx APPEND PROPERTY
           COMPILE_DEFINITIONS KWSYS_CXX_HAS_BORLAND_ASM_CPUID=1)
-      ENDIF()
-    ENDIF()
-  ENDIF()
-  IF(KWSYS_USE___INT64)
-    SET_PROPERTY(SOURCE SystemInformation.cxx testSystemInformation.cxx APPEND PROPERTY
+      endif()
+    endif()
+  endif()
+  if(KWSYS_USE___INT64)
+    set_property(SOURCE SystemInformation.cxx testSystemInformation.cxx APPEND PROPERTY
       COMPILE_DEFINITIONS KWSYS_USE___INT64=1)
-  ENDIF()
-  IF(KWSYS_USE_LONG_LONG)
-    SET_PROPERTY(SOURCE SystemInformation.cxx testSystemInformation.cxx APPEND PROPERTY
+  endif()
+  if(KWSYS_USE_LONG_LONG)
+    set_property(SOURCE SystemInformation.cxx testSystemInformation.cxx APPEND PROPERTY
       COMPILE_DEFINITIONS KWSYS_USE_LONG_LONG=1)
-  ENDIF()
-  IF(KWSYS_IOS_HAS_OSTREAM_LONG_LONG)
-    SET_PROPERTY(SOURCE SystemInformation.cxx testSystemInformation.cxx APPEND PROPERTY
+  endif()
+  if(KWSYS_IOS_HAS_OSTREAM_LONG_LONG)
+    set_property(SOURCE SystemInformation.cxx testSystemInformation.cxx APPEND PROPERTY
       COMPILE_DEFINITIONS KWSYS_IOS_HAS_OSTREAM_LONG_LONG=1)
-  ENDIF()
-  IF(KWSYS_IOS_HAS_OSTREAM___INT64)
-    SET_PROPERTY(SOURCE SystemInformation.cxx testSystemInformation.cxx APPEND PROPERTY
+  endif()
+  if(KWSYS_IOS_HAS_OSTREAM___INT64)
+    set_property(SOURCE SystemInformation.cxx testSystemInformation.cxx APPEND PROPERTY
       COMPILE_DEFINITIONS KWSYS_IOS_HAS_OSTREAM___INT64=1)
-  ENDIF()
-  IF(KWSYS_BUILD_SHARED)
-    SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
+  endif()
+  if(KWSYS_BUILD_SHARED)
+    set_property(SOURCE SystemInformation.cxx APPEND PROPERTY
       COMPILE_DEFINITIONS KWSYS_BUILD_SHARED=1)
-  ENDIF()
+  endif()
 
-  IF(UNIX AND NOT CYGWIN)
+  if(UNIX AND NOT CYGWIN)
     KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_GETLOADAVG
       "Checking whether CXX compiler has getloadavg" DIRECT)
-    IF(KWSYS_CXX_HAS_GETLOADAVG)
-      SET_PROPERTY(SOURCE SystemInformation.cxx APPEND PROPERTY
+    if(KWSYS_CXX_HAS_GETLOADAVG)
+      set_property(SOURCE SystemInformation.cxx APPEND PROPERTY
         COMPILE_DEFINITIONS KWSYS_CXX_HAS_GETLOADAVG=1)
-    ENDIF()
-  ENDIF()
-ENDIF()
+    endif()
+  endif()
+endif()
 
-IF(KWSYS_USE_FStream)
+if(KWSYS_USE_FStream)
   KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H
     "Checking whether <ext/stdio_filebuf.h> is available" DIRECT)
-ENDIF()
+endif()
 
 #-----------------------------------------------------------------------------
 # Choose a directory for the generated headers.
-IF(NOT KWSYS_HEADER_ROOT)
-  SET(KWSYS_HEADER_ROOT "${PROJECT_BINARY_DIR}")
-ENDIF()
-SET(KWSYS_HEADER_DIR "${KWSYS_HEADER_ROOT}/${KWSYS_NAMESPACE}")
-INCLUDE_DIRECTORIES(${KWSYS_HEADER_ROOT})
+if(NOT KWSYS_HEADER_ROOT)
+  set(KWSYS_HEADER_ROOT "${PROJECT_BINARY_DIR}")
+endif()
+set(KWSYS_HEADER_DIR "${KWSYS_HEADER_ROOT}/${KWSYS_NAMESPACE}")
+include_directories(${KWSYS_HEADER_ROOT})
 
 #-----------------------------------------------------------------------------
-IF(KWSYS_INSTALL_DOC_DIR)
+if(KWSYS_INSTALL_DOC_DIR)
   # Assign the license to the runtime component since it must be
   # distributed with binary forms of this software.
-  IF(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
-    SET(KWSYS_INSTALL_LICENSE_OPTIONS ${KWSYS_INSTALL_LICENSE_OPTIONS}
+  if(KWSYS_INSTALL_COMPONENT_NAME_RUNTIME)
+    set(KWSYS_INSTALL_LICENSE_OPTIONS ${KWSYS_INSTALL_LICENSE_OPTIONS}
       COMPONENT ${KWSYS_INSTALL_COMPONENT_NAME_RUNTIME}
       )
-  ENDIF()
+  endif()
 
   # Install the license under the documentation directory.
-  INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/Copyright.txt
+  install(FILES ${CMAKE_CURRENT_SOURCE_DIR}/Copyright.txt
     DESTINATION ${KWSYS_INSTALL_DOC_DIR}/${KWSYS_NAMESPACE}
     ${KWSYS_INSTALL_LICENSE_OPTIONS})
-ENDIF()
+endif()
 
 #-----------------------------------------------------------------------------
 # Build a list of classes and headers we need to implement the
 # selected components.  Initialize with required components.
-SET(KWSYS_CLASSES)
-SET(KWSYS_H_FILES Configure SharedForward)
-SET(KWSYS_HXX_FILES Configure String)
+set(KWSYS_CLASSES)
+set(KWSYS_H_FILES Configure SharedForward)
+set(KWSYS_HXX_FILES Configure String)
 
-IF(NOT CMake_SOURCE_DIR)
-  SET(KWSYS_HXX_FILES ${KWSYS_HXX_FILES}
+if(NOT CMake_SOURCE_DIR)
+  set(KWSYS_HXX_FILES ${KWSYS_HXX_FILES}
     hashtable hash_fun hash_map hash_set
     )
-ENDIF()
+endif()
 
 # Add selected C++ classes.
-SET(cppclasses
+set(cppclasses
   Directory DynamicLoader Encoding Glob RegularExpression SystemTools
   CommandLineArguments IOStream FStream SystemInformation ConsoleBuf
   )
-FOREACH(cpp ${cppclasses})
-  IF(KWSYS_USE_${cpp})
+foreach(cpp ${cppclasses})
+  if(KWSYS_USE_${cpp})
     # Use the corresponding class.
-    SET(KWSYS_CLASSES ${KWSYS_CLASSES} ${cpp})
+    set(KWSYS_CLASSES ${KWSYS_CLASSES} ${cpp})
 
     # Load component-specific CMake code.
-    IF(EXISTS ${PROJECT_SOURCE_DIR}/kwsys${cpp}.cmake)
-      INCLUDE(${PROJECT_SOURCE_DIR}/kwsys${cpp}.cmake)
-    ENDIF()
-  ENDIF()
-ENDFOREACH()
+    if(EXISTS ${PROJECT_SOURCE_DIR}/kwsys${cpp}.cmake)
+      include(${PROJECT_SOURCE_DIR}/kwsys${cpp}.cmake)
+    endif()
+  endif()
+endforeach()
 
 # Add selected C components.
-FOREACH(c
+foreach(c
     Process Base64 Encoding MD5 Terminal System String
     )
-  IF(KWSYS_USE_${c})
+  if(KWSYS_USE_${c})
     # Use the corresponding header file.
-    SET(KWSYS_H_FILES ${KWSYS_H_FILES} ${c})
+    set(KWSYS_H_FILES ${KWSYS_H_FILES} ${c})
 
     # Load component-specific CMake code.
-    IF(EXISTS ${PROJECT_SOURCE_DIR}/kwsys${c}.cmake)
-      INCLUDE(${PROJECT_SOURCE_DIR}/kwsys${c}.cmake)
-    ENDIF()
-  ENDIF()
-ENDFOREACH()
+    if(EXISTS ${PROJECT_SOURCE_DIR}/kwsys${c}.cmake)
+      include(${PROJECT_SOURCE_DIR}/kwsys${c}.cmake)
+    endif()
+  endif()
+endforeach()
 
 #-----------------------------------------------------------------------------
 # Build a list of sources for the library based on components that are
 # included.
-SET(KWSYS_C_SRCS)
-SET(KWSYS_CXX_SRCS)
+set(KWSYS_C_SRCS)
+set(KWSYS_CXX_SRCS)
 
 # Add the proper sources for this platform's Process implementation.
-IF(KWSYS_USE_Process)
-  IF(NOT UNIX)
+if(KWSYS_USE_Process)
+  if(NOT UNIX)
     # Use the Windows implementation.
-    SET(KWSYS_C_SRCS ${KWSYS_C_SRCS} ProcessWin32.c)
-  ELSE()
+    set(KWSYS_C_SRCS ${KWSYS_C_SRCS} ProcessWin32.c)
+  else()
     # Use the UNIX implementation.
-    SET(KWSYS_C_SRCS ${KWSYS_C_SRCS} ProcessUNIX.c)
-  ENDIF()
-ENDIF()
+    set(KWSYS_C_SRCS ${KWSYS_C_SRCS} ProcessUNIX.c)
+  endif()
+endif()
 
 # Add selected C sources.
-FOREACH(c Base64 Encoding MD5 Terminal System String)
-  IF(KWSYS_USE_${c})
-    IF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${c}C.c)
-      LIST(APPEND KWSYS_C_SRCS ${c}C.c)
-    ELSE()
-      LIST(APPEND KWSYS_C_SRCS ${c}.c)
-    ENDIF()
-  ENDIF()
-ENDFOREACH()
+foreach(c Base64 Encoding MD5 Terminal System String)
+  if(KWSYS_USE_${c})
+    if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${c}C.c)
+      list(APPEND KWSYS_C_SRCS ${c}C.c)
+    else()
+      list(APPEND KWSYS_C_SRCS ${c}.c)
+    endif()
+  endif()
+endforeach()
 
 # Configure headers of C++ classes and construct the list of sources.
-FOREACH(c ${KWSYS_CLASSES})
+foreach(c ${KWSYS_CLASSES})
   # Add this source to the list of source files for the library.
-  IF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${c}CXX.cxx)
-    LIST(APPEND KWSYS_CXX_SRCS ${c}CXX.cxx)
-  ELSEIF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${c}.cxx)
-    LIST(APPEND KWSYS_CXX_SRCS ${c}.cxx)
-  ENDIF()
+  if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${c}CXX.cxx)
+    list(APPEND KWSYS_CXX_SRCS ${c}CXX.cxx)
+  elseif(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${c}.cxx)
+    list(APPEND KWSYS_CXX_SRCS ${c}.cxx)
+  endif()
 
   # Configure the header for this class.
-  CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/${c}.hxx.in ${KWSYS_HEADER_DIR}/${c}.hxx
+  configure_file(${PROJECT_SOURCE_DIR}/${c}.hxx.in ${KWSYS_HEADER_DIR}/${c}.hxx
                  @ONLY IMMEDIATE)
-  SET(KWSYS_CXX_SRCS ${KWSYS_CXX_SRCS} ${KWSYS_HEADER_DIR}/${c}.hxx)
+  set(KWSYS_CXX_SRCS ${KWSYS_CXX_SRCS} ${KWSYS_HEADER_DIR}/${c}.hxx)
 
   # Create an install target for the header.
-  IF(KWSYS_INSTALL_INCLUDE_DIR)
-    INSTALL(FILES ${KWSYS_HEADER_DIR}/${c}.hxx
+  if(KWSYS_INSTALL_INCLUDE_DIR)
+    install(FILES ${KWSYS_HEADER_DIR}/${c}.hxx
       DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}
       ${KWSYS_INSTALL_INCLUDE_OPTIONS})
-  ENDIF()
-ENDFOREACH()
+  endif()
+endforeach()
 
 # Configure C headers.
-FOREACH(h ${KWSYS_H_FILES})
+foreach(h ${KWSYS_H_FILES})
   # Configure the header into the given directory.
-  CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/${h}.h.in ${KWSYS_HEADER_DIR}/${h}.h
+  configure_file(${PROJECT_SOURCE_DIR}/${h}.h.in ${KWSYS_HEADER_DIR}/${h}.h
                  @ONLY IMMEDIATE)
-  SET(KWSYS_C_SRCS ${KWSYS_C_SRCS} ${KWSYS_HEADER_DIR}/${h}.h)
+  set(KWSYS_C_SRCS ${KWSYS_C_SRCS} ${KWSYS_HEADER_DIR}/${h}.h)
 
   # Create an install target for the header.
-  IF(KWSYS_INSTALL_INCLUDE_DIR)
-    INSTALL(FILES ${KWSYS_HEADER_DIR}/${h}.h
+  if(KWSYS_INSTALL_INCLUDE_DIR)
+    install(FILES ${KWSYS_HEADER_DIR}/${h}.h
       DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}
       ${KWSYS_INSTALL_INCLUDE_OPTIONS})
-  ENDIF()
-ENDFOREACH()
+  endif()
+endforeach()
 
 # Configure other C++ headers.
-FOREACH(h ${KWSYS_HXX_FILES})
+foreach(h ${KWSYS_HXX_FILES})
   # Configure the header into the given directory.
-  CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/${h}.hxx.in ${KWSYS_HEADER_DIR}/${h}.hxx
+  configure_file(${PROJECT_SOURCE_DIR}/${h}.hxx.in ${KWSYS_HEADER_DIR}/${h}.hxx
                  @ONLY IMMEDIATE)
-  SET(KWSYS_CXX_SRCS ${KWSYS_CXX_SRCS} ${KWSYS_HEADER_DIR}/${h}.hxx)
+  set(KWSYS_CXX_SRCS ${KWSYS_CXX_SRCS} ${KWSYS_HEADER_DIR}/${h}.hxx)
 
   # Create an install target for the header.
-  IF(KWSYS_INSTALL_INCLUDE_DIR)
-    INSTALL(FILES ${KWSYS_HEADER_DIR}/${h}.hxx
+  if(KWSYS_INSTALL_INCLUDE_DIR)
+    install(FILES ${KWSYS_HEADER_DIR}/${h}.hxx
       DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}
       ${KWSYS_INSTALL_INCLUDE_OPTIONS})
-  ENDIF()
-ENDFOREACH()
+  endif()
+endforeach()
 
 #-----------------------------------------------------------------------------
 # Add the library with the configured name and list of sources.
-IF(KWSYS_C_SRCS OR KWSYS_CXX_SRCS)
-  IF(KWSYS_SPLIT_OBJECTS_FROM_INTERFACE)
-    SET(KWSYS_TARGET_INTERFACE ${KWSYS_NAMESPACE})
-    SET(KWSYS_TARGET_OBJECT ${KWSYS_NAMESPACE}_objects)
-    SET(KWSYS_TARGET_LINK ${KWSYS_NAMESPACE}_private)
-    SET(KWSYS_TARGET_INSTALL ${KWSYS_TARGET_INTERFACE} ${KWSYS_TARGET_LINK})
-    SET(KWSYS_LINK_DEPENDENCY INTERFACE)
-    ADD_LIBRARY(${KWSYS_TARGET_OBJECT} OBJECT
+if(KWSYS_C_SRCS OR KWSYS_CXX_SRCS)
+  if(KWSYS_SPLIT_OBJECTS_FROM_INTERFACE)
+    set(KWSYS_TARGET_INTERFACE ${KWSYS_NAMESPACE})
+    set(KWSYS_TARGET_OBJECT ${KWSYS_NAMESPACE}_objects)
+    set(KWSYS_TARGET_LINK ${KWSYS_NAMESPACE}_private)
+    set(KWSYS_TARGET_INSTALL ${KWSYS_TARGET_INTERFACE} ${KWSYS_TARGET_LINK})
+    set(KWSYS_LINK_DEPENDENCY INTERFACE)
+    add_library(${KWSYS_TARGET_OBJECT} OBJECT
       ${KWSYS_C_SRCS} ${KWSYS_CXX_SRCS})
-    IF(KWSYS_BUILD_SHARED OR KWSYS_BUILD_PIC)
-      SET_PROPERTY(TARGET ${KWSYS_TARGET_OBJECT} PROPERTY
+    if(KWSYS_BUILD_SHARED OR KWSYS_BUILD_PIC)
+      set_property(TARGET ${KWSYS_TARGET_OBJECT} PROPERTY
         POSITION_INDEPENDENT_CODE TRUE)
-    ENDIF()
-    ADD_LIBRARY(${KWSYS_TARGET_INTERFACE} INTERFACE)
-    ADD_LIBRARY(${KWSYS_TARGET_LINK} INTERFACE)
-    TARGET_LINK_LIBRARIES(${KWSYS_TARGET_LINK} INTERFACE
+    endif()
+    add_library(${KWSYS_TARGET_INTERFACE} INTERFACE)
+    add_library(${KWSYS_TARGET_LINK} INTERFACE)
+    target_link_libraries(${KWSYS_TARGET_LINK} INTERFACE
       ${KWSYS_TARGET_INTERFACE})
-    TARGET_SOURCES(${KWSYS_TARGET_LINK} INTERFACE
+    target_sources(${KWSYS_TARGET_LINK} INTERFACE
       $<TARGET_OBJECTS:${KWSYS_TARGET_OBJECT}>)
     target_compile_features(${KWSYS_TARGET_OBJECT} PRIVATE ${KWSYS_CXX_COMPILE_FEATURES})
     target_compile_features(${KWSYS_TARGET_INTERFACE} INTERFACE ${KWSYS_CXX_COMPILE_FEATURES})
-  ELSE()
-    SET(KWSYS_TARGET_INTERFACE ${KWSYS_NAMESPACE})
-    SET(KWSYS_TARGET_OBJECT ${KWSYS_NAMESPACE})
-    SET(KWSYS_TARGET_LINK ${KWSYS_NAMESPACE})
+  else()
+    set(KWSYS_TARGET_INTERFACE ${KWSYS_NAMESPACE})
+    set(KWSYS_TARGET_OBJECT ${KWSYS_NAMESPACE})
+    set(KWSYS_TARGET_LINK ${KWSYS_NAMESPACE})
     set(KWSYS_TARGET_INSTALL ${KWSYS_TARGET_LINK})
-    SET(KWSYS_LINK_DEPENDENCY PUBLIC)
-    ADD_LIBRARY(${KWSYS_TARGET_INTERFACE} ${KWSYS_LIBRARY_TYPE}
+    set(KWSYS_LINK_DEPENDENCY PUBLIC)
+    add_library(${KWSYS_TARGET_INTERFACE} ${KWSYS_LIBRARY_TYPE}
       ${KWSYS_C_SRCS} ${KWSYS_CXX_SRCS})
     target_compile_features(${KWSYS_TARGET_INTERFACE} PUBLIC ${KWSYS_CXX_COMPILE_FEATURES})
-  ENDIF()
+  endif()
   if (KWSYS_ALIAS_TARGET)
     add_library(${KWSYS_ALIAS_TARGET} ALIAS ${KWSYS_TARGET_INTERFACE})
   endif ()
-  SET_TARGET_PROPERTIES(${KWSYS_TARGET_OBJECT} PROPERTIES
+  set_target_properties(${KWSYS_TARGET_OBJECT} PROPERTIES
     C_CLANG_TIDY ""
     CXX_CLANG_TIDY ""
     C_INCLUDE_WHAT_YOU_USE ""
     CXX_INCLUDE_WHAT_YOU_USE ""
     LABELS "${KWSYS_LABELS_LIB}")
-  IF(KWSYS_USE_DynamicLoader)
-    IF(UNIX)
-      TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
+  if(KWSYS_USE_DynamicLoader)
+    if(UNIX)
+      target_link_libraries(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
         ${CMAKE_DL_LIBS})
-    ENDIF()
-  ENDIF()
+    endif()
+  endif()
 
-  IF(KWSYS_USE_SystemInformation)
-    IF(WIN32)
-      TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY} ws2_32)
+  if(KWSYS_USE_SystemInformation)
+    if(WIN32)
+      target_link_libraries(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY} ws2_32)
       # link in dbghelp.dll for symbol lookup if MSVC 1800 or later
       # Note that the dbghelp runtime is part of MS Windows OS
-      IF(MSVC_VERSION AND NOT MSVC_VERSION VERSION_LESS 1800)
-        TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY} dbghelp)
-      ENDIF()
-      IF(KWSYS_SYS_HAS_PSAPI)
-        TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
-          Psapi)
-      ENDIF()
-    ELSEIF(UNIX)
-      IF (EXECINFO_LIB AND KWSYS_CXX_HAS_BACKTRACE)
+      if(MSVC_VERSION AND NOT MSVC_VERSION VERSION_LESS 1800)
+        target_link_libraries(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY} dbghelp)
+      endif()
+      if(KWSYS_SYS_HAS_PSAPI)
+        target_link_libraries(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
+          psapi)
+      endif()
+    elseif(UNIX)
+      if (EXECINFO_LIB AND KWSYS_CXX_HAS_BACKTRACE)
         # backtrace on FreeBSD is not in libc
-        TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
+        target_link_libraries(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
           ${EXECINFO_LIB})
-      ENDIF()
-      IF (KWSYS_CXX_HAS_DLADDR)
+      endif()
+      if (KWSYS_CXX_HAS_DLADDR)
         # for symbol lookup using dladdr
-        TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
+        target_link_libraries(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
           ${CMAKE_DL_LIBS})
-      ENDIF()
-      IF (CMAKE_SYSTEM_NAME STREQUAL "SunOS")
-        TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
+      endif()
+      if (CMAKE_SYSTEM_NAME STREQUAL "SunOS")
+        target_link_libraries(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
           socket)
-      ENDIF()
-    ENDIF()
-  ENDIF()
+      endif()
+    endif()
+  endif()
 
   # Apply user-defined target properties to the library.
-  IF(KWSYS_PROPERTIES_CXX)
-    SET_TARGET_PROPERTIES(${KWSYS_TARGET_INTERFACE} PROPERTIES
+  if(KWSYS_PROPERTIES_CXX)
+    set_target_properties(${KWSYS_TARGET_INTERFACE} PROPERTIES
       ${KWSYS_PROPERTIES_CXX})
-  ENDIF()
+  endif()
 
   # Set up include usage requirement
-  IF(COMMAND TARGET_INCLUDE_DIRECTORIES)
-    TARGET_INCLUDE_DIRECTORIES(${KWSYS_TARGET_INTERFACE} INTERFACE
+  if(COMMAND TARGET_INCLUDE_DIRECTORIES)
+    target_include_directories(${KWSYS_TARGET_INTERFACE} INTERFACE
       $<BUILD_INTERFACE:${KWSYS_HEADER_ROOT}>)
-    IF(KWSYS_INSTALL_INCLUDE_DIR)
-      TARGET_INCLUDE_DIRECTORIES(${KWSYS_TARGET_INTERFACE} INTERFACE
+    if(KWSYS_INSTALL_INCLUDE_DIR)
+      target_include_directories(${KWSYS_TARGET_INTERFACE} INTERFACE
         $<INSTALL_INTERFACE:${KWSYS_INSTALL_INCLUDE_DIR}>)
-    ENDIF()
-  ENDIF()
+    endif()
+  endif()
 
   # Create an install target for the library.
-  IF(KWSYS_INSTALL_LIBRARY_RULE)
-    INSTALL(TARGETS ${KWSYS_TARGET_INSTALL} ${KWSYS_INSTALL_LIBRARY_RULE})
-  ENDIF()
-  IF(KWSYS_INSTALL_NAMELINK_RULE)
-    INSTALL(TARGETS ${KWSYS_TARGET_INSTALL} ${KWSYS_INSTALL_NAMELINK_RULE})
-  ENDIF()
-ENDIF()
+  if(KWSYS_INSTALL_LIBRARY_RULE)
+    install(TARGETS ${KWSYS_TARGET_INSTALL} ${KWSYS_INSTALL_LIBRARY_RULE})
+  endif()
+  if(KWSYS_INSTALL_NAMELINK_RULE)
+    install(TARGETS ${KWSYS_TARGET_INSTALL} ${KWSYS_INSTALL_NAMELINK_RULE})
+  endif()
+endif()
 
 # Add a C-only library if requested.
-IF(KWSYS_ENABLE_C AND KWSYS_C_SRCS)
- IF(KWSYS_SPLIT_OBJECTS_FROM_INTERFACE)
-    SET(KWSYS_TARGET_C_INTERFACE ${KWSYS_NAMESPACE}_c)
-    SET(KWSYS_TARGET_C_OBJECT ${KWSYS_NAMESPACE}_c_objects)
-    SET(KWSYS_TARGET_C_LINK ${KWSYS_NAMESPACE}_c_private)
-    SET(KWSYS_TARGET_C_INSTALL
+if(KWSYS_ENABLE_C AND KWSYS_C_SRCS)
+ if(KWSYS_SPLIT_OBJECTS_FROM_INTERFACE)
+    set(KWSYS_TARGET_C_INTERFACE ${KWSYS_NAMESPACE}_c)
+    set(KWSYS_TARGET_C_OBJECT ${KWSYS_NAMESPACE}_c_objects)
+    set(KWSYS_TARGET_C_LINK ${KWSYS_NAMESPACE}_c_private)
+    set(KWSYS_TARGET_C_INSTALL
       ${KWSYS_TARGET_C_INTERFACE} ${KWSYS_TARGET_C_LINK})
-    SET(KWSYS_LINK_DEPENDENCY INTERFACE)
-    ADD_LIBRARY(${KWSYS_TARGET_C_OBJECT} OBJECT ${KWSYS_C_SRCS})
-    IF(KWSYS_BUILD_SHARED OR KWSYS_BUILD_PIC)
-      SET_PROPERTY(TARGET ${KWSYS_TARGET_C_OBJECT} PROPERTY
+    set(KWSYS_LINK_DEPENDENCY INTERFACE)
+    add_library(${KWSYS_TARGET_C_OBJECT} OBJECT ${KWSYS_C_SRCS})
+    if(KWSYS_BUILD_SHARED OR KWSYS_BUILD_PIC)
+      set_property(TARGET ${KWSYS_TARGET_C_OBJECT} PROPERTY
         POSITION_INDEPENDENT_CODE TRUE)
-    ENDIF()
-    ADD_LIBRARY(${KWSYS_TARGET_C_INTERFACE} INTERFACE)
-    ADD_LIBRARY(${KWSYS_TARGET_C_LINK} INTERFACE)
-    TARGET_LINK_LIBRARIES(${KWSYS_TARGET_C_LINK} INTERFACE
+    endif()
+    add_library(${KWSYS_TARGET_C_INTERFACE} INTERFACE)
+    add_library(${KWSYS_TARGET_C_LINK} INTERFACE)
+    target_link_libraries(${KWSYS_TARGET_C_LINK} INTERFACE
       ${KWSYS_TARGET_C_INTERFACE})
-    TARGET_SOURCES(${KWSYS_TARGET_C_LINK} INTERFACE
+    target_sources(${KWSYS_TARGET_C_LINK} INTERFACE
       $<TARGET_OBJECTS:${KWSYS_TARGET_C_OBJECT}>)
-  ELSE()
-    SET(KWSYS_TARGET_C_INTERFACE ${KWSYS_NAMESPACE}_c)
-    SET(KWSYS_TARGET_C_OBJECT ${KWSYS_NAMESPACE}_c)
-    SET(KWSYS_TARGET_C_LINK ${KWSYS_NAMESPACE}_c)
-    SET(KWSYS_TARGET_C_INSTALL ${KWSYS_TARGET_C_LINK})
-    SET(KWSYS_LINK_DEPENDENCY PUBLIC)
-    ADD_LIBRARY(${KWSYS_TARGET_C_INTERFACE} ${KWSYS_LIBRARY_TYPE}
+  else()
+    set(KWSYS_TARGET_C_INTERFACE ${KWSYS_NAMESPACE}_c)
+    set(KWSYS_TARGET_C_OBJECT ${KWSYS_NAMESPACE}_c)
+    set(KWSYS_TARGET_C_LINK ${KWSYS_NAMESPACE}_c)
+    set(KWSYS_TARGET_C_INSTALL ${KWSYS_TARGET_C_LINK})
+    set(KWSYS_LINK_DEPENDENCY PUBLIC)
+    add_library(${KWSYS_TARGET_C_INTERFACE} ${KWSYS_LIBRARY_TYPE}
       ${KWSYS_C_SRCS})
-  ENDIF()
-  SET_TARGET_PROPERTIES(${KWSYS_TARGET_C_OBJECT} PROPERTIES
+  endif()
+  set_target_properties(${KWSYS_TARGET_C_OBJECT} PROPERTIES
     LABELS "${KWSYS_LABELS_LIB}")
 
   # Apply user-defined target properties to the library.
-  IF(KWSYS_PROPERTIES_C)
-    SET_TARGET_PROPERTIES(${KWSYS_TARGET_C_INTERFACE} PROPERTIES
+  if(KWSYS_PROPERTIES_C)
+    set_target_properties(${KWSYS_TARGET_C_INTERFACE} PROPERTIES
       ${KWSYS_PROPERTIES_C})
-  ENDIF()
+  endif()
 
   # Set up include usage requirement
-  IF(COMMAND TARGET_INCLUDE_DIRECTORIES)
-    TARGET_INCLUDE_DIRECTORIES(${KWSYS_TARGET_C_INTERFACE} INTERFACE
+  if(COMMAND TARGET_INCLUDE_DIRECTORIES)
+    target_include_directories(${KWSYS_TARGET_C_INTERFACE} INTERFACE
       $<BUILD_INTERFACE:${KWSYS_HEADER_ROOT}>)
-    IF(KWSYS_INSTALL_INCLUDE_DIR)
-      TARGET_INCLUDE_DIRECTORIES(${KWSYS_TARGET_C_INTERFACE} INTERFACE
+    if(KWSYS_INSTALL_INCLUDE_DIR)
+      target_include_directories(${KWSYS_TARGET_C_INTERFACE} INTERFACE
         $<INSTALL_INTERFACE:${KWSYS_INSTALL_INCLUDE_DIR}>)
-    ENDIF()
-  ENDIF()
+    endif()
+  endif()
 
   # Create an install target for the library.
-  IF(KWSYS_INSTALL_LIBRARY_RULE)
-    INSTALL(TARGETS ${KWSYS_TARGET_C_INSTALL})
-  ENDIF()
-ENDIF()
+  if(KWSYS_INSTALL_LIBRARY_RULE)
+    install(TARGETS ${KWSYS_TARGET_C_INSTALL})
+  endif()
+endif()
 
 # For building kwsys itself, we use a macro defined on the command
 # line to configure the namespace in the C and C++ source files.
-ADD_DEFINITIONS("-DKWSYS_NAMESPACE=${KWSYS_NAMESPACE}")
+add_definitions("-DKWSYS_NAMESPACE=${KWSYS_NAMESPACE}")
 
 # Disable deprecation warnings for standard C functions.
-IF(MSVC OR (WIN32 AND (CMAKE_C_COMPILER_ID STREQUAL "Intel" OR
+if(MSVC OR (WIN32 AND (CMAKE_C_COMPILER_ID STREQUAL "Intel" OR
    (CMAKE_C_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_SIMULATE_ID STREQUAL "MSVC"))))
-  ADD_DEFINITIONS(
+  add_definitions(
     -D_CRT_NONSTDC_NO_DEPRECATE
     -D_CRT_SECURE_NO_DEPRECATE
     -D_CRT_SECURE_NO_WARNINGS
     -D_SCL_SECURE_NO_DEPRECATE
     )
-ENDIF()
+endif()
 
-IF(WIN32)
+if(WIN32)
   # Help enforce the use of wide Windows apis.
-  ADD_DEFINITIONS(-DUNICODE -D_UNICODE)
-ENDIF()
+  add_definitions(-DUNICODE -D_UNICODE)
+endif()
 
-IF(KWSYS_USE_String)
+if(KWSYS_USE_String)
   # Activate code in "String.c".  See the comment in the source.
-  SET_SOURCE_FILES_PROPERTIES(String.c PROPERTIES
+  set_source_files_properties(String.c PROPERTIES
     COMPILE_FLAGS "-DKWSYS_STRING_C")
-ENDIF()
+endif()
 
-IF(KWSYS_USE_Encoding)
+if(KWSYS_USE_Encoding)
   # Set default 8 bit encoding in "EndcodingC.c".
-  SET_PROPERTY(SOURCE EncodingC.c EncodingCXX.cxx APPEND PROPERTY COMPILE_DEFINITIONS
+  set_property(SOURCE EncodingC.c EncodingCXX.cxx APPEND PROPERTY COMPILE_DEFINITIONS
     KWSYS_ENCODING_DEFAULT_CODEPAGE=${KWSYS_ENCODING_DEFAULT_CODEPAGE})
-ENDIF()
+endif()
 
 #-----------------------------------------------------------------------------
 # Setup testing if not being built as part of another project.
-IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
-  IF(BUILD_TESTING)
+if(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
+  if(BUILD_TESTING)
     # Compute the location of executables.
-    SET(EXEC_DIR "${CMAKE_CURRENT_BINARY_DIR}")
-    IF(EXECUTABLE_OUTPUT_PATH)
-      SET(EXEC_DIR "${EXECUTABLE_OUTPUT_PATH}")
-    ENDIF()
+    set(EXEC_DIR "${CMAKE_CURRENT_BINARY_DIR}")
+    if(CMAKE_RUNTIME_OUTPUT_DIRECTORY)
+      set(EXEC_DIR "${CMAKE_RUNTIME_OUTPUT_DIRECTORY}")
+    endif()
 
     # C tests
-    SET(KWSYS_C_TESTS
+    set(KWSYS_C_TESTS
       testEncode.c
       testTerminal.c
       )
-    IF(KWSYS_STANDALONE)
-      SET(KWSYS_C_TESTS ${KWSYS_C_TESTS} testFail.c)
-    ENDIF()
-    CREATE_TEST_SOURCELIST(
+    if(KWSYS_STANDALONE)
+      set(KWSYS_C_TESTS ${KWSYS_C_TESTS} testFail.c)
+    endif()
+    create_test_sourcelist(
       KWSYS_C_TEST_SRCS ${KWSYS_NAMESPACE}TestsC.c
       ${KWSYS_C_TESTS}
       )
-    ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestsC ${KWSYS_C_TEST_SRCS})
-    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsC PROPERTY LABELS ${KWSYS_LABELS_EXE})
-    TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestsC ${KWSYS_TARGET_C_LINK})
-    FOREACH(testfile ${KWSYS_C_TESTS})
+    add_executable(${KWSYS_NAMESPACE}TestsC ${KWSYS_C_TEST_SRCS})
+    set_property(TARGET ${KWSYS_NAMESPACE}TestsC PROPERTY LABELS ${KWSYS_LABELS_EXE})
+    target_link_libraries(${KWSYS_NAMESPACE}TestsC ${KWSYS_TARGET_C_LINK})
+    foreach(testfile ${KWSYS_C_TESTS})
       get_filename_component(test "${testfile}" NAME_WE)
-      ADD_TEST(kwsys.${test} ${EXEC_DIR}/${KWSYS_NAMESPACE}TestsC ${test} ${KWSYS_TEST_ARGS_${test}})
-      SET_PROPERTY(TEST kwsys.${test} PROPERTY LABELS ${KWSYS_LABELS_TEST})
-    ENDFOREACH()
+      add_test(kwsys.${test} ${EXEC_DIR}/${KWSYS_NAMESPACE}TestsC ${test} ${KWSYS_TEST_ARGS_${test}})
+      set_property(TEST kwsys.${test} PROPERTY LABELS ${KWSYS_LABELS_TEST})
+    endforeach()
 
     # C++ tests
-    IF(NOT WATCOM AND NOT CMake_SOURCE_DIR)
-      SET(KWSYS_CXX_TESTS
+    if(NOT WATCOM AND NOT CMake_SOURCE_DIR)
+      set(KWSYS_CXX_TESTS
         testHashSTL.cxx
         )
-    ENDIF()
-    SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS}
+    endif()
+    set(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS}
       testConfigure.cxx
       testSystemTools.cxx
       testCommandLineArguments.cxx
       testCommandLineArguments1.cxx
       testDirectory.cxx
       )
-    IF(KWSYS_STL_HAS_WSTRING)
-      SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS}
+    if(KWSYS_STL_HAS_WSTRING)
+      set(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS}
         testEncoding.cxx
         )
-    ENDIF()
-    IF(KWSYS_USE_FStream)
-      SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS}
+    endif()
+    if(KWSYS_USE_FStream)
+      set(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS}
         testFStream.cxx
         )
-    ENDIF()
-    IF(KWSYS_USE_ConsoleBuf)
-      ADD_EXECUTABLE(testConsoleBufChild testConsoleBufChild.cxx)
-      SET_PROPERTY(TARGET testConsoleBufChild PROPERTY C_CLANG_TIDY "")
-      SET_PROPERTY(TARGET testConsoleBufChild PROPERTY CXX_CLANG_TIDY "")
-      SET_PROPERTY(TARGET testConsoleBufChild PROPERTY C_INCLUDE_WHAT_YOU_USE "")
-      SET_PROPERTY(TARGET testConsoleBufChild PROPERTY CXX_INCLUDE_WHAT_YOU_USE "")
-      SET_PROPERTY(TARGET testConsoleBufChild PROPERTY LABELS ${KWSYS_LABELS_EXE})
-      TARGET_LINK_LIBRARIES(testConsoleBufChild ${KWSYS_TARGET_LINK})
-      SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS}
+    endif()
+    if(KWSYS_USE_ConsoleBuf)
+      add_executable(testConsoleBufChild testConsoleBufChild.cxx)
+      set_property(TARGET testConsoleBufChild PROPERTY C_CLANG_TIDY "")
+      set_property(TARGET testConsoleBufChild PROPERTY CXX_CLANG_TIDY "")
+      set_property(TARGET testConsoleBufChild PROPERTY C_INCLUDE_WHAT_YOU_USE "")
+      set_property(TARGET testConsoleBufChild PROPERTY CXX_INCLUDE_WHAT_YOU_USE "")
+      set_property(TARGET testConsoleBufChild PROPERTY LABELS ${KWSYS_LABELS_EXE})
+      target_link_libraries(testConsoleBufChild ${KWSYS_TARGET_LINK})
+      set(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS}
         testConsoleBuf.cxx
         )
-      IF(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND
+      if(CMAKE_CXX_COMPILER_ID STREQUAL "MSVC" AND
          CMAKE_CXX_COMPILER_VERSION VERSION_GREATER "19.0.23506")
         set_property(SOURCE testConsoleBuf.cxx testConsoleBufChild.cxx PROPERTY COMPILE_FLAGS /utf-8)
-      ENDIF()
-      SET_PROPERTY(SOURCE testConsoleBuf.cxx APPEND PROPERTY COMPILE_DEFINITIONS
+      endif()
+      set_property(SOURCE testConsoleBuf.cxx APPEND PROPERTY COMPILE_DEFINITIONS
         KWSYS_ENCODING_DEFAULT_CODEPAGE=${KWSYS_ENCODING_DEFAULT_CODEPAGE})
-    ENDIF()
-    IF(KWSYS_USE_SystemInformation)
-      SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS} testSystemInformation.cxx)
-    ENDIF()
-    IF(KWSYS_USE_DynamicLoader)
-      SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS} testDynamicLoader.cxx)
+    endif()
+    if(KWSYS_USE_SystemInformation)
+      set(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS} testSystemInformation.cxx)
+    endif()
+    if(KWSYS_USE_DynamicLoader)
+      set(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS} testDynamicLoader.cxx)
       # If kwsys contains the DynamicLoader, need extra library
-      ADD_LIBRARY(${KWSYS_NAMESPACE}TestDynload MODULE testDynload.c)
-      SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestDynload PROPERTY LABELS ${KWSYS_LABELS_LIB})
-      ADD_DEPENDENCIES(${KWSYS_NAMESPACE}TestDynload ${KWSYS_TARGET_INTERFACE})
+      add_library(${KWSYS_NAMESPACE}TestDynload MODULE testDynload.c)
+      set_property(TARGET ${KWSYS_NAMESPACE}TestDynload PROPERTY LABELS ${KWSYS_LABELS_LIB})
+      add_dependencies(${KWSYS_NAMESPACE}TestDynload ${KWSYS_TARGET_INTERFACE})
 
       if (WIN32)
         # Windows tests supported flags.
@@ -1134,33 +1134,33 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
         add_dependencies(${KWSYS_NAMESPACE}TestDynloadUse ${KWSYS_TARGET_INTERFACE})
         target_link_libraries(${KWSYS_NAMESPACE}TestDynloadUse PRIVATE ${KWSYS_NAMESPACE}TestDynloadImpl)
       endif ()
-    ENDIF()
-    CREATE_TEST_SOURCELIST(
+    endif()
+    create_test_sourcelist(
       KWSYS_CXX_TEST_SRCS ${KWSYS_NAMESPACE}TestsCxx.cxx
       ${KWSYS_CXX_TESTS}
       )
-    ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestsCxx ${KWSYS_CXX_TEST_SRCS})
-    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY C_CLANG_TIDY "")
-    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY CXX_CLANG_TIDY "")
-    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY C_INCLUDE_WHAT_YOU_USE "")
-    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY CXX_INCLUDE_WHAT_YOU_USE "")
-    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY LABELS ${KWSYS_LABELS_EXE})
-    TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestsCxx ${KWSYS_TARGET_LINK})
-
-    SET(TEST_SYSTEMTOOLS_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
-    SET(TEST_SYSTEMTOOLS_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}")
-    CONFIGURE_FILE(
+    add_executable(${KWSYS_NAMESPACE}TestsCxx ${KWSYS_CXX_TEST_SRCS})
+    set_property(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY C_CLANG_TIDY "")
+    set_property(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY CXX_CLANG_TIDY "")
+    set_property(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY C_INCLUDE_WHAT_YOU_USE "")
+    set_property(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY CXX_INCLUDE_WHAT_YOU_USE "")
+    set_property(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY LABELS ${KWSYS_LABELS_EXE})
+    target_link_libraries(${KWSYS_NAMESPACE}TestsCxx ${KWSYS_TARGET_LINK})
+
+    set(TEST_SYSTEMTOOLS_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
+    set(TEST_SYSTEMTOOLS_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}")
+    configure_file(
       ${PROJECT_SOURCE_DIR}/testSystemTools.h.in
       ${PROJECT_BINARY_DIR}/testSystemTools.h)
-    INCLUDE_DIRECTORIES(${PROJECT_BINARY_DIR})
+    include_directories(${PROJECT_BINARY_DIR})
 
-    IF(CTEST_TEST_KWSYS)
-      CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/ExtraTest.cmake.in"
+    if(CTEST_TEST_KWSYS)
+      configure_file("${CMAKE_CURRENT_SOURCE_DIR}/ExtraTest.cmake.in"
         "${CMAKE_CURRENT_BINARY_DIR}/ExtraTest.cmake")
-      SET_DIRECTORY_PROPERTIES(PROPERTIES TEST_INCLUDE_FILE "${CMAKE_CURRENT_BINARY_DIR}/ExtraTest.cmake")
-    ENDIF()
+      set_directory_properties(PROPERTIES TEST_INCLUDE_FILE "${CMAKE_CURRENT_BINARY_DIR}/ExtraTest.cmake")
+    endif()
 
-    SET(KWSYS_TEST_ARGS_testCommandLineArguments
+    set(KWSYS_TEST_ARGS_testCommandLineArguments
       --another-bool-variable
       --long3=opt
       --set-bool-arg1
@@ -1179,7 +1179,7 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
       -C=test
       --long2 hello
       )
-    SET(KWSYS_TEST_ARGS_testCommandLineArguments1
+    set(KWSYS_TEST_ARGS_testCommandLineArguments1
       --ignored
       -n 24
       --second-ignored
@@ -1188,73 +1188,73 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
       -p
       some junk at the end
       )
-    FOREACH(testfile ${KWSYS_CXX_TESTS})
+    foreach(testfile ${KWSYS_CXX_TESTS})
       get_filename_component(test "${testfile}" NAME_WE)
-      ADD_TEST(kwsys.${test} ${EXEC_DIR}/${KWSYS_NAMESPACE}TestsCxx ${test} ${KWSYS_TEST_ARGS_${test}})
-      SET_PROPERTY(TEST kwsys.${test} PROPERTY LABELS ${KWSYS_LABELS_TEST})
-    ENDFOREACH()
+      add_test(kwsys.${test} ${EXEC_DIR}/${KWSYS_NAMESPACE}TestsCxx ${test} ${KWSYS_TEST_ARGS_${test}})
+      set_property(TEST kwsys.${test} PROPERTY LABELS ${KWSYS_LABELS_TEST})
+    endforeach()
 
     # Process tests.
-    ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestProcess testProcess.c)
-    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestProcess PROPERTY LABELS ${KWSYS_LABELS_EXE})
-    TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestProcess ${KWSYS_TARGET_C_LINK})
-    IF(NOT CYGWIN)
-      SET(KWSYS_TEST_PROCESS_7 7)
-    ENDIF()
-    FOREACH(n 1 2 3 4 5 6 ${KWSYS_TEST_PROCESS_7} 9 10)
-      ADD_TEST(kwsys.testProcess-${n} ${EXEC_DIR}/${KWSYS_NAMESPACE}TestProcess ${n})
-      SET_PROPERTY(TEST kwsys.testProcess-${n} PROPERTY LABELS ${KWSYS_LABELS_TEST})
-      SET_TESTS_PROPERTIES(kwsys.testProcess-${n} PROPERTIES TIMEOUT 120)
-    ENDFOREACH()
-
-    SET(testProcess_COMPILE_FLAGS "")
+    add_executable(${KWSYS_NAMESPACE}TestProcess testProcess.c)
+    set_property(TARGET ${KWSYS_NAMESPACE}TestProcess PROPERTY LABELS ${KWSYS_LABELS_EXE})
+    target_link_libraries(${KWSYS_NAMESPACE}TestProcess ${KWSYS_TARGET_C_LINK})
+    if(NOT CYGWIN)
+      set(KWSYS_TEST_PROCESS_7 7)
+    endif()
+    foreach(n 1 2 3 4 5 6 ${KWSYS_TEST_PROCESS_7} 9 10)
+      add_test(kwsys.testProcess-${n} ${EXEC_DIR}/${KWSYS_NAMESPACE}TestProcess ${n})
+      set_property(TEST kwsys.testProcess-${n} PROPERTY LABELS ${KWSYS_LABELS_TEST})
+      set_tests_properties(kwsys.testProcess-${n} PROPERTIES TIMEOUT 120)
+    endforeach()
+
+    set(testProcess_COMPILE_FLAGS "")
     # Some Apple compilers produce bad optimizations in this source.
-    IF(APPLE AND CMAKE_C_COMPILER_ID MATCHES "^(GNU|LLVM)$")
-      SET(testProcess_COMPILE_FLAGS "${testProcess_COMPILE_FLAGS} -O0")
-    ELSEIF(CMAKE_C_COMPILER_ID STREQUAL "XL")
+    if(APPLE AND CMAKE_C_COMPILER_ID MATCHES "^(GNU|LLVM)$")
+      set(testProcess_COMPILE_FLAGS "${testProcess_COMPILE_FLAGS} -O0")
+    elseif(CMAKE_C_COMPILER_ID STREQUAL "XL")
       # Tell IBM XL not to warn about our test infinite loop
-      IF(CMAKE_SYSTEM MATCHES "Linux.*ppc64le"
+      if(CMAKE_SYSTEM MATCHES "Linux.*ppc64le"
          AND CMAKE_C_COMPILER_VERSION VERSION_LESS "16.1.0"
          AND NOT CMAKE_C_COMPILER_VERSION VERSION_LESS "13.1.1")
         # v13.1.[1-6] on Linux ppc64le is clang based and does not accept
         # the -qsuppress option, so just suppress all warnings.
-        SET(testProcess_COMPILE_FLAGS "${testProcess_COMPILE_FLAGS} -w")
-      ELSE()
-        SET(testProcess_COMPILE_FLAGS "${testProcess_COMPILE_FLAGS} -qsuppress=1500-010")
-      ENDIF()
-    ENDIF()
-    IF(CMAKE_C_FLAGS MATCHES "-fsanitize=")
-      SET(testProcess_COMPILE_FLAGS "${testProcess_COMPILE_FLAGS} -DCRASH_USING_ABORT")
-    ENDIF()
-    SET_PROPERTY(SOURCE testProcess.c PROPERTY COMPILE_FLAGS "${testProcess_COMPILE_FLAGS}")
+        set(testProcess_COMPILE_FLAGS "${testProcess_COMPILE_FLAGS} -w")
+      else()
+        set(testProcess_COMPILE_FLAGS "${testProcess_COMPILE_FLAGS} -qsuppress=1500-010")
+      endif()
+    endif()
+    if(CMAKE_C_FLAGS MATCHES "-fsanitize=")
+      set(testProcess_COMPILE_FLAGS "${testProcess_COMPILE_FLAGS} -DCRASH_USING_ABORT")
+    endif()
+    set_property(SOURCE testProcess.c PROPERTY COMPILE_FLAGS "${testProcess_COMPILE_FLAGS}")
 
     # Test SharedForward
-    CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/testSharedForward.c.in
+    configure_file(${PROJECT_SOURCE_DIR}/testSharedForward.c.in
                    ${PROJECT_BINARY_DIR}/testSharedForward.c @ONLY IMMEDIATE)
-    ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestSharedForward
+    add_executable(${KWSYS_NAMESPACE}TestSharedForward
                    ${PROJECT_BINARY_DIR}/testSharedForward.c)
-    SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestSharedForward PROPERTY LABELS ${KWSYS_LABELS_EXE})
-    ADD_DEPENDENCIES(${KWSYS_NAMESPACE}TestSharedForward ${KWSYS_TARGET_C_LINK})
-    ADD_TEST(kwsys.testSharedForward ${EXEC_DIR}/${KWSYS_NAMESPACE}TestSharedForward 1)
-    SET_PROPERTY(TEST kwsys.testSharedForward PROPERTY LABELS ${KWSYS_LABELS_TEST})
+    set_property(TARGET ${KWSYS_NAMESPACE}TestSharedForward PROPERTY LABELS ${KWSYS_LABELS_EXE})
+    add_dependencies(${KWSYS_NAMESPACE}TestSharedForward ${KWSYS_TARGET_C_LINK})
+    add_test(kwsys.testSharedForward ${EXEC_DIR}/${KWSYS_NAMESPACE}TestSharedForward 1)
+    set_property(TEST kwsys.testSharedForward PROPERTY LABELS ${KWSYS_LABELS_TEST})
 
     # Configure some test properties.
-    IF(KWSYS_STANDALONE)
+    if(KWSYS_STANDALONE)
       # We expect test to fail
-      SET_TESTS_PROPERTIES(kwsys.testFail PROPERTIES WILL_FAIL ON)
-      GET_TEST_PROPERTY(kwsys.testFail WILL_FAIL wfv)
-      SET_TESTS_PROPERTIES(kwsys.testFail PROPERTIES MEASUREMENT "Some Key=Some Value")
-      MESSAGE(STATUS "GET_TEST_PROPERTY returned: ${wfv}")
-    ENDIF()
+      set_tests_properties(kwsys.testFail PROPERTIES WILL_FAIL ON)
+      get_test_property(kwsys.testFail WILL_FAIL wfv)
+      set_tests_properties(kwsys.testFail PROPERTIES MEASUREMENT "Some Key=Some Value")
+      message(STATUS "GET_TEST_PROPERTY returned: ${wfv}")
+    endif()
 
     # Set up ctest custom configuration file.
-    CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/CTestCustom.cmake.in
+    configure_file(${PROJECT_SOURCE_DIR}/CTestCustom.cmake.in
                    ${PROJECT_BINARY_DIR}/CTestCustom.cmake @ONLY)
 
     # Suppress known consistent failures on buggy systems.
-    IF(KWSYS_TEST_BOGUS_FAILURES)
-      SET_TESTS_PROPERTIES(${KWSYS_TEST_BOGUS_FAILURES} PROPERTIES WILL_FAIL ON)
-    ENDIF()
+    if(KWSYS_TEST_BOGUS_FAILURES)
+      set_tests_properties(${KWSYS_TEST_BOGUS_FAILURES} PROPERTIES WILL_FAIL ON)
+    endif()
 
-  ENDIF()
-ENDIF()
+  endif()
+endif()
diff --git a/Source/kwsys/CommandLineArguments.cxx b/Source/kwsys/CommandLineArguments.cxx
index 3fd1955..a2ed874 100644
--- a/Source/kwsys/CommandLineArguments.cxx
+++ b/Source/kwsys/CommandLineArguments.cxx
@@ -66,26 +66,21 @@ class CommandLineArgumentsMapOfStrucs
 class CommandLineArgumentsInternal
 {
 public:
-  CommandLineArgumentsInternal()
-    : UnknownArgumentCallback{ nullptr }
-    , ClientData{ nullptr }
-    , LastArgument{ 0 }
-  {
-  }
+  CommandLineArgumentsInternal() = default;
 
-  typedef CommandLineArgumentsVectorOfStrings VectorOfStrings;
-  typedef CommandLineArgumentsMapOfStrucs CallbacksMap;
-  typedef kwsys::String String;
-  typedef CommandLineArgumentsSetOfStrings SetOfStrings;
+  using VectorOfStrings = CommandLineArgumentsVectorOfStrings;
+  using CallbacksMap = CommandLineArgumentsMapOfStrucs;
+  using String = kwsys::String;
+  using SetOfStrings = CommandLineArgumentsSetOfStrings;
 
   VectorOfStrings Argv;
   String Argv0;
   CallbacksMap Callbacks;
 
-  CommandLineArguments::ErrorCallbackType UnknownArgumentCallback;
-  void* ClientData;
+  CommandLineArguments::ErrorCallbackType UnknownArgumentCallback{ nullptr };
+  void* ClientData{ nullptr };
 
-  VectorOfStrings::size_type LastArgument;
+  VectorOfStrings::size_type LastArgument{ 0 };
 
   VectorOfStrings UnusedArguments;
 };
@@ -424,8 +419,7 @@ void CommandLineArguments::SetUnknownArgumentCallback(
 
 const char* CommandLineArguments::GetHelp(const char* arg)
 {
-  CommandLineArguments::Internal::CallbacksMap::iterator it =
-    this->Internals->Callbacks.find(arg);
+  auto it = this->Internals->Callbacks.find(arg);
   if (it == this->Internals->Callbacks.end()) {
     return nullptr;
   }
@@ -434,8 +428,7 @@ const char* CommandLineArguments::GetHelp(const char* arg)
   // one point to if this one is pointing to another argument.
   CommandLineArgumentsCallbackStructure* cs = &(it->second);
   for (;;) {
-    CommandLineArguments::Internal::CallbacksMap::iterator hit =
-      this->Internals->Callbacks.find(cs->Help);
+    auto hit = this->Internals->Callbacks.find(cs->Help);
     if (hit == this->Internals->Callbacks.end()) {
       break;
     }
@@ -470,9 +463,8 @@ void CommandLineArguments::GenerateHelp()
   // Collapse all arguments into the map of vectors of all arguments that do
   // the same thing.
   CommandLineArguments::Internal::CallbacksMap::iterator it;
-  typedef std::map<CommandLineArguments::Internal::String,
-                   CommandLineArguments::Internal::SetOfStrings>
-    MapArgs;
+  using MapArgs = std::map<CommandLineArguments::Internal::String,
+                           CommandLineArguments::Internal::SetOfStrings>;
   MapArgs mp;
   MapArgs::iterator mpit, smpit;
   for (it = this->Internals->Callbacks.begin();
@@ -709,7 +701,7 @@ bool CommandLineArguments::PopulateVariable(
   if (cs->Callback) {
     if (!cs->Callback(cs->Argument, value, cs->CallData)) {
       this->Internals->LastArgument--;
-      return 0;
+      return false;
     }
   }
   CommandLineArguments_DEBUG("Set argument: " << cs->Argument << " to "
@@ -759,10 +751,10 @@ bool CommandLineArguments::PopulateVariable(
         std::cerr << "Got unknown variable type: \"" << cs->VariableType
                   << "\"" << std::endl;
         this->Internals->LastArgument--;
-        return 0;
+        return false;
     }
   }
-  return 1;
+  return true;
 }
 
 } // namespace KWSYS_NAMESPACE
diff --git a/Source/kwsys/Directory.cxx b/Source/kwsys/Directory.cxx
index e379182..1a772b4 100644
--- a/Source/kwsys/Directory.cxx
+++ b/Source/kwsys/Directory.cxx
@@ -204,15 +204,15 @@ bool Directory::Load(const std::string& name)
   DIR* dir = opendir(name.c_str());
 
   if (!dir) {
-    return 0;
+    return false;
   }
 
   for (kwsys_dirent* d = readdir(dir); d; d = readdir(dir)) {
-    this->Internal->Files.push_back(d->d_name);
+    this->Internal->Files.emplace_back(d->d_name);
   }
   this->Internal->Path = name;
   closedir(dir);
-  return 1;
+  return true;
 }
 
 unsigned long Directory::GetNumberOfFilesInDirectory(const std::string& name)
diff --git a/Source/kwsys/ExtraTest.cmake.in b/Source/kwsys/ExtraTest.cmake.in
index e8c0a1c..4cec9e2 100644
--- a/Source/kwsys/ExtraTest.cmake.in
+++ b/Source/kwsys/ExtraTest.cmake.in
@@ -1 +1 @@
-MESSAGE("*** This message is generated by message inside a file that is included in DartTestfile.txt ***")
+message("*** This message is generated by message inside a file that is included in DartTestfile.txt ***")
diff --git a/Source/kwsys/Glob.cxx b/Source/kwsys/Glob.cxx
index 34bb0d0..658b816 100644
--- a/Source/kwsys/Glob.cxx
+++ b/Source/kwsys/Glob.cxx
@@ -415,8 +415,7 @@ bool Glob::FindFiles(const std::string& inexpr, GlobMessages* messages)
 
 void Glob::AddExpression(const std::string& expr)
 {
-  this->Internals->Expressions.push_back(
-    kwsys::RegularExpression(this->PatternToRegex(expr)));
+  this->Internals->Expressions.emplace_back(this->PatternToRegex(expr));
 }
 
 void Glob::SetRelative(const char* dir)
diff --git a/Source/kwsys/Process.h.in b/Source/kwsys/Process.h.in
index 73ea9db..9f2162b 100644
--- a/Source/kwsys/Process.h.in
+++ b/Source/kwsys/Process.h.in
@@ -180,8 +180,8 @@ kwsysEXPORT void kwsysProcess_SetPipeShared(kwsysProcess* cp, int pipe,
  * write end of the pipe will be closed in the parent process and the
  * read end will be closed in the child process.
  */
-kwsysEXPORT void kwsysProcess_SetPipeNative(kwsysProcess* cp, int pipe,
-                                            kwsysProcess_Pipe_Handle p[2]);
+kwsysEXPORT void kwsysProcess_SetPipeNative(
+  kwsysProcess* cp, int pipe, const kwsysProcess_Pipe_Handle p[2]);
 
 /**
  * Get/Set a possibly platform-specific option.  Possible options are:
diff --git a/Source/kwsys/ProcessUNIX.c b/Source/kwsys/ProcessUNIX.c
index f65690b..5fde0b0 100644
--- a/Source/kwsys/ProcessUNIX.c
+++ b/Source/kwsys/ProcessUNIX.c
@@ -152,10 +152,11 @@ static int kwsysProcessCreate(kwsysProcess* cp, int prIndex,
 static void kwsysProcessDestroy(kwsysProcess* cp);
 static int kwsysProcessSetupOutputPipeFile(int* p, const char* name);
 static int kwsysProcessSetupOutputPipeNative(int* p, int des[2]);
-static int kwsysProcessGetTimeoutTime(kwsysProcess* cp, double* userTimeout,
+static int kwsysProcessGetTimeoutTime(kwsysProcess* cp,
+                                      const double* userTimeout,
                                       kwsysProcessTime* timeoutTime);
 static int kwsysProcessGetTimeoutLeft(kwsysProcessTime* timeoutTime,
-                                      double* userTimeout,
+                                      const double* userTimeout,
                                       kwsysProcessTimeNative* timeoutLength,
                                       int zeroIsExpired);
 static kwsysProcessTime kwsysProcessTimeGetCurrent(void);
@@ -571,7 +572,7 @@ void kwsysProcess_SetPipeShared(kwsysProcess* cp, int prPipe, int shared)
   }
 }
 
-void kwsysProcess_SetPipeNative(kwsysProcess* cp, int prPipe, int p[2])
+void kwsysProcess_SetPipeNative(kwsysProcess* cp, int prPipe, const int p[2])
 {
   int* pPipeNative = 0;
 
@@ -1959,7 +1960,8 @@ static int kwsysProcessSetupOutputPipeNative(int* p, int des[2])
 
 /* Get the time at which either the process or user timeout will
    expire.  Returns 1 if the user timeout is first, and 0 otherwise.  */
-static int kwsysProcessGetTimeoutTime(kwsysProcess* cp, double* userTimeout,
+static int kwsysProcessGetTimeoutTime(kwsysProcess* cp,
+                                      const double* userTimeout,
                                       kwsysProcessTime* timeoutTime)
 {
   /* The first time this is called, we need to calculate the time at
@@ -1991,7 +1993,7 @@ static int kwsysProcessGetTimeoutTime(kwsysProcess* cp, double* userTimeout,
 /* Get the length of time before the given timeout time arrives.
    Returns 1 if the time has already arrived, and 0 otherwise.  */
 static int kwsysProcessGetTimeoutLeft(kwsysProcessTime* timeoutTime,
-                                      double* userTimeout,
+                                      const double* userTimeout,
                                       kwsysProcessTimeNative* timeoutLength,
                                       int zeroIsExpired)
 {
diff --git a/Source/kwsys/ProcessWin32.c b/Source/kwsys/ProcessWin32.c
index 68c5218..56bbd20 100644
--- a/Source/kwsys/ProcessWin32.c
+++ b/Source/kwsys/ProcessWin32.c
@@ -761,7 +761,7 @@ void kwsysProcess_SetPipeShared(kwsysProcess* cp, int pipe, int shared)
   }
 }
 
-void kwsysProcess_SetPipeNative(kwsysProcess* cp, int pipe, HANDLE p[2])
+void kwsysProcess_SetPipeNative(kwsysProcess* cp, int pipe, const HANDLE p[2])
 {
   HANDLE* pPipeNative = 0;
 
diff --git a/Source/kwsys/System.c b/Source/kwsys/System.c
index d43cc6f..dbfd2fd 100644
--- a/Source/kwsys/System.c
+++ b/Source/kwsys/System.c
@@ -22,7 +22,7 @@ typedef ptrdiff_t kwsysSystem_ptrdiff_t;
 typedef int kwsysSystem_ptrdiff_t;
 #endif
 
-static int kwsysSystem__AppendByte(char* local, char** begin, char** end,
+static int kwsysSystem__AppendByte(const char* local, char** begin, char** end,
                                    int* size, char c)
 {
   /* Allocate space for the character.  */
diff --git a/Source/kwsys/SystemInformation.cxx b/Source/kwsys/SystemInformation.cxx
index 6ec6e48..3cf64a8 100644
--- a/Source/kwsys/SystemInformation.cxx
+++ b/Source/kwsys/SystemInformation.cxx
@@ -132,7 +132,7 @@ typedef int siginfo_t;
 #    endif
 #  endif
 #  if defined(KWSYS_CXX_HAS_RLIMIT64)
-typedef struct rlimit64 ResourceLimitType;
+using ResourceLimitType = struct rlimit64;
 #    define GetResourceLimit getrlimit64
 #  else
 typedef struct rlimit ResourceLimitType;
@@ -303,34 +303,34 @@ T min(T a, T b)
 }
 
 extern "C" {
-typedef void (*SigAction)(int, siginfo_t*, void*);
+using SigAction = void (*)(int, siginfo_t*, void*);
 }
 
 //  Define SystemInformationImplementation class
-typedef void (*DELAY_FUNC)(unsigned int uiMS);
+using DELAY_FUNC = void (*)(unsigned int);
 
 class SystemInformationImplementation
 {
 public:
-  typedef SystemInformation::LongLong LongLong;
+  using LongLong = SystemInformation::LongLong;
   SystemInformationImplementation();
-  ~SystemInformationImplementation();
+  ~SystemInformationImplementation() = default;
 
-  const char* GetVendorString();
+  const char* GetVendorString() const;
   const char* GetVendorID();
-  std::string GetTypeID();
-  std::string GetFamilyID();
-  std::string GetModelID();
-  std::string GetModelName();
-  std::string GetSteppingCode();
-  const char* GetExtendedProcessorName();
-  const char* GetProcessorSerialNumber();
-  int GetProcessorCacheSize();
-  unsigned int GetLogicalProcessorsPerPhysical();
-  float GetProcessorClockFrequency();
-  int GetProcessorAPICID();
-  int GetProcessorCacheXSize(long int);
-  bool DoesCPUSupportFeature(long int);
+  std::string GetTypeID() const;
+  std::string GetFamilyID() const;
+  std::string GetModelID() const;
+  std::string GetModelName() const;
+  std::string GetSteppingCode() const;
+  const char* GetExtendedProcessorName() const;
+  const char* GetProcessorSerialNumber() const;
+  int GetProcessorCacheSize() const;
+  unsigned int GetLogicalProcessorsPerPhysical() const;
+  float GetProcessorClockFrequency() const;
+  int GetProcessorAPICID() const;
+  int GetProcessorCacheXSize(long int) const;
+  bool DoesCPUSupportFeature(long int) const;
 
   const char* GetOSName();
   const char* GetHostname();
@@ -339,24 +339,24 @@ public:
   const char* GetOSVersion();
   const char* GetOSPlatform();
 
-  bool Is64Bits();
+  bool Is64Bits() const;
 
-  unsigned int GetNumberOfLogicalCPU(); // per physical cpu
-  unsigned int GetNumberOfPhysicalCPU();
+  unsigned int GetNumberOfLogicalCPU() const; // per physical cpu
+  unsigned int GetNumberOfPhysicalCPU() const;
 
   bool DoesCPUSupportCPUID();
 
   // Retrieve memory information in MiB.
-  size_t GetTotalVirtualMemory();
-  size_t GetAvailableVirtualMemory();
-  size_t GetTotalPhysicalMemory();
-  size_t GetAvailablePhysicalMemory();
+  size_t GetTotalVirtualMemory() const;
+  size_t GetAvailableVirtualMemory() const;
+  size_t GetTotalPhysicalMemory() const;
+  size_t GetAvailablePhysicalMemory() const;
 
   LongLong GetProcessId();
 
   // Retrieve memory information in KiB.
   LongLong GetHostMemoryTotal();
-  LongLong GetHostMemoryAvailable(const char* envVarName);
+  LongLong GetHostMemoryAvailable(const char* hostLimitEnvVarName);
   LongLong GetHostMemoryUsed();
 
   LongLong GetProcMemoryAvailable(const char* hostLimitEnvVarName,
@@ -377,60 +377,103 @@ public:
   void RunMemoryCheck();
 
 public:
-  typedef struct tagID
+  using ID = struct tagID
+
   {
+
     int Type;
+
     int Family;
+
     int Model;
+
     int Revision;
+
     int ExtendedFamily;
+
     int ExtendedModel;
+
     std::string ProcessorName;
+
     std::string Vendor;
+
     std::string SerialNumber;
+
     std::string ModelName;
-  } ID;
+  };
+
+  using CPUPowerManagement = struct tagCPUPowerManagement
 
-  typedef struct tagCPUPowerManagement
   {
+
     bool HasVoltageID;
+
     bool HasFrequencyID;
+
     bool HasTempSenseDiode;
-  } CPUPowerManagement;
+  };
+
+  using CPUExtendedFeatures = struct tagCPUExtendedFeatures
 
-  typedef struct tagCPUExtendedFeatures
   {
+
     bool Has3DNow;
+
     bool Has3DNowPlus;
+
     bool SupportsMP;
+
     bool HasMMXPlus;
+
     bool HasSSEMMX;
+
     unsigned int LogicalProcessorsPerPhysical;
+
     int APIC_ID;
+
     CPUPowerManagement PowerManagement;
-  } CPUExtendedFeatures;
+  };
+
+  using CPUFeatures = struct CPUtagFeatures
 
-  typedef struct CPUtagFeatures
   {
+
     bool HasFPU;
+
     bool HasTSC;
+
     bool HasMMX;
+
     bool HasSSE;
+
     bool HasSSEFP;
+
     bool HasSSE2;
+
     bool HasIA64;
+
     bool HasAPIC;
+
     bool HasCMOV;
+
     bool HasMTRR;
+
     bool HasACPI;
+
     bool HasSerial;
+
     bool HasThermal;
+
     int CPUSpeed;
+
     int L1CacheSize;
+
     int L2CacheSize;
+
     int L3CacheSize;
+
     CPUExtendedFeatures ExtendedFeatures;
-  } CPUFeatures;
+  };
 
   enum Manufacturer
   {
@@ -476,7 +519,7 @@ protected:
 
   void CPUCountWindows();    // For windows
   unsigned char GetAPICId(); // For windows
-  bool IsSMTSupported();
+  bool IsSMTSupported() const;
   static LongLong GetCyclesDifference(DELAY_FUNC, unsigned int); // For windows
 
   // For Linux and Cygwin, /proc/cpuinfo formats are slightly different
@@ -885,7 +928,7 @@ int LoadLines(FILE* file, std::vector<std::string>& lines)
         *pBuf = '\0';
       pBuf += 1;
     }
-    lines.push_back(buf);
+    lines.emplace_back(buf);
     ++nRead;
   }
   if (ferror(file)) {
@@ -899,7 +942,7 @@ int LoadLines(FILE* file, std::vector<std::string>& lines)
 int LoadLines(const char* fileName, std::vector<std::string>& lines)
 {
   FILE* file = fopen(fileName, "r");
-  if (file == 0) {
+  if (file == nullptr) {
     return 0;
   }
   int nRead = LoadLines(file, lines);
@@ -1464,10 +1507,6 @@ SystemInformationImplementation::SystemInformationImplementation()
   this->OSIs64Bit = (sizeof(void*) == 8);
 }
 
-SystemInformationImplementation::~SystemInformationImplementation()
-{
-}
-
 void SystemInformationImplementation::RunCPUCheck()
 {
 #ifdef _WIN32
@@ -1564,7 +1603,7 @@ void SystemInformationImplementation::RunMemoryCheck()
 }
 
 /** Get the vendor string */
-const char* SystemInformationImplementation::GetVendorString()
+const char* SystemInformationImplementation::GetVendorString() const
 {
   return this->ChipID.Vendor.c_str();
 }
@@ -1760,7 +1799,7 @@ const char* SystemInformationImplementation::GetVendorID()
 }
 
 /** Return the type ID of the CPU */
-std::string SystemInformationImplementation::GetTypeID()
+std::string SystemInformationImplementation::GetTypeID() const
 {
   std::ostringstream str;
   str << this->ChipID.Type;
@@ -1768,7 +1807,7 @@ std::string SystemInformationImplementation::GetTypeID()
 }
 
 /** Return the family of the CPU present */
-std::string SystemInformationImplementation::GetFamilyID()
+std::string SystemInformationImplementation::GetFamilyID() const
 {
   std::ostringstream str;
   str << this->ChipID.Family;
@@ -1776,7 +1815,7 @@ std::string SystemInformationImplementation::GetFamilyID()
 }
 
 // Return the model of CPU present */
-std::string SystemInformationImplementation::GetModelID()
+std::string SystemInformationImplementation::GetModelID() const
 {
   std::ostringstream str;
   str << this->ChipID.Model;
@@ -1784,13 +1823,13 @@ std::string SystemInformationImplementation::GetModelID()
 }
 
 // Return the model name of CPU present */
-std::string SystemInformationImplementation::GetModelName()
+std::string SystemInformationImplementation::GetModelName() const
 {
   return this->ChipID.ModelName;
 }
 
 /** Return the stepping code of the CPU present. */
-std::string SystemInformationImplementation::GetSteppingCode()
+std::string SystemInformationImplementation::GetSteppingCode() const
 {
   std::ostringstream str;
   str << this->ChipID.Revision;
@@ -1798,44 +1837,46 @@ std::string SystemInformationImplementation::GetSteppingCode()
 }
 
 /** Return the stepping code of the CPU present. */
-const char* SystemInformationImplementation::GetExtendedProcessorName()
+const char* SystemInformationImplementation::GetExtendedProcessorName() const
 {
   return this->ChipID.ProcessorName.c_str();
 }
 
 /** Return the serial number of the processor
  *  in hexadecimal: xxxx-xxxx-xxxx-xxxx-xxxx-xxxx. */
-const char* SystemInformationImplementation::GetProcessorSerialNumber()
+const char* SystemInformationImplementation::GetProcessorSerialNumber() const
 {
   return this->ChipID.SerialNumber.c_str();
 }
 
 /** Return the logical processors per physical */
 unsigned int SystemInformationImplementation::GetLogicalProcessorsPerPhysical()
+  const
 {
   return this->Features.ExtendedFeatures.LogicalProcessorsPerPhysical;
 }
 
 /** Return the processor clock frequency. */
-float SystemInformationImplementation::GetProcessorClockFrequency()
+float SystemInformationImplementation::GetProcessorClockFrequency() const
 {
   return this->CPUSpeedInMHz;
 }
 
 /**  Return the APIC ID. */
-int SystemInformationImplementation::GetProcessorAPICID()
+int SystemInformationImplementation::GetProcessorAPICID() const
 {
   return this->Features.ExtendedFeatures.APIC_ID;
 }
 
 /** Return the L1 cache size. */
-int SystemInformationImplementation::GetProcessorCacheSize()
+int SystemInformationImplementation::GetProcessorCacheSize() const
 {
   return this->Features.L1CacheSize;
 }
 
 /** Return the chosen cache size. */
-int SystemInformationImplementation::GetProcessorCacheXSize(long int dwCacheID)
+int SystemInformationImplementation::GetProcessorCacheXSize(
+  long int dwCacheID) const
 {
   switch (dwCacheID) {
     case SystemInformation::CPU_FEATURE_L1CACHE:
@@ -1848,7 +1889,8 @@ int SystemInformationImplementation::GetProcessorCacheXSize(long int dwCacheID)
   return -1;
 }
 
-bool SystemInformationImplementation::DoesCPUSupportFeature(long int dwFeature)
+bool SystemInformationImplementation::DoesCPUSupportFeature(
+  long int dwFeature) const
 {
   bool bHasFeature = false;
 
@@ -3409,7 +3451,7 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile()
   // We want to record the total number of cores in this->NumberOfPhysicalCPU
   // (checking only the first proc)
   std::string Cores = this->ExtractValueFromCpuInfoFile(buffer, "cpu cores");
-  unsigned int NumberOfCoresPerSocket = (unsigned int)atoi(Cores.c_str());
+  auto NumberOfCoresPerSocket = (unsigned int)atoi(Cores.c_str());
   NumberOfCoresPerSocket = std::max(NumberOfCoresPerSocket, 1u);
   this->NumberOfPhysicalCPU =
     NumberOfCoresPerSocket * (unsigned int)NumberOfSockets;
@@ -3441,7 +3483,7 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile()
     // Linux Sparc: CPU speed is in Hz and encoded in hexadecimal
     CPUSpeed = this->ExtractValueFromCpuInfoFile(buffer, "Cpu0ClkTck");
     this->CPUSpeedInMHz =
-      static_cast<float>(strtoull(CPUSpeed.c_str(), 0, 16)) / 1000000.0f;
+      static_cast<float>(strtoull(CPUSpeed.c_str(), nullptr, 16)) / 1000000.0f;
   }
 #endif
 
@@ -3502,9 +3544,8 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile()
   cachename.push_back("D-cache");    // e.g. PA-RISC
 
   this->Features.L1CacheSize = 0;
-  for (size_t index = 0; index < cachename.size(); index++) {
-    std::string cacheSize =
-      this->ExtractValueFromCpuInfoFile(buffer, cachename[index]);
+  for (auto& index : cachename) {
+    std::string cacheSize = this->ExtractValueFromCpuInfoFile(buffer, index);
     if (!cacheSize.empty()) {
       pos = cacheSize.find(" KB");
       if (pos != std::string::npos) {
@@ -4249,24 +4290,24 @@ bool SystemInformationImplementation::QueryMemory()
 }
 
 /** */
-size_t SystemInformationImplementation::GetTotalVirtualMemory()
+size_t SystemInformationImplementation::GetTotalVirtualMemory() const
 {
   return this->TotalVirtualMemory;
 }
 
 /** */
-size_t SystemInformationImplementation::GetAvailableVirtualMemory()
+size_t SystemInformationImplementation::GetAvailableVirtualMemory() const
 {
   return this->AvailableVirtualMemory;
 }
 
-size_t SystemInformationImplementation::GetTotalPhysicalMemory()
+size_t SystemInformationImplementation::GetTotalPhysicalMemory() const
 {
   return this->TotalPhysicalMemory;
 }
 
 /** */
-size_t SystemInformationImplementation::GetAvailablePhysicalMemory()
+size_t SystemInformationImplementation::GetAvailablePhysicalMemory() const
 {
   return this->AvailablePhysicalMemory;
 }
@@ -4350,7 +4391,7 @@ void SystemInformationImplementation::DelayOverhead(unsigned int uiMS)
 }
 
 /** Works only for windows */
-bool SystemInformationImplementation::IsSMTSupported()
+bool SystemInformationImplementation::IsSMTSupported() const
 {
   return this->Features.ExtendedFeatures.LogicalProcessorsPerPhysical > 1;
 }
@@ -4432,13 +4473,13 @@ void SystemInformationImplementation::CPUCountWindows()
 }
 
 /** Return the number of logical CPUs on the system */
-unsigned int SystemInformationImplementation::GetNumberOfLogicalCPU()
+unsigned int SystemInformationImplementation::GetNumberOfLogicalCPU() const
 {
   return this->NumberOfLogicalCPU;
 }
 
 /** Return the number of physical CPUs on the system */
-unsigned int SystemInformationImplementation::GetNumberOfPhysicalCPU()
+unsigned int SystemInformationImplementation::GetNumberOfPhysicalCPU() const
 {
   return this->NumberOfPhysicalCPU;
 }
@@ -4739,8 +4780,8 @@ std::string SystemInformationImplementation::ParseValueFromKStat(
   args.reserve(3 + args_string.size());
   args.push_back("kstat");
   args.push_back("-p");
-  for (size_t i = 0; i < args_string.size(); ++i) {
-    args.push_back(args_string[i].c_str());
+  for (auto& i : args_string) {
+    args.push_back(i.c_str());
   }
   args.push_back(nullptr);
 
@@ -5459,7 +5500,7 @@ void SystemInformationImplementation::TrimNewline(std::string& output)
 }
 
 /** Return true if the machine is 64 bits */
-bool SystemInformationImplementation::Is64Bits()
+bool SystemInformationImplementation::Is64Bits() const
 {
   return this->OSIs64Bit;
 }
diff --git a/Source/kwsys/SystemTools.cxx b/Source/kwsys/SystemTools.cxx
index f11eff7..3fa1745 100644
--- a/Source/kwsys/SystemTools.cxx
+++ b/Source/kwsys/SystemTools.cxx
@@ -350,7 +350,7 @@ extern int putenv(char* __string) __THROW;
 
 namespace KWSYS_NAMESPACE {
 
-double SystemTools::GetTime(void)
+double SystemTools::GetTime()
 {
 #if defined(_WIN32) && !defined(__CYGWIN__)
   FILETIME ft;
@@ -368,7 +368,7 @@ double SystemTools::GetTime(void)
 #if defined(_WIN32)
 typedef wchar_t envchar;
 #else
-typedef char envchar;
+using envchar = char;
 #endif
 
 /* Order by environment key only (VAR from VAR=VALUE).  */
@@ -421,7 +421,7 @@ public:
   const envchar* Release(const envchar* env)
   {
     const envchar* old = nullptr;
-    iterator i = this->find(env);
+    auto i = this->find(env);
     if (i != this->end()) {
       old = *i;
       this->erase(i);
@@ -452,7 +452,7 @@ struct SystemToolsPathCaseCmp
 class SystemToolsStatic
 {
 public:
-  typedef std::map<std::string, std::string> StringMap;
+  using StringMap = std::map<std::string, std::string>;
 #if KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP
   /**
    * Path translation table from dir to refdir
@@ -488,7 +488,7 @@ public:
    */
   static std::string FindName(
     const std::string& name,
-    const std::vector<std::string>& path = std::vector<std::string>(),
+    const std::vector<std::string>& userPaths = std::vector<std::string>(),
     bool no_system_path = false);
 };
 
@@ -613,8 +613,7 @@ void SystemTools::GetPath(std::vector<std::string>& path, const char* env)
       done = true;
     }
   }
-  for (std::vector<std::string>::iterator i = path.begin() + old_size;
-       i != path.end(); ++i) {
+  for (auto i = path.begin() + old_size; i != path.end(); ++i) {
     SystemTools::ConvertToUnixSlashes(*i);
   }
 }
@@ -1858,7 +1857,7 @@ char* SystemTools::DuplicateString(const char* str)
 // Return a cropped string
 std::string SystemTools::CropString(const std::string& s, size_t max_len)
 {
-  if (!s.size() || max_len == 0 || max_len >= s.size()) {
+  if (s.empty() || max_len == 0 || max_len >= s.size()) {
     return s;
   }
 
@@ -1893,7 +1892,7 @@ std::vector<std::string> SystemTools::SplitString(const std::string& p,
   }
   if (isPath && path[0] == '/') {
     path.erase(path.begin());
-    paths.push_back("/");
+    paths.emplace_back("/");
   }
   std::string::size_type pos1 = 0;
   std::string::size_type pos2 = path.find(sep, pos1 + 1);
@@ -3571,14 +3570,14 @@ void SystemTools::SplitPath(const std::string& p,
   for (; *last; ++last) {
     if (*last == '/' || *last == '\\') {
       // End of a component.  Save it.
-      components.push_back(std::string(first, last));
+      components.emplace_back(first, last);
       first = last + 1;
     }
   }
 
   // Save the last component unless there were no components.
   if (last != c) {
-    components.push_back(std::string(first, last));
+    components.emplace_back(first, last);
   }
 }
 
@@ -3594,7 +3593,7 @@ std::string SystemTools::JoinPath(
   // Construct result in a single string.
   std::string result;
   size_t len = 0;
-  for (std::vector<std::string>::const_iterator i = first; i != last; ++i) {
+  for (auto i = first; i != last; ++i) {
     len += 1 + i->size();
   }
   result.reserve(len);
@@ -3828,7 +3827,7 @@ SystemTools::FileTypeEnum SystemTools::DetectFileType(const char* filename,
 
   // Allocate buffer and read bytes
 
-  unsigned char* buffer = new unsigned char[length];
+  auto* buffer = new unsigned char[length];
   size_t read_length = fread(buffer, 1, length, fp);
   fclose(fp);
   if (read_length == 0) {
diff --git a/Source/kwsys/kwsysPlatformTests.cmake b/Source/kwsys/kwsysPlatformTests.cmake
index 28d3f68..89be4b8 100644
--- a/Source/kwsys/kwsysPlatformTests.cmake
+++ b/Source/kwsys/kwsysPlatformTests.cmake
@@ -1,185 +1,185 @@
 # Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
 # file Copyright.txt or https://cmake.org/licensing#kwsys for details.
 
-SET(KWSYS_PLATFORM_TEST_FILE_C kwsysPlatformTestsC.c)
-SET(KWSYS_PLATFORM_TEST_FILE_CXX kwsysPlatformTestsCXX.cxx)
+set(KWSYS_PLATFORM_TEST_FILE_C kwsysPlatformTestsC.c)
+set(KWSYS_PLATFORM_TEST_FILE_CXX kwsysPlatformTestsCXX.cxx)
 
-MACRO(KWSYS_PLATFORM_TEST lang var description invert)
-  IF(NOT DEFINED ${var}_COMPILED)
-    MESSAGE(STATUS "${description}")
+macro(KWSYS_PLATFORM_TEST lang var description invert)
+  if(NOT DEFINED ${var}_COMPILED)
+    message(STATUS "${description}")
     set(maybe_cxx_standard "")
     if(CMAKE_VERSION VERSION_LESS 3.8 AND CMAKE_CXX_STANDARD)
       set(maybe_cxx_standard "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}")
     endif()
-    TRY_COMPILE(${var}_COMPILED
+    try_compile(${var}_COMPILED
       ${CMAKE_CURRENT_BINARY_DIR}
       ${CMAKE_CURRENT_SOURCE_DIR}/${KWSYS_PLATFORM_TEST_FILE_${lang}}
       COMPILE_DEFINITIONS -DTEST_${var} ${KWSYS_PLATFORM_TEST_DEFINES} ${KWSYS_PLATFORM_TEST_EXTRA_FLAGS}
       CMAKE_FLAGS "-DLINK_LIBRARIES:STRING=${KWSYS_PLATFORM_TEST_LINK_LIBRARIES}"
                   ${maybe_cxx_standard}
       OUTPUT_VARIABLE OUTPUT)
-    IF(${var}_COMPILED)
-      FILE(APPEND
+    if(${var}_COMPILED)
+      file(APPEND
         ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
         "${description} compiled with the following output:\n${OUTPUT}\n\n")
-    ELSE()
-      FILE(APPEND
+    else()
+      file(APPEND
         ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
         "${description} failed to compile with the following output:\n${OUTPUT}\n\n")
-    ENDIF()
-    IF(${invert} MATCHES INVERT)
-      IF(${var}_COMPILED)
-        MESSAGE(STATUS "${description} - no")
-      ELSE()
-        MESSAGE(STATUS "${description} - yes")
-      ENDIF()
-    ELSE()
-      IF(${var}_COMPILED)
-        MESSAGE(STATUS "${description} - yes")
-      ELSE()
-        MESSAGE(STATUS "${description} - no")
-      ENDIF()
-    ENDIF()
-  ENDIF()
-  IF(${invert} MATCHES INVERT)
-    IF(${var}_COMPILED)
-      SET(${var} 0)
-    ELSE()
-      SET(${var} 1)
-    ENDIF()
-  ELSE()
-    IF(${var}_COMPILED)
-      SET(${var} 1)
-    ELSE()
-      SET(${var} 0)
-    ENDIF()
-  ENDIF()
-ENDMACRO()
+    endif()
+    if(${invert} MATCHES INVERT)
+      if(${var}_COMPILED)
+        message(STATUS "${description} - no")
+      else()
+        message(STATUS "${description} - yes")
+      endif()
+    else()
+      if(${var}_COMPILED)
+        message(STATUS "${description} - yes")
+      else()
+        message(STATUS "${description} - no")
+      endif()
+    endif()
+  endif()
+  if(${invert} MATCHES INVERT)
+    if(${var}_COMPILED)
+      set(${var} 0)
+    else()
+      set(${var} 1)
+    endif()
+  else()
+    if(${var}_COMPILED)
+      set(${var} 1)
+    else()
+      set(${var} 0)
+    endif()
+  endif()
+endmacro()
 
-MACRO(KWSYS_PLATFORM_TEST_RUN lang var description invert)
-  IF(NOT DEFINED ${var})
-    MESSAGE(STATUS "${description}")
-    TRY_RUN(${var} ${var}_COMPILED
+macro(KWSYS_PLATFORM_TEST_RUN lang var description invert)
+  if(NOT DEFINED ${var})
+    message(STATUS "${description}")
+    try_run(${var} ${var}_COMPILED
       ${CMAKE_CURRENT_BINARY_DIR}
       ${CMAKE_CURRENT_SOURCE_DIR}/${KWSYS_PLATFORM_TEST_FILE_${lang}}
       COMPILE_DEFINITIONS -DTEST_${var} ${KWSYS_PLATFORM_TEST_DEFINES} ${KWSYS_PLATFORM_TEST_EXTRA_FLAGS}
       OUTPUT_VARIABLE OUTPUT)
 
     # Note that ${var} will be a 0 return value on success.
-    IF(${var}_COMPILED)
-      IF(${var})
-        FILE(APPEND
+    if(${var}_COMPILED)
+      if(${var})
+        file(APPEND
           ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
           "${description} compiled but failed to run with the following output:\n${OUTPUT}\n\n")
-      ELSE()
-        FILE(APPEND
+      else()
+        file(APPEND
           ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
           "${description} compiled and ran with the following output:\n${OUTPUT}\n\n")
-      ENDIF()
-    ELSE()
-      FILE(APPEND
+      endif()
+    else()
+      file(APPEND
         ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
         "${description} failed to compile with the following output:\n${OUTPUT}\n\n")
-      SET(${var} -1 CACHE INTERNAL "${description} failed to compile.")
-    ENDIF()
+      set(${var} -1 CACHE INTERNAL "${description} failed to compile.")
+    endif()
 
-    IF(${invert} MATCHES INVERT)
-      IF(${var}_COMPILED)
-        IF(${var})
-          MESSAGE(STATUS "${description} - yes")
-        ELSE()
-          MESSAGE(STATUS "${description} - no")
-        ENDIF()
-      ELSE()
-        MESSAGE(STATUS "${description} - failed to compile")
-      ENDIF()
-    ELSE()
-      IF(${var}_COMPILED)
-        IF(${var})
-          MESSAGE(STATUS "${description} - no")
-        ELSE()
-          MESSAGE(STATUS "${description} - yes")
-        ENDIF()
-      ELSE()
-        MESSAGE(STATUS "${description} - failed to compile")
-      ENDIF()
-    ENDIF()
-  ENDIF()
+    if(${invert} MATCHES INVERT)
+      if(${var}_COMPILED)
+        if(${var})
+          message(STATUS "${description} - yes")
+        else()
+          message(STATUS "${description} - no")
+        endif()
+      else()
+        message(STATUS "${description} - failed to compile")
+      endif()
+    else()
+      if(${var}_COMPILED)
+        if(${var})
+          message(STATUS "${description} - no")
+        else()
+          message(STATUS "${description} - yes")
+        endif()
+      else()
+        message(STATUS "${description} - failed to compile")
+      endif()
+    endif()
+  endif()
 
-  IF(${invert} MATCHES INVERT)
-    IF(${var}_COMPILED)
-      IF(${var})
-        SET(${var} 1)
-      ELSE()
-        SET(${var} 0)
-      ENDIF()
-    ELSE()
-      SET(${var} 1)
-    ENDIF()
-  ELSE()
-    IF(${var}_COMPILED)
-      IF(${var})
-        SET(${var} 0)
-      ELSE()
-        SET(${var} 1)
-      ENDIF()
-    ELSE()
-      SET(${var} 0)
-    ENDIF()
-  ENDIF()
-ENDMACRO()
+  if(${invert} MATCHES INVERT)
+    if(${var}_COMPILED)
+      if(${var})
+        set(${var} 1)
+      else()
+        set(${var} 0)
+      endif()
+    else()
+      set(${var} 1)
+    endif()
+  else()
+    if(${var}_COMPILED)
+      if(${var})
+        set(${var} 0)
+      else()
+        set(${var} 1)
+      endif()
+    else()
+      set(${var} 0)
+    endif()
+  endif()
+endmacro()
 
-MACRO(KWSYS_PLATFORM_C_TEST var description invert)
-  SET(KWSYS_PLATFORM_TEST_DEFINES ${KWSYS_PLATFORM_C_TEST_DEFINES})
-  SET(KWSYS_PLATFORM_TEST_EXTRA_FLAGS ${KWSYS_PLATFORM_C_TEST_EXTRA_FLAGS})
+macro(KWSYS_PLATFORM_C_TEST var description invert)
+  set(KWSYS_PLATFORM_TEST_DEFINES ${KWSYS_PLATFORM_C_TEST_DEFINES})
+  set(KWSYS_PLATFORM_TEST_EXTRA_FLAGS ${KWSYS_PLATFORM_C_TEST_EXTRA_FLAGS})
   KWSYS_PLATFORM_TEST(C "${var}" "${description}" "${invert}")
-  SET(KWSYS_PLATFORM_TEST_DEFINES)
-  SET(KWSYS_PLATFORM_TEST_EXTRA_FLAGS)
-ENDMACRO()
+  set(KWSYS_PLATFORM_TEST_DEFINES)
+  set(KWSYS_PLATFORM_TEST_EXTRA_FLAGS)
+endmacro()
 
-MACRO(KWSYS_PLATFORM_C_TEST_RUN var description invert)
-  SET(KWSYS_PLATFORM_TEST_DEFINES ${KWSYS_PLATFORM_C_TEST_DEFINES})
-  SET(KWSYS_PLATFORM_TEST_EXTRA_FLAGS ${KWSYS_PLATFORM_C_TEST_EXTRA_FLAGS})
+macro(KWSYS_PLATFORM_C_TEST_RUN var description invert)
+  set(KWSYS_PLATFORM_TEST_DEFINES ${KWSYS_PLATFORM_C_TEST_DEFINES})
+  set(KWSYS_PLATFORM_TEST_EXTRA_FLAGS ${KWSYS_PLATFORM_C_TEST_EXTRA_FLAGS})
   KWSYS_PLATFORM_TEST_RUN(C "${var}" "${description}" "${invert}")
-  SET(KWSYS_PLATFORM_TEST_DEFINES)
-  SET(KWSYS_PLATFORM_TEST_EXTRA_FLAGS)
-ENDMACRO()
+  set(KWSYS_PLATFORM_TEST_DEFINES)
+  set(KWSYS_PLATFORM_TEST_EXTRA_FLAGS)
+endmacro()
 
-MACRO(KWSYS_PLATFORM_CXX_TEST var description invert)
-  SET(KWSYS_PLATFORM_TEST_DEFINES ${KWSYS_PLATFORM_CXX_TEST_DEFINES})
-  SET(KWSYS_PLATFORM_TEST_EXTRA_FLAGS ${KWSYS_PLATFORM_CXX_TEST_EXTRA_FLAGS})
-  SET(KWSYS_PLATFORM_TEST_LINK_LIBRARIES ${KWSYS_PLATFORM_CXX_TEST_LINK_LIBRARIES})
+macro(KWSYS_PLATFORM_CXX_TEST var description invert)
+  set(KWSYS_PLATFORM_TEST_DEFINES ${KWSYS_PLATFORM_CXX_TEST_DEFINES})
+  set(KWSYS_PLATFORM_TEST_EXTRA_FLAGS ${KWSYS_PLATFORM_CXX_TEST_EXTRA_FLAGS})
+  set(KWSYS_PLATFORM_TEST_LINK_LIBRARIES ${KWSYS_PLATFORM_CXX_TEST_LINK_LIBRARIES})
   KWSYS_PLATFORM_TEST(CXX "${var}" "${description}" "${invert}")
-  SET(KWSYS_PLATFORM_TEST_DEFINES)
-  SET(KWSYS_PLATFORM_TEST_EXTRA_FLAGS)
-  SET(KWSYS_PLATFORM_TEST_LINK_LIBRARIES)
-ENDMACRO()
+  set(KWSYS_PLATFORM_TEST_DEFINES)
+  set(KWSYS_PLATFORM_TEST_EXTRA_FLAGS)
+  set(KWSYS_PLATFORM_TEST_LINK_LIBRARIES)
+endmacro()
 
-MACRO(KWSYS_PLATFORM_CXX_TEST_RUN var description invert)
-  SET(KWSYS_PLATFORM_TEST_DEFINES ${KWSYS_PLATFORM_CXX_TEST_DEFINES})
-  SET(KWSYS_PLATFORM_TEST_EXTRA_FLAGS ${KWSYS_PLATFORM_CXX_TEST_EXTRA_FLAGS})
+macro(KWSYS_PLATFORM_CXX_TEST_RUN var description invert)
+  set(KWSYS_PLATFORM_TEST_DEFINES ${KWSYS_PLATFORM_CXX_TEST_DEFINES})
+  set(KWSYS_PLATFORM_TEST_EXTRA_FLAGS ${KWSYS_PLATFORM_CXX_TEST_EXTRA_FLAGS})
   KWSYS_PLATFORM_TEST_RUN(CXX "${var}" "${description}" "${invert}")
-  SET(KWSYS_PLATFORM_TEST_DEFINES)
-  SET(KWSYS_PLATFORM_TEST_EXTRA_FLAGS)
-ENDMACRO()
+  set(KWSYS_PLATFORM_TEST_DEFINES)
+  set(KWSYS_PLATFORM_TEST_EXTRA_FLAGS)
+endmacro()
 
 #-----------------------------------------------------------------------------
 # KWSYS_PLATFORM_INFO_TEST(lang var description)
 #
 # Compile test named by ${var} and store INFO strings extracted from binary.
-MACRO(KWSYS_PLATFORM_INFO_TEST lang var description)
+macro(KWSYS_PLATFORM_INFO_TEST lang var description)
   # We can implement this macro on CMake 2.6 and above.
-  IF("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.6)
-    SET(${var} "")
-  ELSE()
+  if("${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}" LESS 2.6)
+    set(${var} "")
+  else()
     # Choose a location for the result binary.
-    SET(KWSYS_PLATFORM_INFO_FILE
+    set(KWSYS_PLATFORM_INFO_FILE
       ${CMAKE_CURRENT_BINARY_DIR}/${CMAKE_FILES_DIRECTORY}/${var}.bin)
 
     # Compile the test binary.
-    IF(NOT EXISTS ${KWSYS_PLATFORM_INFO_FILE})
-      MESSAGE(STATUS "${description}")
-      TRY_COMPILE(${var}_COMPILED
+    if(NOT EXISTS ${KWSYS_PLATFORM_INFO_FILE})
+      message(STATUS "${description}")
+      try_compile(${var}_COMPILED
         ${CMAKE_CURRENT_BINARY_DIR}
         ${CMAKE_CURRENT_SOURCE_DIR}/${KWSYS_PLATFORM_TEST_FILE_${lang}}
         COMPILE_DEFINITIONS -DTEST_${var}
@@ -188,29 +188,29 @@ MACRO(KWSYS_PLATFORM_INFO_TEST lang var description)
         OUTPUT_VARIABLE OUTPUT
         COPY_FILE ${KWSYS_PLATFORM_INFO_FILE}
         )
-      IF(${var}_COMPILED)
-        FILE(APPEND
+      if(${var}_COMPILED)
+        file(APPEND
           ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeOutput.log
           "${description} compiled with the following output:\n${OUTPUT}\n\n")
-      ELSE()
-        FILE(APPEND
+      else()
+        file(APPEND
           ${CMAKE_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/CMakeError.log
           "${description} failed to compile with the following output:\n${OUTPUT}\n\n")
-      ENDIF()
-      IF(${var}_COMPILED)
-        MESSAGE(STATUS "${description} - compiled")
-      ELSE()
-        MESSAGE(STATUS "${description} - failed")
-      ENDIF()
-    ENDIF()
+      endif()
+      if(${var}_COMPILED)
+        message(STATUS "${description} - compiled")
+      else()
+        message(STATUS "${description} - failed")
+      endif()
+    endif()
 
     # Parse info strings out of the compiled binary.
-    IF(${var}_COMPILED)
-      FILE(STRINGS ${KWSYS_PLATFORM_INFO_FILE} ${var} REGEX "INFO:[A-Za-z0-9]+\\[[^]]*\\]")
-    ELSE()
-      SET(${var} "")
-    ENDIF()
+    if(${var}_COMPILED)
+      file(STRINGS ${KWSYS_PLATFORM_INFO_FILE} ${var} REGEX "INFO:[A-Za-z0-9]+\\[[^]]*\\]")
+    else()
+      set(${var} "")
+    endif()
 
-    SET(KWSYS_PLATFORM_INFO_FILE)
-  ENDIF()
-ENDMACRO()
+    set(KWSYS_PLATFORM_INFO_FILE)
+  endif()
+endmacro()
diff --git a/Source/kwsys/testCommandLineArguments.cxx b/Source/kwsys/testCommandLineArguments.cxx
index 1778a9b..79ebe1a 100644
--- a/Source/kwsys/testCommandLineArguments.cxx
+++ b/Source/kwsys/testCommandLineArguments.cxx
@@ -98,7 +98,7 @@ int testCommandLineArguments(int argc, char* argv[])
   std::vector<std::string> stl_strings_argument;
   std::string valid_stl_strings[] = { "ken", "brad", "bill", "andy" };
 
-  typedef kwsys::CommandLineArguments argT;
+  using argT = kwsys::CommandLineArguments;
 
   arg.AddArgument("--some-int-variable", argT::SPACE_ARGUMENT,
                   &some_int_variable, "Set some random int variable");
diff --git a/Source/kwsys/testCommandLineArguments1.cxx b/Source/kwsys/testCommandLineArguments1.cxx
index 64561b1..cbc3002 100644
--- a/Source/kwsys/testCommandLineArguments1.cxx
+++ b/Source/kwsys/testCommandLineArguments1.cxx
@@ -25,7 +25,7 @@ int testCommandLineArguments1(int argc, char* argv[])
   std::string p;
   int res = 0;
 
-  typedef kwsys::CommandLineArguments argT;
+  using argT = kwsys::CommandLineArguments;
   arg.AddArgument("-n", argT::SPACE_ARGUMENT, &n, "Argument N");
   arg.AddArgument("-m", argT::EQUAL_ARGUMENT, &m, "Argument M");
   arg.AddBooleanArgument("-p", &p, "Argument P");
diff --git a/Source/kwsys/testDynamicLoader.cxx b/Source/kwsys/testDynamicLoader.cxx
index 2421ac0..703ad4d 100644
--- a/Source/kwsys/testDynamicLoader.cxx
+++ b/Source/kwsys/testDynamicLoader.cxx
@@ -25,7 +25,7 @@ static std::string GetLibName(const char* lname, const char* subdir = nullptr)
 {
   // Construct proper name of lib
   std::string slname;
-  slname = EXECUTABLE_OUTPUT_PATH;
+  slname = RUNTIME_OUTPUT_DIRECTORY;
   if (subdir) {
     slname += "/";
     slname += subdir;
diff --git a/Source/kwsys/testEncoding.cxx b/Source/kwsys/testEncoding.cxx
index 988697b..d672aed 100644
--- a/Source/kwsys/testEncoding.cxx
+++ b/Source/kwsys/testEncoding.cxx
@@ -85,7 +85,7 @@ static int testRobustEncoding()
   std::wstring wstr = kwsys::Encoding::ToWide(cstr);
 
   wstr = kwsys::Encoding::ToWide(nullptr);
-  if (wstr != L"") {
+  if (!wstr.empty()) {
     const wchar_t* wcstr = wstr.c_str();
     std::cout << "ToWide(NULL) returned";
     for (size_t i = 0; i < wstr.size(); i++) {
@@ -95,7 +95,7 @@ static int testRobustEncoding()
     ret++;
   }
   wstr = kwsys::Encoding::ToWide("");
-  if (wstr != L"") {
+  if (!wstr.empty()) {
     const wchar_t* wcstr = wstr.c_str();
     std::cout << "ToWide(\"\") returned";
     for (size_t i = 0; i < wstr.size(); i++) {
@@ -113,13 +113,13 @@ static int testRobustEncoding()
 #endif
 
   std::string str = kwsys::Encoding::ToNarrow(nullptr);
-  if (str != "") {
+  if (!str.empty()) {
     std::cout << "ToNarrow(NULL) returned " << str << std::endl;
     ret++;
   }
 
   str = kwsys::Encoding::ToNarrow(L"");
-  if (wstr != L"") {
+  if (!wstr.empty()) {
     std::cout << "ToNarrow(\"\") returned " << str << std::endl;
     ret++;
   }
@@ -140,14 +140,13 @@ static int testWithNulls()
   strings.push_back(std::string("k") + '\0' + '\0');
   strings.push_back(std::string("\0\0\0\0", 4) + "lmn" +
                     std::string("\0\0\0\0", 4));
-  for (std::vector<std::string>::iterator it = strings.begin();
-       it != strings.end(); ++it) {
-    std::wstring wstr = kwsys::Encoding::ToWide(*it);
+  for (auto& string : strings) {
+    std::wstring wstr = kwsys::Encoding::ToWide(string);
     std::string str = kwsys::Encoding::ToNarrow(wstr);
-    std::string s(*it);
+    std::string s(string);
     std::replace(s.begin(), s.end(), '\0', ' ');
-    std::cout << "'" << s << "' (" << it->size() << ")" << std::endl;
-    if (str != *it) {
+    std::cout << "'" << s << "' (" << string.size() << ")" << std::endl;
+    if (str != string) {
       std::replace(str.begin(), str.end(), '\0', ' ');
       std::cout << "string with null was different: '" << str << "' ("
                 << str.size() << ")" << std::endl;
diff --git a/Source/kwsys/testHashSTL.cxx b/Source/kwsys/testHashSTL.cxx
index 4ed2f89..18cae7f 100644
--- a/Source/kwsys/testHashSTL.cxx
+++ b/Source/kwsys/testHashSTL.cxx
@@ -27,30 +27,30 @@ template class kwsys::hash_set<int>;
 
 static bool test_hash_map()
 {
-  typedef kwsys::hash_map<const char*, int> mtype;
+  using mtype = kwsys::hash_map<const char*, int>;
   mtype m;
   const char* keys[] = { "hello", "world" };
   m[keys[0]] = 1;
   m.insert(mtype::value_type(keys[1], 2));
   int sum = 0;
-  for (mtype::iterator mi = m.begin(); mi != m.end(); ++mi) {
-    std::cout << "Found entry [" << mi->first << "," << mi->second << "]"
+  for (auto& mi : m) {
+    std::cout << "Found entry [" << mi.first << "," << mi.second << "]"
               << std::endl;
-    sum += mi->second;
+    sum += mi.second;
   }
   return sum == 3;
 }
 
 static bool test_hash_set()
 {
-  typedef kwsys::hash_set<int> stype;
+  using stype = kwsys::hash_set<int>;
   stype s;
   s.insert(1);
   s.insert(2);
   int sum = 0;
-  for (stype::iterator si = s.begin(); si != s.end(); ++si) {
-    std::cout << "Found entry [" << *si << "]" << std::endl;
-    sum += *si;
+  for (int si : s) {
+    std::cout << "Found entry [" << si << "]" << std::endl;
+    sum += si;
   }
   return sum == 3;
 }
diff --git a/Source/kwsys/testSystemTools.cxx b/Source/kwsys/testSystemTools.cxx
index 6afc326..670e8dc 100644
--- a/Source/kwsys/testSystemTools.cxx
+++ b/Source/kwsys/testSystemTools.cxx
@@ -721,8 +721,7 @@ static std::string StringVectorToString(const std::vector<std::string>& vec)
 {
   std::stringstream ss;
   ss << "vector(";
-  for (std::vector<std::string>::const_iterator i = vec.begin();
-       i != vec.end(); ++i) {
+  for (auto i = vec.begin(); i != vec.end(); ++i) {
     if (i != vec.begin()) {
       ss << ", ";
     }
@@ -743,16 +742,16 @@ static bool CheckGetPath()
   const char* registryPath = "[HKEY_LOCAL_MACHINE\\SOFTWARE\\MyApp; MyKey]";
 
   std::vector<std::string> originalPaths;
-  originalPaths.push_back(registryPath);
+  originalPaths.emplace_back(registryPath);
 
   std::vector<std::string> expectedPaths;
-  expectedPaths.push_back(registryPath);
+  expectedPaths.emplace_back(registryPath);
 #ifdef _WIN32
   expectedPaths.push_back("C:/Somewhere/something");
   expectedPaths.push_back("D:/Temp");
 #else
-  expectedPaths.push_back("/Somewhere/something");
-  expectedPaths.push_back("/tmp");
+  expectedPaths.emplace_back("/Somewhere/something");
+  expectedPaths.emplace_back("/tmp");
 #endif
 
   bool res = true;
@@ -817,7 +816,7 @@ static bool CheckFind()
   }
 
   std::vector<std::string> searchPaths;
-  searchPaths.push_back(TEST_SYSTEMTOOLS_BINARY_DIR);
+  searchPaths.emplace_back(TEST_SYSTEMTOOLS_BINARY_DIR);
   if (kwsys::SystemTools::FindFile(testFindFileName, searchPaths, true)
         .empty()) {
     std::cerr << "Problem with FindFile without system paths for: "
diff --git a/Source/kwsys/testSystemTools.h.in b/Source/kwsys/testSystemTools.h.in
index 022e36e..e4b89a7 100644
--- a/Source/kwsys/testSystemTools.h.in
+++ b/Source/kwsys/testSystemTools.h.in
@@ -3,7 +3,7 @@
 #ifndef @KWSYS_NAMESPACE@_testSystemtools_h
 #define @KWSYS_NAMESPACE@_testSystemtools_h
 
-#define EXECUTABLE_OUTPUT_PATH "@CMAKE_CURRENT_BINARY_DIR@"
+#define RUNTIME_OUTPUT_DIRECTORY "@CMAKE_CURRENT_BINARY_DIR@"
 
 #define TEST_SYSTEMTOOLS_SOURCE_DIR "@TEST_SYSTEMTOOLS_SOURCE_DIR@"
 #define TEST_SYSTEMTOOLS_BINARY_DIR "@TEST_SYSTEMTOOLS_BINARY_DIR@"