.clang-format

 ---
-# This configuration requires clang-format version 6.0 exactly.
+# This configuration requires clang-format version 18 exactly.
 BasedOnStyle: Mozilla
 AlignOperands: false
 AllowShortFunctionsOnASingleLine: InlineOnly
@@ -16,6 +16,7 @@ BraceWrapping:
 BreakBeforeBraces: Custom
 ColumnLimit: 79
 IndentPPDirectives: AfterHash
+QualifierAlignment: Right
 SortUsingDeclarations: false
 SpaceAfterTemplateKeyword: true
 Standard: Cpp03

.gitattributes

@@ -4,7 +4,7 @@
 .hooks*          export-ignore
 
 # Custom attribute to mark sources as using the kwsys C code style.
-[attr]kwsys-c-style  whitespace=tab-in-indent  format.clang-format
+[attr]kwsys-c-style  whitespace=tab-in-indent  format.clang-format=18
 
 /GitSetup        export-ignore
 /*.sh            export-ignore eol=lf

Base64.c

@@ -9,12 +9,12 @@
 #  include "Base64.h.in"
 #endif
 
-static const unsigned char kwsysBase64EncodeTable[65] =
+static unsigned char const kwsysBase64EncodeTable[65] =
   "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
   "abcdefghijklmnopqrstuvwxyz"
   "0123456789+/";
 
-static const unsigned char kwsysBase64DecodeTable[256] = {
+static unsigned char const kwsysBase64DecodeTable[256] = {
   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
   0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
@@ -49,7 +49,7 @@ static unsigned char kwsysBase64DecodeChar(unsigned char c)
 }
 
 /* Encode 3 bytes into a 4 byte string. */
-void kwsysBase64_Encode3(const unsigned char* src, unsigned char* dest)
+void kwsysBase64_Encode3(unsigned char const* src, unsigned char* dest)
 {
   dest[0] = kwsysBase64EncodeChar((src[0] >> 2) & 0x3F);
   dest[1] =
@@ -60,7 +60,7 @@ void kwsysBase64_Encode3(const unsigned char* src, unsigned char* dest)
 }
 
 /* Encode 2 bytes into a 4 byte string. */
-void kwsysBase64_Encode2(const unsigned char* src, unsigned char* dest)
+void kwsysBase64_Encode2(unsigned char const* src, unsigned char* dest)
 {
   dest[0] = kwsysBase64EncodeChar((src[0] >> 2) & 0x3F);
   dest[1] =
@@ -70,7 +70,7 @@ void kwsysBase64_Encode2(const unsigned char* src, unsigned char* dest)
 }
 
 /* Encode 1 bytes into a 4 byte string. */
-void kwsysBase64_Encode1(const unsigned char* src, unsigned char* dest)
+void kwsysBase64_Encode1(unsigned char const* src, unsigned char* dest)
 {
   dest[0] = kwsysBase64EncodeChar((src[0] >> 2) & 0x3F);
   dest[1] = kwsysBase64EncodeChar(((src[0] << 4) & 0x30));
@@ -88,11 +88,11 @@ void kwsysBase64_Encode1(const unsigned char* src, unsigned char* dest)
    actually knowing how much data to expect (if the input is not a multiple of
    3 bytes then the extra padding needed to complete the encode 4 bytes will
    stop the decoding anyway).  */
-size_t kwsysBase64_Encode(const unsigned char* input, size_t length,
+size_t kwsysBase64_Encode(unsigned char const* input, size_t length,
                           unsigned char* output, int mark_end)
 {
-  const unsigned char* ptr = input;
-  const unsigned char* end = input + length;
+  unsigned char const* ptr = input;
+  unsigned char const* end = input + length;
   unsigned char* optr = output;
 
   /* Encode complete triplet */
@@ -128,7 +128,7 @@ size_t kwsysBase64_Encode(const unsigned char* input, size_t length,
 }
 
 /* Decode 4 bytes into a 3 byte string. */
-int kwsysBase64_Decode3(const unsigned char* src, unsigned char* dest)
+int kwsysBase64_Decode3(unsigned char const* src, unsigned char* dest)
 {
   unsigned char d0;
   unsigned char d1;
@@ -172,16 +172,16 @@ int kwsysBase64_Decode3(const unsigned char* src, unsigned char* dest)
    'length' parameter is ignored. This enables the caller to decode a stream
    without actually knowing how much decoded data to expect (of course, the
    buffer must be large enough). */
-size_t kwsysBase64_Decode(const unsigned char* input, size_t length,
+size_t kwsysBase64_Decode(unsigned char const* input, size_t length,
                           unsigned char* output, size_t max_input_length)
 {
-  const unsigned char* ptr = input;
+  unsigned char const* ptr = input;
   unsigned char* optr = output;
 
   /* Decode complete triplet */
 
   if (max_input_length) {
-    const unsigned char* end = input + max_input_length;
+    unsigned char const* end = input + max_input_length;
     while (ptr < end) {
       int len = kwsysBase64_Decode3(ptr, optr);
       optr += len;

Base64.h.in

@@ -32,19 +32,19 @@ extern "C" {
 /**
  * Encode 3 bytes into a 4 byte string.
  */
-kwsysEXPORT void kwsysBase64_Encode3(const unsigned char* src,
+kwsysEXPORT void kwsysBase64_Encode3(unsigned char const* src,
                                      unsigned char* dest);
 
 /**
  * Encode 2 bytes into a 4 byte string.
  */
-kwsysEXPORT void kwsysBase64_Encode2(const unsigned char* src,
+kwsysEXPORT void kwsysBase64_Encode2(unsigned char const* src,
                                      unsigned char* dest);
 
 /**
  * Encode 1 bytes into a 4 byte string.
  */
-kwsysEXPORT void kwsysBase64_Encode1(const unsigned char* src,
+kwsysEXPORT void kwsysBase64_Encode1(unsigned char const* src,
                                      unsigned char* dest);
 
 /**
@@ -60,7 +60,7 @@ kwsysEXPORT void kwsysBase64_Encode1(const unsigned char* src,
  * the extra padding needed to complete the encode 4 bytes will stop
  * the decoding anyway).
  */
-kwsysEXPORT size_t kwsysBase64_Encode(const unsigned char* input,
+kwsysEXPORT size_t kwsysBase64_Encode(unsigned char const* input,
                                       size_t length, unsigned char* output,
                                       int mark_end);
 
@@ -68,7 +68,7 @@ kwsysEXPORT size_t kwsysBase64_Encode(const unsigned char* input,
  * Decode 4 bytes into a 3 byte string.  Returns the number of bytes
  * actually decoded.
  */
-kwsysEXPORT int kwsysBase64_Decode3(const unsigned char* src,
+kwsysEXPORT int kwsysBase64_Decode3(unsigned char const* src,
                                     unsigned char* dest);
 
 /**
@@ -83,7 +83,7 @@ kwsysEXPORT int kwsysBase64_Decode3(const unsigned char* src,
  * much decoded data to expect (of course, the buffer must be large
  * enough).
  */
-kwsysEXPORT size_t kwsysBase64_Decode(const unsigned char* input,
+kwsysEXPORT size_t kwsysBase64_Decode(unsigned char const* input,
                                       size_t length, unsigned char* output,
                                       size_t max_input_length);
 

CMakeLists.txt

@@ -88,17 +88,7 @@
 # any outside mailing list and no documentation of the change will be
 # written.
 
-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()
+cmake_minimum_required(VERSION 3.13...3.31 FATAL_ERROR)
 
 # Some configure checks depend upon the deployment target. Clear checks when
 # the deployment target changes.
@@ -183,6 +173,9 @@ if(KWSYS_USE_Process)
   set(KWSYS_USE_System 1)
   set(KWSYS_USE_Encoding 1)
 endif()
+if(KWSYS_USE_Status)
+  set(KWSYS_USE_Encoding 1)
+endif()
 if(KWSYS_USE_SystemInformation)
   set(KWSYS_USE_Process 1)
 endif()
@@ -192,6 +185,7 @@ endif()
 if(KWSYS_USE_Directory)
   set(KWSYS_USE_Encoding 1)
   set(KWSYS_USE_Status 1)
+  set(KWSYS_USE_SystemTools 1)
 endif()
 if(KWSYS_USE_DynamicLoader)
   set(KWSYS_USE_Encoding 1)
@@ -210,11 +204,7 @@ 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()
+  include(CTest)
 endif()
 
 # Choose default shared/static build if not specified.
@@ -311,14 +301,6 @@ endif()
 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}"
-  KWSYS_IN_SOURCE_BUILD)
-if(NOT KWSYS_IN_SOURCE_BUILD)
-  configure_file(${PROJECT_SOURCE_DIR}/kwsysPrivate.h
-    ${PROJECT_BINARY_DIR}/kwsysPrivate.h COPYONLY IMMEDIATE)
-endif()
-
 # Select plugin module file name convention.
 if(NOT KWSYS_DynamicLoader_PREFIX)
   set(KWSYS_DynamicLoader_PREFIX ${CMAKE_SHARED_MODULE_PREFIX})
@@ -335,7 +317,7 @@ endif()
 
 #-----------------------------------------------------------------------------
 # Adjust compiler flags for some platforms.
-if(NOT CMAKE_COMPILER_IS_GNUCXX)
+if(NOT CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
   if(CMAKE_SYSTEM MATCHES "OSF1-V.*")
     string(REGEX MATCH "-timplicit_local"
       KWSYS_CXX_FLAGS_HAVE_IMPLICIT_LOCAL "${CMAKE_CXX_FLAGS}")
@@ -431,14 +413,6 @@ if(KWSYS_USE_DynamicLoader)
 endif()
 
 if(KWSYS_USE_SystemTools)
-  if (NOT DEFINED KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP)
-    set(KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP 1)
-  endif ()
-  if (KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP)
-    set(KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP 1)
-  else ()
-    set(KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP 0)
-  endif ()
   KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_SETENV
     "Checking whether CXX compiler has setenv" DIRECT)
   KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_UNSETENV
@@ -487,7 +461,7 @@ if(KWSYS_USE_SystemInformation)
     COMPILE_DEFINITIONS SIZEOF_VOID_P=${CMAKE_SIZEOF_VOID_P})
   if(NOT CYGWIN)
     include(CheckIncludeFiles)
-    CHECK_INCLUDE_FILES("sys/types.h;ifaddrs.h" KWSYS_SYS_HAS_IFADDRS_H)
+    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
         COMPILE_DEFINITIONS KWSYS_SYS_HAS_IFADDRS_H=1)
@@ -496,7 +470,7 @@ if(KWSYS_USE_SystemInformation)
   if(WIN32)
     include(CheckSymbolExists)
     set(CMAKE_REQUIRED_LIBRARIES psapi)
-    CHECK_SYMBOL_EXISTS(GetProcessMemoryInfo "windows.h;psapi.h" KWSYS_SYS_HAS_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
@@ -508,14 +482,14 @@ if(KWSYS_USE_SystemInformation)
     endif()
   endif()
   if(CMAKE_SYSTEM MATCHES "HP-UX")
-    CHECK_INCLUDE_FILES("sys/mpctl.h" KWSYS_SYS_HAS_MPCTL_H)
+    check_include_files("sys/mpctl.h" KWSYS_SYS_HAS_MPCTL_H)
     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")
-    CHECK_INCLUDE_FILES("machine/cpu.h" KWSYS_SYS_HAS_MACHINE_CPU_H)
+    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
         COMPILE_DEFINITIONS KWSYS_SYS_HAS_MACHINE_CPU_H=1)
@@ -538,7 +512,7 @@ if(KWSYS_USE_SystemInformation)
     if (NOT EXECINFO_LIB)
       set(EXECINFO_LIB "")
     endif()
-    CHECK_INCLUDE_FILE_CXX("execinfo.h" KWSYS_CXX_HAS_EXECINFOH)
+    check_include_file_cxx("execinfo.h" KWSYS_CXX_HAS_EXECINFOH)
     if (KWSYS_CXX_HAS_EXECINFOH)
       # we have the backtrace header check if it
       # can be used with this compiler
@@ -552,7 +526,7 @@ if(KWSYS_USE_SystemInformation)
         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)
+        check_include_file_cxx("dlfcn.h" 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
@@ -569,7 +543,7 @@ if(KWSYS_USE_SystemInformation)
         endif()
         # c++ demangling support
         # check for cxxabi headers
-        CHECK_INCLUDE_FILE_CXX("cxxabi.h" KWSYS_CXX_HAS_CXXABIH)
+        check_include_file_cxx("cxxabi.h" KWSYS_CXX_HAS_CXXABIH)
         if (KWSYS_CXX_HAS_CXXABIH)
           # check if cxxabi can be used with this
           # system and compiler.
@@ -639,15 +613,15 @@ 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_H_FILES Configure)
+set(KWSYS_HXX_FILES Configure)
 
 # Add selected C++ classes.
 set(cppclasses
   Directory DynamicLoader Encoding Glob RegularExpression SystemTools
   CommandLineArguments FStream SystemInformation ConsoleBuf Status
   )
-foreach(cpp ${cppclasses})
+foreach(cpp IN LISTS cppclasses)
   if(KWSYS_USE_${cpp})
     # Use the corresponding class.
     set(KWSYS_CLASSES ${KWSYS_CLASSES} ${cpp})
@@ -660,7 +634,7 @@ foreach(cpp ${cppclasses})
 endforeach()
 
 # Add selected C components.
-foreach(c
+foreach(c IN ITEMS
     Process Base64 Encoding MD5 Terminal System String
     )
   if(KWSYS_USE_${c})
@@ -692,7 +666,7 @@ if(KWSYS_USE_Process)
 endif()
 
 # Add selected C sources.
-foreach(c Base64 Encoding MD5 Terminal System String)
+foreach(c IN ITEMS 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)
@@ -703,7 +677,7 @@ foreach(c Base64 Encoding MD5 Terminal System String)
 endforeach()
 
 # Configure headers of C++ classes and construct the list of sources.
-foreach(c ${KWSYS_CLASSES})
+foreach(c IN LISTS 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)
@@ -713,7 +687,7 @@ foreach(c ${KWSYS_CLASSES})
 
   # Configure the header for this class.
   configure_file(${PROJECT_SOURCE_DIR}/${c}.hxx.in ${KWSYS_HEADER_DIR}/${c}.hxx
-                 @ONLY IMMEDIATE)
+                 @ONLY)
   set(KWSYS_CXX_SRCS ${KWSYS_CXX_SRCS} ${KWSYS_HEADER_DIR}/${c}.hxx)
 
   # Create an install target for the header.
@@ -725,10 +699,10 @@ foreach(c ${KWSYS_CLASSES})
 endforeach()
 
 # Configure C headers.
-foreach(h ${KWSYS_H_FILES})
+foreach(h IN LISTS KWSYS_H_FILES)
   # Configure the header into the given directory.
   configure_file(${PROJECT_SOURCE_DIR}/${h}.h.in ${KWSYS_HEADER_DIR}/${h}.h
-                 @ONLY IMMEDIATE)
+                 @ONLY)
   set(KWSYS_C_SRCS ${KWSYS_C_SRCS} ${KWSYS_HEADER_DIR}/${h}.h)
 
   # Create an install target for the header.
@@ -740,10 +714,10 @@ foreach(h ${KWSYS_H_FILES})
 endforeach()
 
 # Configure other C++ headers.
-foreach(h ${KWSYS_HXX_FILES})
+foreach(h IN LISTS KWSYS_HXX_FILES)
   # Configure the header into the given directory.
   configure_file(${PROJECT_SOURCE_DIR}/${h}.hxx.in ${KWSYS_HEADER_DIR}/${h}.hxx
-                 @ONLY IMMEDIATE)
+                 @ONLY)
   set(KWSYS_CXX_SRCS ${KWSYS_CXX_SRCS} ${KWSYS_HEADER_DIR}/${h}.hxx)
 
   # Create an install target for the header.
@@ -969,9 +943,11 @@ if(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
     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})
+    foreach(testfile IN LISTS KWSYS_C_TESTS)
       get_filename_component(test "${testfile}" NAME_WE)
-      add_test(kwsys.${test} ${EXEC_DIR}/${KWSYS_NAMESPACE}TestsC ${test} ${KWSYS_TEST_ARGS_${test}})
+      add_test(NAME kwsys.${test}
+        COMMAND ${EXEC_DIR}/${KWSYS_NAMESPACE}TestsC ${test} ${KWSYS_TEST_ARGS_${test}}
+        )
       set_property(TEST kwsys.${test} PROPERTY LABELS ${KWSYS_LABELS_TEST})
     endforeach()
 
@@ -1047,6 +1023,10 @@ if(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
     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})
+    get_property(_isMultiConfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+    if(_isMultiConfig)
+      set_property(TARGET ${KWSYS_NAMESPACE}TestsCxx APPEND PROPERTY COMPILE_DEFINITIONS BUILD_CONFIG="$<CONFIG>")
+    endif()
 
     set(TEST_SYSTEMTOOLS_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
     set(TEST_SYSTEMTOOLS_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}")
@@ -1058,7 +1038,7 @@ if(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
     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")
+      set_property(DIRECTORY APPEND PROPERTY TEST_INCLUDE_FILES "${CMAKE_CURRENT_BINARY_DIR}/ExtraTest.cmake")
     endif()
 
     set(KWSYS_TEST_ARGS_testCommandLineArguments
@@ -1089,9 +1069,11 @@ if(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
       -p
       some junk at the end
       )
-    foreach(testfile ${KWSYS_CXX_TESTS})
+    foreach(testfile IN LISTS KWSYS_CXX_TESTS)
       get_filename_component(test "${testfile}" NAME_WE)
-      add_test(kwsys.${test} ${EXEC_DIR}/${KWSYS_NAMESPACE}TestsCxx ${test} ${KWSYS_TEST_ARGS_${test}})
+      add_test(NAME kwsys.${test}
+        COMMAND ${EXEC_DIR}/${KWSYS_NAMESPACE}TestsCxx ${test} ${KWSYS_TEST_ARGS_${test}}
+        )
       set_property(TEST kwsys.${test} PROPERTY LABELS ${KWSYS_LABELS_TEST})
     endforeach()
 
@@ -1100,17 +1082,19 @@ if(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
     set_property(TARGET ${KWSYS_NAMESPACE}TestProcess PROPERTY LABELS ${KWSYS_LABELS_EXE})
     target_link_libraries(${KWSYS_NAMESPACE}TestProcess ${KWSYS_TARGET_C_LINK})
     #set(KWSYS_TEST_PROCESS_7 7) # uncomment to run timing-sensitive test locally
-    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})
+    foreach(n IN ITEMS 1 2 3 4 5 6 ${KWSYS_TEST_PROCESS_7} 9 10)
+      add_test(NAME kwsys.testProcess-${n}
+        COMMAND ${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)
+      set_property(TEST kwsys.testProcess-${n} PROPERTY 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")
+    elseif(CMAKE_C_COMPILER_ID MATCHES "^(XL|XLClang)$")
       # Tell IBM XL not to warn about our test infinite loop
       if(CMAKE_SYSTEM MATCHES "Linux.*ppc64le"
          AND CMAKE_C_COMPILER_VERSION VERSION_LESS "16.1.0"
@@ -1127,22 +1111,12 @@ if(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
     endif()
     set_property(SOURCE testProcess.c PROPERTY COMPILE_FLAGS "${testProcess_COMPILE_FLAGS}")
 
-    # Test SharedForward
-    configure_file(${PROJECT_SOURCE_DIR}/testSharedForward.c.in
-                   ${PROJECT_BINARY_DIR}/testSharedForward.c @ONLY IMMEDIATE)
-    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})
-
     # Configure some test properties.
     if(KWSYS_STANDALONE)
       # We expect test to fail
-      set_tests_properties(kwsys.testFail PROPERTIES WILL_FAIL ON)
+      set_property(TEST kwsys.testFail PROPERTY WILL_FAIL ON)
       get_test_property(kwsys.testFail WILL_FAIL wfv)
-      set_tests_properties(kwsys.testFail PROPERTIES MEASUREMENT "Some Key=Some Value")
+      set_property(TEST kwsys.testFail PROPERTY MEASUREMENT "Some Key=Some Value")
       message(STATUS "GET_TEST_PROPERTY returned: ${wfv}")
     endif()
 
@@ -1152,7 +1126,7 @@ if(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
 
     # Suppress known consistent failures on buggy systems.
     if(KWSYS_TEST_BOGUS_FAILURES)
-      set_tests_properties(${KWSYS_TEST_BOGUS_FAILURES} PROPERTIES WILL_FAIL ON)
+      set_property(TEST ${KWSYS_TEST_BOGUS_FAILURES} PROPERTY WILL_FAIL ON)
     endif()
 
   endif()

CONTRIBUTING.rst

@@ -27,14 +27,14 @@ copies of KWSys within dependent projects can be updated to get the changes.
 Code Style
 ==========
 
-We use `clang-format`_ version **6.0** to define our style for C++ code in
+We use `clang-format`_ version **18** to define our style for C++ code in
 the KWSys source tree.  See the `.clang-format`_ configuration file for
 our style settings.  Use the `clang-format.bash`_ script to format source
 code.  It automatically runs ``clang-format`` on the set of source files
 for which we enforce style.  The script also has options to format only
 a subset of files, such as those that are locally modified.
 
-.. _`clang-format`: http://clang.llvm.org/docs/ClangFormat.html
+.. _`clang-format`: https://clang.llvm.org/docs/ClangFormat.html
 .. _`.clang-format`: .clang-format
 .. _`clang-format.bash`: clang-format.bash
 

CTestConfig.cmake

@@ -3,9 +3,7 @@
 
 set(CTEST_PROJECT_NAME "KWSys")
 set(CTEST_NIGHTLY_START_TIME "21:00:00 EDT")
-if (NOT CTEST_DROP_METHOD STREQUAL "https")
-  set(CTEST_DROP_METHOD "http")
-endif ()
+set(CTEST_DROP_METHOD "https")
 set(CTEST_DROP_SITE "open.cdash.org")
 set(CTEST_DROP_LOCATION "/submit.php?project=KWSys")
 set(CTEST_DROP_SITE_CDASH TRUE)

CommandLineArguments.cxx

@@ -4,20 +4,19 @@
 #include KWSYS_HEADER(CommandLineArguments.hxx)
 
 #include KWSYS_HEADER(Configure.hxx)
-#include KWSYS_HEADER(String.hxx)
 
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
 #  include "CommandLineArguments.hxx.in"
 #  include "Configure.hxx.in"
-#  include "String.hxx.in"
 #endif
 
 #include <iostream>
 #include <map>
 #include <set>
 #include <sstream>
+#include <string>
 #include <vector>
 
 #include <cstdio>
@@ -43,23 +42,23 @@ namespace KWSYS_NAMESPACE {
 
 struct CommandLineArgumentsCallbackStructure
 {
-  const char* Argument;
+  char const* Argument;
   int ArgumentType;
   CommandLineArguments::CallbackType Callback;
   void* CallData;
   void* Variable;
   int VariableType;
-  const char* Help;
+  char const* Help;
 };
 
-class CommandLineArgumentsVectorOfStrings : public std::vector<kwsys::String>
+class CommandLineArgumentsVectorOfStrings : public std::vector<std::string>
 {
 };
-class CommandLineArgumentsSetOfStrings : public std::set<kwsys::String>
+class CommandLineArgumentsSetOfStrings : public std::set<std::string>
 {
 };
 class CommandLineArgumentsMapOfStrucs
-  : public std::map<kwsys::String, CommandLineArgumentsCallbackStructure>
+  : public std::map<std::string, CommandLineArgumentsCallbackStructure>
 {
 };
 
@@ -70,7 +69,7 @@ public:
 
   using VectorOfStrings = CommandLineArgumentsVectorOfStrings;
   using CallbacksMap = CommandLineArgumentsMapOfStrucs;
-  using String = kwsys::String;
+  using String = std::string;
   using SetOfStrings = CommandLineArgumentsSetOfStrings;
 
   VectorOfStrings Argv;
@@ -98,7 +97,7 @@ CommandLineArguments::~CommandLineArguments()
   delete this->Internals;
 }
 
-void CommandLineArguments::Initialize(int argc, const char* const argv[])
+void CommandLineArguments::Initialize(int argc, char const* const argv[])
 {
   int cc;
 
@@ -111,7 +110,7 @@ void CommandLineArguments::Initialize(int argc, const char* const argv[])
 
 void CommandLineArguments::Initialize(int argc, char* argv[])
 {
-  this->Initialize(argc, static_cast<const char* const*>(argv));
+  this->Initialize(argc, static_cast<char const* const*>(argv));
 }
 
 void CommandLineArguments::Initialize()
@@ -120,21 +119,21 @@ void CommandLineArguments::Initialize()
   this->Internals->LastArgument = 0;
 }
 
-void CommandLineArguments::ProcessArgument(const char* arg)
+void CommandLineArguments::ProcessArgument(char const* arg)
 {
   this->Internals->Argv.push_back(arg);
 }
 
 bool CommandLineArguments::GetMatchedArguments(
-  std::vector<std::string>* matches, const std::string& arg)
+  std::vector<std::string>* matches, std::string const& arg)
 {
   matches->clear();
   CommandLineArguments::Internal::CallbacksMap::iterator it;
 
   // Does the argument match to any we know about?
   for (it = this->Internals->Callbacks.begin();
-       it != this->Internals->Callbacks.end(); it++) {
-    const CommandLineArguments::Internal::String& parg = it->first;
+       it != this->Internals->Callbacks.end(); ++it) {
+    CommandLineArguments::Internal::String const& parg = it->first;
     CommandLineArgumentsCallbackStructure* cs = &it->second;
     if (cs->ArgumentType == CommandLineArguments::NO_ARGUMENT ||
         cs->ArgumentType == CommandLineArguments::SPACE_ARGUMENT) {
@@ -156,7 +155,7 @@ int CommandLineArguments::Parse()
     this->Internals->UnusedArguments.clear();
   }
   for (cc = 0; cc < this->Internals->Argv.size(); cc++) {
-    const std::string& arg = this->Internals->Argv[cc];
+    std::string const& arg = this->Internals->Argv[cc];
     CommandLineArguments_DEBUG("Process argument: " << arg);
     this->Internals->LastArgument = cc;
     if (this->GetMatchedArguments(&matches, arg)) {
@@ -175,7 +174,7 @@ int CommandLineArguments::Parse()
       // additional value
       CommandLineArgumentsCallbackStructure* cs =
         &this->Internals->Callbacks[matches[maxidx]];
-      const std::string& sarg = matches[maxidx];
+      std::string const& sarg = matches[maxidx];
       if (cs->Argument != sarg) {
         abort();
       }
@@ -221,7 +220,7 @@ int CommandLineArguments::Parse()
           // Suck in all the rest of the arguments
           CommandLineArguments_DEBUG("This is a multi argument: " << arg);
           for (cc++; cc < this->Internals->Argv.size(); ++cc) {
-            const std::string& marg = this->Internals->Argv[cc];
+            std::string const& marg = this->Internals->Argv[cc];
             CommandLineArguments_DEBUG(
               " check multi argument value: " << marg);
             if (this->GetMatchedArguments(&matches, marg)) {
@@ -306,7 +305,7 @@ void CommandLineArguments::GetUnusedArguments(int* argc, char*** argv)
 
   // Copy everything after the LastArgument, since that was not parsed.
   for (cc = 0; cc < this->Internals->UnusedArguments.size(); cc++) {
-    kwsys::String& str = this->Internals->UnusedArguments[cc];
+    std::string& str = this->Internals->UnusedArguments[cc];
     args[cnt] = new char[str.size() + 1];
     strcpy(args[cnt], str.c_str());
     cnt++;
@@ -319,15 +318,15 @@ void CommandLineArguments::DeleteRemainingArguments(int argc, char*** argv)
 {
   int cc;
   for (cc = 0; cc < argc; ++cc) {
-    delete[](*argv)[cc];
+    delete[] (*argv)[cc];
   }
-  delete[] * argv;
+  delete[] *argv;
 }
 
-void CommandLineArguments::AddCallback(const char* argument,
+void CommandLineArguments::AddCallback(char const* argument,
                                        ArgumentTypeEnum type,
                                        CallbackType callback, void* call_data,
-                                       const char* help)
+                                       char const* help)
 {
   CommandLineArgumentsCallbackStructure s;
   s.Argument = argument;
@@ -342,10 +341,10 @@ void CommandLineArguments::AddCallback(const char* argument,
   this->GenerateHelp();
 }
 
-void CommandLineArguments::AddArgument(const char* argument,
+void CommandLineArguments::AddArgument(char const* argument,
                                        ArgumentTypeEnum type,
                                        VariableTypeEnum vtype, void* variable,
-                                       const char* help)
+                                       char const* help)
 {
   CommandLineArgumentsCallbackStructure s;
   s.Argument = argument;
@@ -417,7 +416,7 @@ void CommandLineArguments::SetUnknownArgumentCallback(
   this->Internals->UnknownArgumentCallback = callback;
 }
 
-const char* CommandLineArguments::GetHelp(const char* arg)
+char const* CommandLineArguments::GetHelp(char const* arg)
 {
   auto it = this->Internals->Callbacks.find(arg);
   if (it == this->Internals->Callbacks.end()) {
@@ -446,7 +445,7 @@ void CommandLineArguments::SetLineLength(unsigned int ll)
   this->GenerateHelp();
 }
 
-const char* CommandLineArguments::GetArgv0()
+char const* CommandLineArguments::GetArgv0()
 {
   return this->Internals->Argv0.c_str();
 }
@@ -468,7 +467,7 @@ void CommandLineArguments::GenerateHelp()
   MapArgs mp;
   MapArgs::iterator mpit, smpit;
   for (it = this->Internals->Callbacks.begin();
-       it != this->Internals->Callbacks.end(); it++) {
+       it != this->Internals->Callbacks.end(); ++it) {
     CommandLineArgumentsCallbackStructure* cs = &(it->second);
     mpit = mp.find(cs->Help);
     if (mpit != mp.end()) {
@@ -479,14 +478,14 @@ void CommandLineArguments::GenerateHelp()
     }
   }
   for (it = this->Internals->Callbacks.begin();
-       it != this->Internals->Callbacks.end(); it++) {
+       it != this->Internals->Callbacks.end(); ++it) {
     CommandLineArgumentsCallbackStructure* cs = &(it->second);
     mpit = mp.find(cs->Help);
     if (mpit != mp.end()) {
       mpit->second.insert(it->first);
       smpit = mp.find(it->first);
       CommandLineArguments::Internal::SetOfStrings::iterator sit;
-      for (sit = smpit->second.begin(); sit != smpit->second.end(); sit++) {
+      for (sit = smpit->second.begin(); sit != smpit->second.end(); ++sit) {
         mpit->second.insert(*sit);
       }
       mp.erase(smpit);
@@ -497,9 +496,9 @@ void CommandLineArguments::GenerateHelp()
 
   // Find the length of the longest string
   CommandLineArguments::Internal::String::size_type maxlen = 0;
-  for (mpit = mp.begin(); mpit != mp.end(); mpit++) {
+  for (mpit = mp.begin(); mpit != mp.end(); ++mpit) {
     CommandLineArguments::Internal::SetOfStrings::iterator sit;
-    for (sit = mpit->second.begin(); sit != mpit->second.end(); sit++) {
+    for (sit = mpit->second.begin(); sit != mpit->second.end(); ++sit) {
       CommandLineArguments::Internal::String::size_type clen = sit->size();
       switch (this->Internals->Callbacks[*sit].ArgumentType) {
         case CommandLineArguments::NO_ARGUMENT:
@@ -525,9 +524,9 @@ void CommandLineArguments::GenerateHelp()
   maxlen += 4; // For the space before and after the option
 
   // Print help for each option
-  for (mpit = mp.begin(); mpit != mp.end(); mpit++) {
+  for (mpit = mp.begin(); mpit != mp.end(); ++mpit) {
     CommandLineArguments::Internal::SetOfStrings::iterator sit;
-    for (sit = mpit->second.begin(); sit != mpit->second.end(); sit++) {
+    for (sit = mpit->second.begin(); sit != mpit->second.end(); ++sit) {
       str << std::endl;
       std::string argument = *sit;
       switch (this->Internals->Callbacks[*sit].ArgumentType) {
@@ -548,7 +547,7 @@ void CommandLineArguments::GenerateHelp()
       }
       str << "  " << argument.substr(0, maxstrlen) << "  ";
     }
-    const char* ptr = this->Internals->Callbacks[mpit->first].Help;
+    char const* ptr = this->Internals->Callbacks[mpit->first].Help;
     size_t len = strlen(ptr);
     int cnt = 0;
     while (len > 0) {
@@ -599,7 +598,7 @@ void CommandLineArguments::GenerateHelp()
 }
 
 void CommandLineArguments::PopulateVariable(bool* variable,
-                                            const std::string& value)
+                                            std::string const& value)
 {
   if (value == "1" || value == "ON" || value == "on" || value == "On" ||
       value == "TRUE" || value == "true" || value == "True" ||
@@ -611,7 +610,7 @@ void CommandLineArguments::PopulateVariable(bool* variable,
 }
 
 void CommandLineArguments::PopulateVariable(int* variable,
-                                            const std::string& value)
+                                            std::string const& value)
 {
   char* res = nullptr;
   *variable = static_cast<int>(strtol(value.c_str(), &res, 10));
@@ -622,7 +621,7 @@ void CommandLineArguments::PopulateVariable(int* variable,
 }
 
 void CommandLineArguments::PopulateVariable(double* variable,
-                                            const std::string& value)
+                                            std::string const& value)
 {
   char* res = nullptr;
   *variable = strtod(value.c_str(), &res);
@@ -633,21 +632,21 @@ void CommandLineArguments::PopulateVariable(double* variable,
 }
 
 void CommandLineArguments::PopulateVariable(char** variable,
-                                            const std::string& value)
+                                            std::string const& value)
 {
-  delete[] * variable;
+  delete[] *variable;
   *variable = new char[value.size() + 1];
   strcpy(*variable, value.c_str());
 }
 
 void CommandLineArguments::PopulateVariable(std::string* variable,
-                                            const std::string& value)
+                                            std::string const& value)
 {
   *variable = value;
 }
 
 void CommandLineArguments::PopulateVariable(std::vector<bool>* variable,
-                                            const std::string& value)
+                                            std::string const& value)
 {
   bool val = false;
   if (value == "1" || value == "ON" || value == "on" || value == "On" ||
@@ -659,7 +658,7 @@ void CommandLineArguments::PopulateVariable(std::vector<bool>* variable,
 }
 
 void CommandLineArguments::PopulateVariable(std::vector<int>* variable,
-                                            const std::string& value)
+                                            std::string const& value)
 {
   char* res = nullptr;
   variable->push_back(static_cast<int>(strtol(value.c_str(), &res, 10)));
@@ -670,7 +669,7 @@ void CommandLineArguments::PopulateVariable(std::vector<int>* variable,
 }
 
 void CommandLineArguments::PopulateVariable(std::vector<double>* variable,
-                                            const std::string& value)
+                                            std::string const& value)
 {
   char* res = nullptr;
   variable->push_back(strtod(value.c_str(), &res));
@@ -681,7 +680,7 @@ void CommandLineArguments::PopulateVariable(std::vector<double>* variable,
 }
 
 void CommandLineArguments::PopulateVariable(std::vector<char*>* variable,
-                                            const std::string& value)
+                                            std::string const& value)
 {
   char* var = new char[value.size() + 1];
   strcpy(var, value.c_str());
@@ -689,13 +688,13 @@ void CommandLineArguments::PopulateVariable(std::vector<char*>* variable,
 }
 
 void CommandLineArguments::PopulateVariable(std::vector<std::string>* variable,
-                                            const std::string& value)
+                                            std::string const& value)
 {
   variable->push_back(value);
 }
 
 bool CommandLineArguments::PopulateVariable(
-  CommandLineArgumentsCallbackStructure* cs, const char* value)
+  CommandLineArgumentsCallbackStructure* cs, char const* value)
 {
   // Call the callback
   if (cs->Callback) {

CommandLineArguments.hxx.in

@@ -62,8 +62,8 @@ public:
   CommandLineArguments();
   ~CommandLineArguments();
 
-  CommandLineArguments(const CommandLineArguments&) = delete;
-  CommandLineArguments& operator=(const CommandLineArguments&) = delete;
+  CommandLineArguments(CommandLineArguments const&) = delete;
+  CommandLineArguments& operator=(CommandLineArguments const&) = delete;
 
   /**
    * Various argument types.
@@ -100,14 +100,14 @@ public:
   /**
    * Prototypes for callbacks for callback interface.
    */
-  typedef int (*CallbackType)(const char* argument, const char* value,
+  typedef int (*CallbackType)(char const* argument, char const* value,
                               void* call_data);
-  typedef int (*ErrorCallbackType)(const char* argument, void* client_data);
+  typedef int (*ErrorCallbackType)(char const* argument, void* client_data);
 
   /**
    * Initialize internal data structures. This should be called before parsing.
    */
-  void Initialize(int argc, const char* const argv[]);
+  void Initialize(int argc, char const* const argv[]);
   void Initialize(int argc, char* argv[]);
 
   /**
@@ -116,7 +116,7 @@ public:
    * are not available.
    */
   void Initialize();
-  void ProcessArgument(const char* arg);
+  void ProcessArgument(char const* arg);
 
   /**
    * This method will parse arguments and call appropriate methods.
@@ -129,56 +129,56 @@ public:
    * argument help specifies the help string used with this option. The
    * callback and call_data can be skipped.
    */
-  void AddCallback(const char* argument, ArgumentTypeEnum type,
-                   CallbackType callback, void* call_data, const char* help);
+  void AddCallback(char const* argument, ArgumentTypeEnum type,
+                   CallbackType callback, void* call_data, char const* help);
 
   /**
    * Add handler for argument which is going to set the variable to the
    * specified value. If the argument is specified, the option is casted to the
    * appropriate type.
    */
-  void AddArgument(const char* argument, ArgumentTypeEnum type, bool* variable,
-                   const char* help);
-  void AddArgument(const char* argument, ArgumentTypeEnum type, int* variable,
-                   const char* help);
-  void AddArgument(const char* argument, ArgumentTypeEnum type,
-                   double* variable, const char* help);
-  void AddArgument(const char* argument, ArgumentTypeEnum type,
-                   char** variable, const char* help);
-  void AddArgument(const char* argument, ArgumentTypeEnum type,
-                   std::string* variable, const char* help);
+  void AddArgument(char const* argument, ArgumentTypeEnum type, bool* variable,
+                   char const* help);
+  void AddArgument(char const* argument, ArgumentTypeEnum type, int* variable,
+                   char const* help);
+  void AddArgument(char const* argument, ArgumentTypeEnum type,
+                   double* variable, char const* help);
+  void AddArgument(char const* argument, ArgumentTypeEnum type,
+                   char** variable, char const* help);
+  void AddArgument(char const* argument, ArgumentTypeEnum type,
+                   std::string* variable, char const* help);
 
   /**
    * Add handler for argument which is going to set the variable to the
    * specified value. If the argument is specified, the option is casted to the
    * appropriate type. This will handle the multi argument values.
    */
-  void AddArgument(const char* argument, ArgumentTypeEnum type,
-                   std::vector<bool>* variable, const char* help);
-  void AddArgument(const char* argument, ArgumentTypeEnum type,
-                   std::vector<int>* variable, const char* help);
-  void AddArgument(const char* argument, ArgumentTypeEnum type,
-                   std::vector<double>* variable, const char* help);
-  void AddArgument(const char* argument, ArgumentTypeEnum type,
-                   std::vector<char*>* variable, const char* help);
-  void AddArgument(const char* argument, ArgumentTypeEnum type,
-                   std::vector<std::string>* variable, const char* help);
+  void AddArgument(char const* argument, ArgumentTypeEnum type,
+                   std::vector<bool>* variable, char const* help);
+  void AddArgument(char const* argument, ArgumentTypeEnum type,
+                   std::vector<int>* variable, char const* help);
+  void AddArgument(char const* argument, ArgumentTypeEnum type,
+                   std::vector<double>* variable, char const* help);
+  void AddArgument(char const* argument, ArgumentTypeEnum type,
+                   std::vector<char*>* variable, char const* help);
+  void AddArgument(char const* argument, ArgumentTypeEnum type,
+                   std::vector<std::string>* variable, char const* help);
 
   /**
    * Add handler for boolean argument. The argument does not take any option
    * and if it is specified, the value of the variable is true/1, otherwise it
    * is false/0.
    */
-  void AddBooleanArgument(const char* argument, bool* variable,
-                          const char* help);
-  void AddBooleanArgument(const char* argument, int* variable,
-                          const char* help);
-  void AddBooleanArgument(const char* argument, double* variable,
-                          const char* help);
-  void AddBooleanArgument(const char* argument, char** variable,
-                          const char* help);
-  void AddBooleanArgument(const char* argument, std::string* variable,
-                          const char* help);
+  void AddBooleanArgument(char const* argument, bool* variable,
+                          char const* help);
+  void AddBooleanArgument(char const* argument, int* variable,
+                          char const* help);
+  void AddBooleanArgument(char const* argument, double* variable,
+                          char const* help);
+  void AddBooleanArgument(char const* argument, char** variable,
+                          char const* help);
+  void AddBooleanArgument(char const* argument, std::string* variable,
+                          char const* help);
 
   /**
    * Set the callbacks for error handling.
@@ -205,8 +205,8 @@ public:
    * Return string containing help. If the argument is specified, only return
    * help for that argument.
    */
-  const char* GetHelp() { return this->Help.c_str(); }
-  const char* GetHelp(const char* arg);
+  char const* GetHelp() { return this->Help.c_str(); }
+  char const* GetHelp(char const* arg);
 
   /**
    * Get / Set the help line length. This length is used when generating the
@@ -219,7 +219,7 @@ public:
    * Get the executable name (argv0). This is only available when using
    * Initialize with argc/argv.
    */
-  const char* GetArgv0();
+  char const* GetArgv0();
 
   /**
    * Get index of the last argument parsed. This is the last argument that was
@@ -231,30 +231,30 @@ protected:
   void GenerateHelp();
 
   //! This is internal method that registers variable with argument
-  void AddArgument(const char* argument, ArgumentTypeEnum type,
-                   VariableTypeEnum vtype, void* variable, const char* help);
+  void AddArgument(char const* argument, ArgumentTypeEnum type,
+                   VariableTypeEnum vtype, void* variable, char const* help);
 
   bool GetMatchedArguments(std::vector<std::string>* matches,
-                           const std::string& arg);
+                           std::string const& arg);
 
   //! Populate individual variables
   bool PopulateVariable(CommandLineArgumentsCallbackStructure* cs,
-                        const char* value);
+                        char const* value);
 
   //! Populate individual variables of type ...
-  void PopulateVariable(bool* variable, const std::string& value);
-  void PopulateVariable(int* variable, const std::string& value);
-  void PopulateVariable(double* variable, const std::string& value);
-  void PopulateVariable(char** variable, const std::string& value);
-  void PopulateVariable(std::string* variable, const std::string& value);
-  void PopulateVariable(std::vector<bool>* variable, const std::string& value);
-  void PopulateVariable(std::vector<int>* variable, const std::string& value);
+  void PopulateVariable(bool* variable, std::string const& value);
+  void PopulateVariable(int* variable, std::string const& value);
+  void PopulateVariable(double* variable, std::string const& value);
+  void PopulateVariable(char** variable, std::string const& value);
+  void PopulateVariable(std::string* variable, std::string const& value);
+  void PopulateVariable(std::vector<bool>* variable, std::string const& value);
+  void PopulateVariable(std::vector<int>* variable, std::string const& value);
   void PopulateVariable(std::vector<double>* variable,
-                        const std::string& value);
+                        std::string const& value);
   void PopulateVariable(std::vector<char*>* variable,
-                        const std::string& value);
+                        std::string const& value);
   void PopulateVariable(std::vector<std::string>* variable,
-                        const std::string& value);
+                        std::string const& value);
 
   typedef CommandLineArgumentsInternal Internal;
   Internal* Internals;

Configure.hxx.in

@@ -11,16 +11,13 @@
 /* Whether <ext/stdio_filebuf.h> is available. */
 #define @KWSYS_NAMESPACE@_CXX_HAS_EXT_STDIO_FILEBUF_H                         \
   @KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H@
-/* Whether the translation map is available or not. */
-#define @KWSYS_NAMESPACE@_SYSTEMTOOLS_USE_TRANSLATION_MAP                     \
-  @KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP@
 
 #if defined(__SUNPRO_CC) && __SUNPRO_CC > 0x5130 && defined(__has_attribute)
-#  define @KWSYS_NAMESPACE@__has_cpp_attribute(x) __has_attribute(x)
+#  define @KWSYS_NAMESPACE@_has_cpp_attribute(x) __has_attribute(x)
 #elif defined(__has_cpp_attribute)
-#  define @KWSYS_NAMESPACE@__has_cpp_attribute(x) __has_cpp_attribute(x)
+#  define @KWSYS_NAMESPACE@_has_cpp_attribute(x) __has_cpp_attribute(x)
 #else
-#  define @KWSYS_NAMESPACE@__has_cpp_attribute(x) 0
+#  define @KWSYS_NAMESPACE@_has_cpp_attribute(x) 0
 #endif
 
 #if __cplusplus >= 201103L
@@ -31,13 +28,13 @@
 
 #ifndef @KWSYS_NAMESPACE@_FALLTHROUGH
 #  if __cplusplus >= 201703L &&                                               \
-    @KWSYS_NAMESPACE@__has_cpp_attribute(fallthrough)
+    @KWSYS_NAMESPACE@_has_cpp_attribute(fallthrough)
 #    define @KWSYS_NAMESPACE@_FALLTHROUGH [[fallthrough]]
 #  elif __cplusplus >= 201103L &&                                             \
-    @KWSYS_NAMESPACE@__has_cpp_attribute(gnu::fallthrough)
+    @KWSYS_NAMESPACE@_has_cpp_attribute(gnu::fallthrough)
 #    define @KWSYS_NAMESPACE@_FALLTHROUGH [[gnu::fallthrough]]
 #  elif __cplusplus >= 201103L &&                                             \
-    @KWSYS_NAMESPACE@__has_cpp_attribute(clang::fallthrough)
+    @KWSYS_NAMESPACE@_has_cpp_attribute(clang::fallthrough)
 #    define @KWSYS_NAMESPACE@_FALLTHROUGH [[clang::fallthrough]]
 #  endif
 #endif
@@ -45,7 +42,7 @@
 #  define @KWSYS_NAMESPACE@_FALLTHROUGH static_cast<void>(0)
 #endif
 
-#undef @KWSYS_NAMESPACE@__has_cpp_attribute
+#undef @KWSYS_NAMESPACE@_has_cpp_attribute
 
 /* If building a C++ file in kwsys itself, give the source file
    access to the macros without a configured namespace.  */
@@ -58,8 +55,6 @@
 #  define KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H                                   \
     @KWSYS_NAMESPACE@_CXX_HAS_EXT_STDIO_FILEBUF_H
 #  define KWSYS_FALLTHROUGH @KWSYS_NAMESPACE@_FALLTHROUGH
-#  define KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP                               \
-    @KWSYS_NAMESPACE@_SYSTEMTOOLS_USE_TRANSLATION_MAP
 #endif
 
 #endif

ConsoleBuf.hxx.in

@@ -34,14 +34,14 @@ public:
   class Manager
   {
   public:
-    Manager(std::basic_ios<CharT, Traits>& ios, const bool err = false)
+    Manager(std::basic_ios<CharT, Traits>& ios, bool const err = false)
       : m_consolebuf(0)
     {
       m_ios = &ios;
       try {
         m_consolebuf = new BasicConsoleBuf<CharT, Traits>(err);
         m_streambuf = m_ios->rdbuf(m_consolebuf);
-      } catch (const std::runtime_error& ex) {
+      } catch (std::runtime_error const& ex) {
         std::cerr << "Failed to create ConsoleBuf!" << std::endl
                   << ex.what() << std::endl;
       };
@@ -72,7 +72,7 @@ public:
     BasicConsoleBuf<CharT, Traits>* m_consolebuf;
   };
 
-  BasicConsoleBuf(const bool err = false)
+  BasicConsoleBuf(bool const err = false)
     : flush_on_newline(true)
     , input_pipe_codepage(0)
     , output_pipe_codepage(0)
@@ -111,7 +111,7 @@ protected:
       success = false;
     }
     if (m_hOutput && !m_obuffer.empty()) {
-      const std::wstring wbuffer = getBuffer(m_obuffer);
+      std::wstring const wbuffer = getBuffer(m_obuffer);
       if (m_isConsoleOutput) {
         DWORD charsWritten;
         success =
@@ -320,17 +320,17 @@ private:
     this->setp((char_type*)m_obuffer.data(),
                (char_type*)m_obuffer.data() + m_obuffer.size());
   }
-  bool encodeOutputBuffer(const std::wstring wbuffer, std::string& buffer)
+  bool encodeOutputBuffer(std::wstring const wbuffer, std::string& buffer)
   {
     if (wbuffer.size() == 0) {
       buffer = std::string();
       return true;
     }
-    const int length =
+    int const length =
       WideCharToMultiByte(m_activeOutputCodepage, 0, wbuffer.c_str(),
                           (int)wbuffer.size(), nullptr, 0, nullptr, nullptr);
     char* buf = new char[length];
-    const bool success =
+    bool const success =
       WideCharToMultiByte(m_activeOutputCodepage, 0, wbuffer.c_str(),
                           (int)wbuffer.size(), buf, length, nullptr,
                           nullptr) > 0
@@ -340,7 +340,7 @@ private:
     delete[] buf;
     return success;
   }
-  bool decodeInputBuffer(const std::string buffer, std::wstring& wbuffer)
+  bool decodeInputBuffer(std::string const buffer, std::wstring& wbuffer)
   {
     size_t length = buffer.length();
     if (length == 0) {
@@ -348,19 +348,19 @@ private:
       return true;
     }
     int actualCodepage = m_activeInputCodepage;
-    const char BOM_UTF8[] = { char(0xEF), char(0xBB), char(0xBF) };
-    const char* data = buffer.data();
-    const size_t BOMsize = sizeof(BOM_UTF8);
+    char const BOM_UTF8[] = { char(0xEF), char(0xBB), char(0xBF) };
+    char const* data = buffer.data();
+    size_t const BOMsize = sizeof(BOM_UTF8);
     if (length >= BOMsize && std::memcmp(data, BOM_UTF8, BOMsize) == 0) {
       // PowerShell uses UTF-8 with BOM for pipes
       actualCodepage = CP_UTF8;
       data += BOMsize;
       length -= BOMsize;
     }
-    const size_t wlength = static_cast<size_t>(MultiByteToWideChar(
+    size_t const wlength = static_cast<size_t>(MultiByteToWideChar(
       actualCodepage, 0, data, static_cast<int>(length), nullptr, 0));
     wchar_t* wbuf = new wchar_t[wlength];
-    const bool success =
+    bool const success =
       MultiByteToWideChar(actualCodepage, 0, data, static_cast<int>(length),
                           wbuf, static_cast<int>(wlength)) > 0
       ? true
@@ -369,19 +369,19 @@ private:
     delete[] wbuf;
     return success;
   }
-  std::wstring getBuffer(const std::basic_string<char> buffer)
+  std::wstring getBuffer(std::basic_string<char> const buffer)
   {
     return Encoding::ToWide(buffer);
   }
-  std::wstring getBuffer(const std::basic_string<wchar_t> buffer)
+  std::wstring getBuffer(std::basic_string<wchar_t> const buffer)
   {
     return buffer;
   }
-  void setBuffer(const std::wstring wbuffer, std::basic_string<char>& target)
+  void setBuffer(std::wstring const wbuffer, std::basic_string<char>& target)
   {
     target = Encoding::ToNarrow(wbuffer);
   }
-  void setBuffer(const std::wstring wbuffer,
+  void setBuffer(std::wstring const wbuffer,
                  std::basic_string<wchar_t>& target)
   {
     target = wbuffer;

Directory.cxx

@@ -7,6 +7,8 @@
 
 #include KWSYS_HEADER(Encoding.hxx)
 
+#include KWSYS_HEADER(SystemTools.hxx)
+
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
@@ -16,15 +18,48 @@
 #endif
 
 #include <string>
+#include <utility>
 #include <vector>
 
+#if defined(_WIN32) && !defined(__CYGWIN__)
+#  include <windows.h>
+
+#  include <ctype.h>
+#  include <fcntl.h>
+#  include <io.h>
+#  include <stdio.h>
+#  include <stdlib.h>
+#  include <string.h>
+#  include <sys/stat.h>
+#  include <sys/types.h>
+#endif
+
 namespace KWSYS_NAMESPACE {
 
 class DirectoryInternals
 {
 public:
+  struct FileData
+  {
+    std::string Name;
+#if defined(_WIN32) && !defined(__CYGWIN__)
+    WIN32_FIND_DATAW FindData;
+#endif
+    FileData(std::string name
+#if defined(_WIN32) && !defined(__CYGWIN__)
+             ,
+             WIN32_FIND_DATAW data
+#endif
+             )
+      : Name(std::move(name))
+#if defined(_WIN32) && !defined(__CYGWIN__)
+      , FindData(std::move(data))
+#endif
+    {
+    }
+  };
   // Array of Files
-  std::vector<std::string> Files;
+  std::vector<FileData> Files;
 
   // Path to Open'ed directory
   std::string Path;
@@ -57,15 +92,50 @@ unsigned long Directory::GetNumberOfFiles() const
   return static_cast<unsigned long>(this->Internal->Files.size());
 }
 
-const char* Directory::GetFile(unsigned long dindex) const
+char const* Directory::GetFile(unsigned long dindex) const
 {
-  if (dindex >= this->Internal->Files.size()) {
-    return nullptr;
+  return this->Internal->Files[dindex].Name.c_str();
+}
+
+std::string const& Directory::GetFileName(std::size_t i) const
+{
+  return this->Internal->Files[i].Name;
+}
+
+std::string Directory::GetFilePath(std::size_t i) const
+{
+  std::string abs = this->Internal->Path;
+  if (!abs.empty() && abs.back() != '/') {
+    abs += '/';
   }
-  return this->Internal->Files[dindex].c_str();
+  abs += this->Internal->Files[i].Name;
+  return abs;
 }
 
-const char* Directory::GetPath() const
+bool Directory::FileIsDirectory(std::size_t i) const
+{
+#if defined(_WIN32) && !defined(__CYGWIN__)
+  auto const& data = this->Internal->Files[i].FindData;
+  return (data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
+#else
+  std::string const& path = this->GetFilePath(i);
+  return kwsys::SystemTools::FileIsDirectory(path);
+#endif
+}
+
+bool Directory::FileIsSymlink(std::size_t i) const
+{
+  std::string const& path = this->GetFilePath(i);
+#if defined(_WIN32) && !defined(__CYGWIN__)
+  auto const& data = this->Internal->Files[i].FindData;
+  return kwsys::SystemTools::FileIsSymlinkWithAttr(
+    Encoding::ToWindowsExtendedPath(path), data.dwFileAttributes);
+#else
+  return kwsys::SystemTools::FileIsSymlink(path);
+#endif
+}
+
+char const* Directory::GetPath() const
 {
   return this->Internal->Path.c_str();
 }
@@ -81,46 +151,39 @@ void Directory::Clear()
 // First Windows platforms
 
 #if defined(_WIN32) && !defined(__CYGWIN__)
-#  include <windows.h>
-
-#  include <ctype.h>
-#  include <fcntl.h>
-#  include <io.h>
-#  include <stdio.h>
-#  include <stdlib.h>
-#  include <string.h>
-#  include <sys/stat.h>
-#  include <sys/types.h>
 
 namespace KWSYS_NAMESPACE {
 
 Status Directory::Load(std::string const& name, std::string* errorMessage)
 {
   this->Clear();
-  intptr_t srchHandle;
+  HANDLE srchHandle;
   char* buf;
+  size_t bufLength;
   size_t n = name.size();
   if (name.back() == '/' || name.back() == '\\') {
-    buf = new char[n + 1 + 1];
-    sprintf(buf, "%s*", name.c_str());
+    bufLength = n + 1 + 1;
+    buf = new char[bufLength];
+    snprintf(buf, bufLength, "%s*", name.c_str());
   } else {
     // Make sure the slashes in the wildcard suffix are consistent with the
     // rest of the path
-    buf = new char[n + 2 + 1];
+    bufLength = n + 2 + 1;
+    buf = new char[bufLength];
     if (name.find('\\') != std::string::npos) {
-      sprintf(buf, "%s\\*", name.c_str());
+      snprintf(buf, bufLength, "%s\\*", name.c_str());
     } else {
-      sprintf(buf, "%s/*", name.c_str());
+      snprintf(buf, bufLength, "%s/*", name.c_str());
     }
   }
-  struct _wfinddata_t data; // data of current file
+  WIN32_FIND_DATAW data; // data of current file
 
   // Now put them into the file array
   srchHandle =
-    _wfindfirst((wchar_t*)Encoding::ToWindowsExtendedPath(buf).c_str(), &data);
+    FindFirstFileW(Encoding::ToWindowsExtendedPath(buf).c_str(), &data);
   delete[] buf;
 
-  if (srchHandle == -1) {
+  if (srchHandle == INVALID_HANDLE_VALUE) {
     Status status = Status::POSIX_errno();
     if (errorMessage) {
       *errorMessage = status.GetString();
@@ -130,10 +193,11 @@ Status Directory::Load(std::string const& name, std::string* errorMessage)
 
   // Loop through names
   do {
-    this->Internal->Files.push_back(Encoding::ToNarrow(data.name));
-  } while (_wfindnext(srchHandle, &data) != -1);
+    this->Internal->Files.emplace_back(Encoding::ToNarrow(data.cFileName),
+                                       data);
+  } while (FindNextFileW(srchHandle, &data));
   this->Internal->Path = name;
-  if (_findclose(srchHandle) == -1) {
+  if (!FindClose(srchHandle)) {
     Status status = Status::POSIX_errno();
     if (errorMessage) {
       *errorMessage = status.GetString();
@@ -143,26 +207,29 @@ Status Directory::Load(std::string const& name, std::string* errorMessage)
   return Status::Success();
 }
 
-unsigned long Directory::GetNumberOfFilesInDirectory(const std::string& name,
+unsigned long Directory::GetNumberOfFilesInDirectory(std::string const& name,
                                                      std::string* errorMessage)
 {
-  intptr_t srchHandle;
+  HANDLE srchHandle;
   char* buf;
+  size_t bufLength;
   size_t n = name.size();
   if (name.back() == '/') {
+    bufLength = n + 1 + 1;
     buf = new char[n + 1 + 1];
-    sprintf(buf, "%s*", name.c_str());
+    snprintf(buf, bufLength, "%s*", name.c_str());
   } else {
+    bufLength = n + 2 + 1;
     buf = new char[n + 2 + 1];
-    sprintf(buf, "%s/*", name.c_str());
+    snprintf(buf, bufLength, "%s/*", name.c_str());
   }
-  struct _wfinddata_t data; // data of current file
+  WIN32_FIND_DATAW data; // data of current file
 
   // Now put them into the file array
-  srchHandle = _wfindfirst((wchar_t*)Encoding::ToWide(buf).c_str(), &data);
+  srchHandle = FindFirstFileW(Encoding::ToWide(buf).c_str(), &data);
   delete[] buf;
 
-  if (srchHandle == -1) {
+  if (srchHandle == INVALID_HANDLE_VALUE) {
     if (errorMessage) {
       if (unsigned int errorId = GetLastError()) {
         LPSTR message = nullptr;
@@ -184,8 +251,8 @@ unsigned long Directory::GetNumberOfFilesInDirectory(const std::string& name,
   unsigned long count = 0;
   do {
     count++;
-  } while (_wfindnext(srchHandle, &data) != -1);
-  _findclose(srchHandle);
+  } while (FindNextFileW(srchHandle, &data));
+  FindClose(srchHandle);
   return count;
 }
 
@@ -202,7 +269,7 @@ unsigned long Directory::GetNumberOfFilesInDirectory(const std::string& name,
 #  include <string.h>
 
 // PGI with glibc has trouble with dirent and large file support:
-//  http://www.pgroup.com/userforum/viewtopic.php?
+//  https://www.pgroup.com/userforum/viewtopic.php?
 //  p=1992&sid=f16167f51964f1a68fe5041b8eb213b6
 // Work around the problem by mapping dirent the same way as readdir.
 #  if defined(__PGI) && defined(__GLIBC__)
@@ -225,7 +292,7 @@ Status Directory::Load(std::string const& name, std::string* errorMessage)
   DIR* dir = opendir(name.c_str());
 
   if (!dir) {
-    if (errorMessage != nullptr) {
+    if (errorMessage) {
       *errorMessage = std::string(strerror(errno));
     }
     return Status::POSIX_errno();
@@ -236,7 +303,7 @@ Status Directory::Load(std::string const& name, std::string* errorMessage)
     this->Internal->Files.emplace_back(d->d_name);
   }
   if (errno != 0) {
-    if (errorMessage != nullptr) {
+    if (errorMessage) {
       *errorMessage = std::string(strerror(errno));
     }
     return Status::POSIX_errno();
@@ -247,14 +314,14 @@ Status Directory::Load(std::string const& name, std::string* errorMessage)
   return Status::Success();
 }
 
-unsigned long Directory::GetNumberOfFilesInDirectory(const std::string& name,
+unsigned long Directory::GetNumberOfFilesInDirectory(std::string const& name,
                                                      std::string* errorMessage)
 {
   errno = 0;
   DIR* dir = opendir(name.c_str());
 
   if (!dir) {
-    if (errorMessage != nullptr) {
+    if (errorMessage) {
       *errorMessage = std::string(strerror(errno));
     }
     return 0;
@@ -265,7 +332,7 @@ unsigned long Directory::GetNumberOfFilesInDirectory(const std::string& name,
     count++;
   }
   if (errno != 0) {
-    if (errorMessage != nullptr) {
+    if (errorMessage) {
       *errorMessage = std::string(strerror(errno));
     }
     return false;

Directory.hxx.in

@@ -6,6 +6,7 @@
 #include <@KWSYS_NAMESPACE@/Configure.h>
 #include <@KWSYS_NAMESPACE@/Status.hxx>
 
+#include <cstddef>
 #include <string>
 
 namespace @KWSYS_NAMESPACE@ {
@@ -25,10 +26,10 @@ class @KWSYS_NAMESPACE@_EXPORT Directory
 public:
   Directory();
   Directory(Directory&& other);
-  Directory(const Directory&) = delete;
-  Directory& operator=(const Directory&) = delete;
+  Directory(Directory const&) = delete;
+  Directory& operator=(Directory const&) = delete;
   Directory& operator=(Directory&& other);
-  bool operator==(const Directory&) = delete;
+  bool operator==(Directory const&) = delete;
   ~Directory();
 
   /**
@@ -47,17 +48,37 @@ public:
    * A higher performance static method.
    */
   static unsigned long GetNumberOfFilesInDirectory(
-    const std::string&, std::string* errorMessage = nullptr);
+    std::string const&, std::string* errorMessage = nullptr);
 
   /**
    * Return the file at the given index, the indexing is 0 based
    */
-  const char* GetFile(unsigned long) const;
+  char const* GetFile(unsigned long) const;
+
+  /**
+   * Return the name of the file at the given 0-based index.
+   */
+  std::string const& GetFileName(std::size_t i) const;
+
+  /**
+   * Return the absolute path to the file at the given 0-based index.
+   */
+  std::string GetFilePath(std::size_t i) const;
+
+  /**
+   * Return whether the file at the given 0-based index is a directory.
+   */
+  bool FileIsDirectory(std::size_t i) const;
+
+  /**
+   * Return whether the file at the given 0-based index is a symlink.
+   */
+  bool FileIsSymlink(std::size_t i) const;
 
   /**
    * Return the path to Open'ed directory
    */
-  const char* GetPath() const;
+  char const* GetPath() const;
 
   /**
    * Clear the internal structure. Used internally at beginning of Load(...)

DynamicLoader.cxx

@@ -46,7 +46,7 @@
 namespace KWSYS_NAMESPACE {
 
 DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(
-  const std::string& libname)
+  std::string const& libname)
 {
   return DynamicLoader::OpenLibrary(libname, 0);
 }
@@ -59,7 +59,7 @@ DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(
 namespace KWSYS_NAMESPACE {
 
 DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(
-  const std::string& libname, int flags)
+  std::string const& libname, int flags)
 {
   return 0;
 }
@@ -74,12 +74,12 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
 }
 
 DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
-  DynamicLoader::LibraryHandle lib, const std::string& sym)
+  DynamicLoader::LibraryHandle lib, std::string const& sym)
 {
   return 0;
 }
 
-const char* DynamicLoader::LastError()
+char const* DynamicLoader::LastError()
 {
   return "General error";
 }
@@ -94,7 +94,7 @@ const char* DynamicLoader::LastError()
 namespace KWSYS_NAMESPACE {
 
 DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(
-  const std::string& libname, int flags)
+  std::string const& libname, int flags)
 {
   CHECK_OPEN_FLAGS(flags, 0, 0);
 
@@ -110,7 +110,7 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
 }
 
 DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
-  DynamicLoader::LibraryHandle lib, const std::string& sym)
+  DynamicLoader::LibraryHandle lib, std::string const& sym)
 {
   void* addr;
   int status;
@@ -127,7 +127,7 @@ DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
   return *reinterpret_cast<DynamicLoader::SymbolPointer*>(&result);
 }
 
-const char* DynamicLoader::LastError()
+char const* DynamicLoader::LastError()
 {
   // TODO: Need implementation with errno/strerror
   /* If successful, shl_findsym returns an integer (int) value zero. If
@@ -159,7 +159,7 @@ const char* DynamicLoader::LastError()
 namespace KWSYS_NAMESPACE {
 
 DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(
-  const std::string& libname, int flags)
+  std::string const& libname, int flags)
 {
   CHECK_OPEN_FLAGS(flags, 0, 0);
 
@@ -190,7 +190,7 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
 }
 
 DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
-  DynamicLoader::LibraryHandle lib, const std::string& sym)
+  DynamicLoader::LibraryHandle lib, std::string const& sym)
 {
   void* result = 0;
   // Need to prepend symbols with '_' on Apple-gcc compilers
@@ -205,7 +205,7 @@ DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
   return *reinterpret_cast<DynamicLoader::SymbolPointer*>(&result);
 }
 
-const char* DynamicLoader::LastError()
+char const* DynamicLoader::LastError()
 {
   return 0;
 }
@@ -221,7 +221,7 @@ const char* DynamicLoader::LastError()
 namespace KWSYS_NAMESPACE {
 
 DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(
-  const std::string& libname, int flags)
+  std::string const& libname, int flags)
 {
   CHECK_OPEN_FLAGS(flags, SearchBesideLibrary, nullptr);
 
@@ -240,7 +240,7 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
 }
 
 DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
-  DynamicLoader::LibraryHandle lib, const std::string& sym)
+  DynamicLoader::LibraryHandle lib, std::string const& sym)
 {
   // TODO: The calling convention affects the name of the symbol.  We
   // should have a tool to help get the symbol with the desired
@@ -254,14 +254,14 @@ DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
   // Note that the "@X" part of the name above is the total size (in
   // bytes) of the arguments on the stack.
   void* result;
-  const char* rsym = sym.c_str();
+  char const* rsym = sym.c_str();
   result = (void*)GetProcAddress(lib, rsym);
   return *reinterpret_cast<DynamicLoader::SymbolPointer*>(&result);
 }
 
 #  define DYNLOAD_ERROR_BUFFER_SIZE 1024
 
-const char* DynamicLoader::LastError()
+char const* DynamicLoader::LastError()
 {
   wchar_t lpMsgBuf[DYNLOAD_ERROR_BUFFER_SIZE + 1];
 
@@ -275,20 +275,20 @@ const char* DynamicLoader::LastError()
 
   if (length < 1) {
     /* FormatMessage failed.  Use a default message.  */
-    _snprintf(str, DYNLOAD_ERROR_BUFFER_SIZE,
-              "DynamicLoader encountered error 0x%X.  "
-              "FormatMessage failed with error 0x%X",
-              error, GetLastError());
+    snprintf(str, DYNLOAD_ERROR_BUFFER_SIZE,
+             "DynamicLoader encountered error 0x%lX.  "
+             "FormatMessage failed with error 0x%lX",
+             error, GetLastError());
     return str;
   }
 
   if (!WideCharToMultiByte(CP_UTF8, 0, lpMsgBuf, -1, str,
                            DYNLOAD_ERROR_BUFFER_SIZE, nullptr, nullptr)) {
     /* WideCharToMultiByte failed.  Use a default message.  */
-    _snprintf(str, DYNLOAD_ERROR_BUFFER_SIZE,
-              "DynamicLoader encountered error 0x%X.  "
-              "WideCharToMultiByte failed with error 0x%X",
-              error, GetLastError());
+    snprintf(str, DYNLOAD_ERROR_BUFFER_SIZE,
+             "DynamicLoader encountered error 0x%lX.  "
+             "WideCharToMultiByte failed with error 0x%lX",
+             error, GetLastError());
   }
 
   return str;
@@ -308,7 +308,7 @@ namespace KWSYS_NAMESPACE {
 static image_id last_dynamic_err = B_OK;
 
 DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(
-  const std::string& libname, int flags)
+  std::string const& libname, int flags)
 {
   CHECK_OPEN_FLAGS(flags, 0, 0);
 
@@ -341,7 +341,7 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
 }
 
 DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
-  DynamicLoader::LibraryHandle lib, const std::string& sym)
+  DynamicLoader::LibraryHandle lib, std::string const& sym)
 {
   // Hack to cast pointer-to-data to pointer-to-function.
   union
@@ -368,9 +368,9 @@ DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
   return result.psym;
 }
 
-const char* DynamicLoader::LastError()
+char const* DynamicLoader::LastError()
 {
-  const char* retval = strerror(last_dynamic_err);
+  char const* retval = strerror(last_dynamic_err);
   last_dynamic_err = B_OK;
   return retval;
 }
@@ -388,7 +388,7 @@ const char* DynamicLoader::LastError()
 namespace KWSYS_NAMESPACE {
 
 DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(
-  const std::string& libname, int flags)
+  std::string const& libname, int flags)
 {
   CHECK_OPEN_FLAGS(flags, 0, nullptr);
 
@@ -407,7 +407,7 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
 }
 
 DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
-  DynamicLoader::LibraryHandle lib, const std::string& sym)
+  DynamicLoader::LibraryHandle lib, std::string const& sym)
 {
   // Hack to cast pointer-to-data to pointer-to-function.
   union
@@ -419,7 +419,7 @@ DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
   return result.psym;
 }
 
-const char* DynamicLoader::LastError()
+char const* DynamicLoader::LastError()
 {
   return dld_strerror(dld_errno);
 }
@@ -434,11 +434,16 @@ const char* DynamicLoader::LastError()
 namespace KWSYS_NAMESPACE {
 
 DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(
-  const std::string& libname, int flags)
+  std::string const& libname, int flags)
 {
-  CHECK_OPEN_FLAGS(flags, 0, nullptr);
+  CHECK_OPEN_FLAGS(flags, RTLDGlobal, nullptr);
+
+  int llFlags = RTLD_LAZY;
+  if (flags & RTLDGlobal) {
+    llFlags |= RTLD_GLOBAL;
+  }
 
-  return dlopen(libname.c_str(), RTLD_LAZY);
+  return dlopen(libname.c_str(), llFlags);
 }
 
 int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
@@ -452,7 +457,7 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
 }
 
 DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
-  DynamicLoader::LibraryHandle lib, const std::string& sym)
+  DynamicLoader::LibraryHandle lib, std::string const& sym)
 {
   // Hack to cast pointer-to-data to pointer-to-function.
   union
@@ -464,7 +469,7 @@ DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
   return result.psym;
 }
 
-const char* DynamicLoader::LastError()
+char const* DynamicLoader::LastError()
 {
   return dlerror();
 }

DynamicLoader.hxx.in

@@ -73,7 +73,12 @@ public:
     // This is currently only supported on Windows.
     SearchBesideLibrary = 0x00000001,
 
-    AllOpenFlags = SearchBesideLibrary
+    // Make loaded symbols visible globally
+    //
+    // This is currently only supported on *nix systems.
+    RTLDGlobal = 0x00000002,
+
+    AllOpenFlags = SearchBesideLibrary | RTLDGlobal
   };
 
   /** Load a dynamic library into the current process.
@@ -81,24 +86,24 @@ public:
    * library. The optional second argument is a set of flags to use when
    * opening the library. If unrecognized or unsupported flags are specified,
    * the library is not opened. */
-  static LibraryHandle OpenLibrary(const std::string&);
-  static LibraryHandle OpenLibrary(const std::string&, int);
+  static LibraryHandle OpenLibrary(std::string const&);
+  static LibraryHandle OpenLibrary(std::string const&, int);
 
   /** Attempt to detach a dynamic library from the
    * process.  A value of true is returned if it is successful. */
   static int CloseLibrary(LibraryHandle);
 
   /** Find the address of the symbol in the given library. */
-  static SymbolPointer GetSymbolAddress(LibraryHandle, const std::string&);
+  static SymbolPointer GetSymbolAddress(LibraryHandle, std::string const&);
 
   /** Return the default module prefix for the current platform.  */
-  static const char* LibPrefix() { return "@KWSYS_DynamicLoader_PREFIX@"; }
+  static char const* LibPrefix() { return "@KWSYS_DynamicLoader_PREFIX@"; }
 
   /** Return the default module suffix for the current platform.  */
-  static const char* LibExtension() { return "@KWSYS_DynamicLoader_SUFFIX@"; }
+  static char const* LibExtension() { return "@KWSYS_DynamicLoader_SUFFIX@"; }
 
   /** Return the last error produced from a calls made on this class. */
-  static const char* LastError();
+  static char const* LastError();
 }; // End Class: DynamicLoader
 
 } // namespace @KWSYS_NAMESPACE@

Encoding.h.in

@@ -31,22 +31,22 @@ extern "C" {
    On Windows, UTF-8 is assumed, and on other platforms,
    the current locale is assumed.
    */
-kwsysEXPORT size_t kwsysEncoding_mbstowcs(wchar_t* dest, const char* src,
+kwsysEXPORT size_t kwsysEncoding_mbstowcs(wchar_t* dest, char const* src,
                                           size_t n);
 
 /* Convert a narrow string to a wide string.
    This can return NULL if the conversion fails. */
-kwsysEXPORT wchar_t* kwsysEncoding_DupToWide(const char* src);
+kwsysEXPORT wchar_t* kwsysEncoding_DupToWide(char const* src);
 
 /* Convert a wide string to a narrow string.
    On Windows, UTF-8 is assumed, and on other platforms,
    the current locale is assumed. */
-kwsysEXPORT size_t kwsysEncoding_wcstombs(char* dest, const wchar_t* src,
+kwsysEXPORT size_t kwsysEncoding_wcstombs(char* dest, wchar_t const* src,
                                           size_t n);
 
 /* Convert a wide string to a narrow string.
    This can return NULL if the conversion fails. */
-kwsysEXPORT char* kwsysEncoding_DupToNarrow(const wchar_t* str);
+kwsysEXPORT char* kwsysEncoding_DupToNarrow(wchar_t const* str);
 
 #if defined(__cplusplus)
 } /* extern "C" */

Encoding.hxx.in

@@ -31,8 +31,8 @@ public:
     // argc and wide argv.  This is useful if wmain() is used.
     CommandLineArguments(int argc, wchar_t const* const* argv);
     ~CommandLineArguments();
-    CommandLineArguments(const CommandLineArguments&);
-    CommandLineArguments& operator=(const CommandLineArguments&);
+    CommandLineArguments(CommandLineArguments const&);
+    CommandLineArguments& operator=(CommandLineArguments const&);
 
     int argc() const;
     char const* const* argv() const;
@@ -50,14 +50,14 @@ public:
   // Convert a narrow string to a wide string.
   // On Windows, UTF-8 is assumed, and on other platforms,
   // the current locale is assumed.
-  static std::wstring ToWide(const std::string& str);
-  static std::wstring ToWide(const char* str);
+  static std::wstring ToWide(std::string const& str);
+  static std::wstring ToWide(char const* str);
 
   // Convert a wide string to a narrow string.
   // On Windows, UTF-8 is assumed, and on other platforms,
   // the current locale is assumed.
-  static std::string ToNarrow(const std::wstring& str);
-  static std::string ToNarrow(const wchar_t* str);
+  static std::string ToNarrow(std::wstring const& str);
+  static std::string ToNarrow(wchar_t const* str);
 
 #  if defined(_WIN32)
   /**
@@ -68,7 +68,7 @@ public:
    * absolute paths with Windows-style backslashes.
    **/
   static std::wstring ToWindowsExtendedPath(std::string const&);
-  static std::wstring ToWindowsExtendedPath(const char* source);
+  static std::wstring ToWindowsExtendedPath(char const* source);
   static std::wstring ToWindowsExtendedPath(std::wstring const& wsource);
 #  endif
 

EncodingC.c

@@ -15,7 +15,7 @@
 #  include <windows.h>
 #endif
 
-size_t kwsysEncoding_mbstowcs(wchar_t* dest, const char* str, size_t n)
+size_t kwsysEncoding_mbstowcs(wchar_t* dest, char const* str, size_t n)
 {
   if (str == 0) {
     return (size_t)-1;
@@ -29,7 +29,7 @@ size_t kwsysEncoding_mbstowcs(wchar_t* dest, const char* str, size_t n)
 #endif
 }
 
-wchar_t* kwsysEncoding_DupToWide(const char* str)
+wchar_t* kwsysEncoding_DupToWide(char const* str)
 {
   wchar_t* ret = NULL;
   size_t length = kwsysEncoding_mbstowcs(NULL, str, 0) + 1;
@@ -43,7 +43,7 @@ wchar_t* kwsysEncoding_DupToWide(const char* str)
   return ret;
 }
 
-size_t kwsysEncoding_wcstombs(char* dest, const wchar_t* str, size_t n)
+size_t kwsysEncoding_wcstombs(char* dest, wchar_t const* str, size_t n)
 {
   if (str == 0) {
     return (size_t)-1;
@@ -57,7 +57,7 @@ size_t kwsysEncoding_wcstombs(char* dest, const wchar_t* str, size_t n)
 #endif
 }
 
-char* kwsysEncoding_DupToNarrow(const wchar_t* str)
+char* kwsysEncoding_DupToNarrow(wchar_t const* str)
 {
   char* ret = NULL;
   size_t length = kwsysEncoding_wcstombs(NULL, str, 0) + 1;

EncodingCXX.cxx

@@ -86,7 +86,7 @@ Encoding::CommandLineArguments::~CommandLineArguments()
 }
 
 Encoding::CommandLineArguments::CommandLineArguments(
-  const CommandLineArguments& other)
+  CommandLineArguments const& other)
 {
   this->argv_.resize(other.argv_.size());
   for (size_t i = 0; i < this->argv_.size(); i++) {
@@ -95,7 +95,7 @@ Encoding::CommandLineArguments::CommandLineArguments(
 }
 
 Encoding::CommandLineArguments& Encoding::CommandLineArguments::operator=(
-  const CommandLineArguments& other)
+  CommandLineArguments const& other)
 {
   if (this != &other) {
     size_t i;
@@ -124,11 +124,11 @@ char const* const* Encoding::CommandLineArguments::argv() const
 
 #if KWSYS_STL_HAS_WSTRING
 
-std::wstring Encoding::ToWide(const std::string& str)
+std::wstring Encoding::ToWide(std::string const& str)
 {
   std::wstring wstr;
 #  if defined(_WIN32)
-  const int wlength =
+  int const wlength =
     MultiByteToWideChar(KWSYS_ENCODING_DEFAULT_CODEPAGE, 0, str.data(),
                         int(str.size()), nullptr, 0);
   if (wlength > 0) {
@@ -157,7 +157,7 @@ std::wstring Encoding::ToWide(const std::string& str)
   return wstr;
 }
 
-std::string Encoding::ToNarrow(const std::wstring& str)
+std::string Encoding::ToNarrow(std::wstring const& str)
 {
   std::string nstr;
 #  if defined(_WIN32)
@@ -191,28 +191,32 @@ std::string Encoding::ToNarrow(const std::wstring& str)
   return nstr;
 }
 
-std::wstring Encoding::ToWide(const char* cstr)
+std::wstring Encoding::ToWide(char const* cstr)
 {
   std::wstring wstr;
-  size_t length = kwsysEncoding_mbstowcs(nullptr, cstr, 0) + 1;
-  if (length > 0) {
-    std::vector<wchar_t> wchars(length);
-    if (kwsysEncoding_mbstowcs(&wchars[0], cstr, length) > 0) {
-      wstr = &wchars[0];
-    }
+  size_t length = kwsysEncoding_mbstowcs(nullptr, cstr, 0);
+  if (length == 0 || length == static_cast<size_t>(-1)) {
+    return wstr;
+  }
+  ++length;
+  std::vector<wchar_t> wchars(length);
+  if (kwsysEncoding_mbstowcs(wchars.data(), cstr, length) > 0) {
+    wstr = wchars.data();
   }
   return wstr;
 }
 
-std::string Encoding::ToNarrow(const wchar_t* wcstr)
+std::string Encoding::ToNarrow(wchar_t const* wcstr)
 {
   std::string str;
-  size_t length = kwsysEncoding_wcstombs(nullptr, wcstr, 0) + 1;
-  if (length > 0) {
-    std::vector<char> chars(length);
-    if (kwsysEncoding_wcstombs(&chars[0], wcstr, length) > 0) {
-      str = &chars[0];
-    }
+  size_t length = kwsysEncoding_wcstombs(nullptr, wcstr, 0);
+  if (length == 0 || length == static_cast<size_t>(-1)) {
+    return str;
+  }
+  ++length;
+  std::vector<char> chars(length);
+  if (kwsysEncoding_wcstombs(chars.data(), wcstr, length) > 0) {
+    str = chars.data();
   }
   return str;
 }
@@ -225,7 +229,7 @@ std::wstring Encoding::ToWindowsExtendedPath(std::string const& source)
 }
 
 // Convert local paths to UNC style paths
-std::wstring Encoding::ToWindowsExtendedPath(const char* source)
+std::wstring Encoding::ToWindowsExtendedPath(char const* source)
 {
   return ToWindowsExtendedPath(ToWide(source));
 }

FStream.hxx.in

@@ -33,7 +33,7 @@ public:
   typedef std::basic_filebuf<CharType, Traits> my_base_type;
   basic_filebuf* open(char const* s, std::ios_base::openmode mode)
   {
-    const std::wstring wstr = Encoding::ToWindowsExtendedPath(s);
+    std::wstring const wstr = Encoding::ToWindowsExtendedPath(s);
     return static_cast<basic_filebuf*>(my_base_type::open(wstr.c_str(), mode));
   }
 #    endif
@@ -41,7 +41,7 @@ public:
 
 #  else
 
-inline std::wstring getcmode(const std::ios_base::openmode mode)
+inline std::wstring getcmode(std::ios_base::openmode const mode)
 {
   std::wstring cmode;
   bool plus = false;
@@ -91,9 +91,9 @@ public:
       return false;
     }
 #  if defined(_MSC_VER)
-    const bool success = buf_->open(file_name, mode) != 0;
+    bool const success = buf_->open(file_name, mode) != 0;
 #  else
-    const std::wstring wstr = Encoding::ToWindowsExtendedPath(file_name);
+    std::wstring const wstr = Encoding::ToWindowsExtendedPath(file_name);
     bool success = false;
     std::wstring cmode = getcmode(mode);
     file_ = _wfopen(wstr.c_str(), cmode.c_str());