diff --git a/thirdparty/KWSys/CMakeLists.txt b/thirdparty/KWSys/CMakeLists.txt
index 62afcc1147e786f747b8918cb51e1692dedb8b99..c0e95036c4934402c6bf24acc1d3ddb87c756265 100644
--- a/thirdparty/KWSys/CMakeLists.txt
+++ b/thirdparty/KWSys/CMakeLists.txt
@@ -2,15 +2,7 @@ set(KWSYS_NAMESPACE adios2sys)
set(KWSYS_USE_DynamicLoader ON)
set(KWSYS_USE_RegularExpression ON)
set(KWSYS_USE_SystemTools ON)
-set(KWSYS_BUILD_SHARED OFF)
-if(NOT ADIOS2_BUILD_SHARED_LIBS)
- set(KWSYS_INSTALL_EXPORT_NAME adios2)
- set(KWSYS_INSTALL_LIB_DIR ${CMAKE_INSTALL_LIBDIR})
-endif()
+set(KWSYS_BUILD_SHARED ${ADIOS2_BUILD_SHARED_LIBS})
+set(KWSYS_SPLIT_OBJECTS_FROM_INTERFACE ON)
-add_subdirectory(adios2sys)
-
-# Add the include usage requirements for KWSys
-target_include_directories(adios2sys
- INTERFACE ${CMAKE_CURRENT_BINARY_DIR}/adios2sys
-)
+add_subdirectory(adios2sys EXCLUDE_FROM_ALL)
diff --git a/thirdparty/KWSys/adios2sys/Base64.c b/thirdparty/KWSys/adios2sys/Base64.c
index 37c3b8c40ad3a2802274dd30366a5633e4f21967..99f008e595e97a118303b16ad59c41108d3cc352 100644
--- a/thirdparty/KWSys/adios2sys/Base64.c
+++ b/thirdparty/KWSys/adios2sys/Base64.c
@@ -9,13 +9,11 @@
#include "Base64.h.in"
#endif
-/*--------------------------------------------------------------------------*/
static const unsigned char kwsysBase64EncodeTable[65] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"abcdefghijklmnopqrstuvwxyz"
"0123456789+/";
-/*--------------------------------------------------------------------------*/
static const unsigned char 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,
@@ -40,19 +38,16 @@ static const unsigned char kwsysBase64DecodeTable[256] = {
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
};
-/*--------------------------------------------------------------------------*/
static unsigned char kwsysBase64EncodeChar(int c)
{
return kwsysBase64EncodeTable[(unsigned char)c];
}
-/*--------------------------------------------------------------------------*/
static unsigned char kwsysBase64DecodeChar(unsigned char c)
{
return kwsysBase64DecodeTable[c];
}
-/*--------------------------------------------------------------------------*/
/* Encode 3 bytes into a 4 byte string. */
void kwsysBase64_Encode3(const unsigned char* src, unsigned char* dest)
{
@@ -64,7 +59,6 @@ void kwsysBase64_Encode3(const unsigned char* src, unsigned char* dest)
dest[3] = kwsysBase64EncodeChar(src[2] & 0x3F);
}
-/*--------------------------------------------------------------------------*/
/* Encode 2 bytes into a 4 byte string. */
void kwsysBase64_Encode2(const unsigned char* src, unsigned char* dest)
{
@@ -75,7 +69,6 @@ void kwsysBase64_Encode2(const unsigned char* src, unsigned char* dest)
dest[3] = '=';
}
-/*--------------------------------------------------------------------------*/
/* Encode 1 bytes into a 4 byte string. */
void kwsysBase64_Encode1(const unsigned char* src, unsigned char* dest)
{
@@ -85,7 +78,6 @@ void kwsysBase64_Encode1(const unsigned char* src, unsigned char* dest)
dest[3] = '=';
}
-/*--------------------------------------------------------------------------*/
/* Encode 'length' bytes from the input buffer and store the
encoded stream into the output buffer. Return the length of the encoded
buffer (output). Note that the output buffer must be allocated by the caller
@@ -135,7 +127,6 @@ size_t kwsysBase64_Encode(const unsigned char* input, size_t length,
return (size_t)(optr - output);
}
-/*--------------------------------------------------------------------------*/
/* Decode 4 bytes into a 3 byte string. */
int kwsysBase64_Decode3(const unsigned char* src, unsigned char* dest)
{
@@ -169,7 +160,6 @@ int kwsysBase64_Decode3(const unsigned char* src, unsigned char* dest)
return 3;
}
-/*--------------------------------------------------------------------------*/
/* Decode bytes from the input buffer and store the decoded stream
into the output buffer until 'length' bytes have been decoded. Return the
real length of the decoded stream (which should be equal to 'length'). Note
diff --git a/thirdparty/KWSys/adios2sys/CMakeLists.txt b/thirdparty/KWSys/adios2sys/CMakeLists.txt
index e15b49e42638dad201c022544633bf88ecb74093..5d5fa9df510129a61de7a5fd92bf3dcd2d3246c2 100644
--- a/thirdparty/KWSys/adios2sys/CMakeLists.txt
+++ b/thirdparty/KWSys/adios2sys/CMakeLists.txt
@@ -20,6 +20,21 @@
# KWSYS_HEADER_ROOT = The directory into which to generate the kwsys headers.
# A directory called "${KWSYS_NAMESPACE}" will be
# created under this root directory to hold the files.
+# KWSYS_SPLIT_OBJECTS_FROM_INTERFACE
+# = Instead of creating a single ${KWSYS_NAMESPACE} library
+# target, create three separate targets:
+# ${KWSYS_NAMESPACE}_objects
+# - An OBJECT library for the built kwsys objects.
+# ${KWSYS_NAMESPACE}_interface
+# - An INTERFACE library for the usage requirements.
+# ${KWSYS_NAMESPACE}
+# - An INTERFACE library combining both that is
+# appropriate for use with PRIVATE linking in
+# target_link_libraries. Because of how interface
+# properties propagate, this target is not suitable
+# for use with PUBLIC or INTERFACE linking.
+# Note: only the ${KWSYS_NAMESPACE}_interface library will
+# be installed
#
# Example:
#
@@ -79,6 +94,10 @@ FOREACH(p
ENDFOREACH()
SET(CMAKE_LEGACY_CYGWIN_WIN32 0)
+IF(CMAKE_VERSION VERSION_LESS 3.0)
+ SET(KWSYS_SPLIT_OBJECTS_FROM_INTERFACE 0)
+ENDIF()
+
#-----------------------------------------------------------------------------
# If a namespace is not specified, use "kwsys" and enable testing.
# This should be the case only when kwsys is not included inside
@@ -795,67 +814,126 @@ ENDFOREACH()
#-----------------------------------------------------------------------------
# Add the library with the configured name and list of sources.
IF(KWSYS_C_SRCS OR KWSYS_CXX_SRCS)
- ADD_LIBRARY(${KWSYS_NAMESPACE} ${KWSYS_LIBRARY_TYPE}
- ${KWSYS_C_SRCS} ${KWSYS_CXX_SRCS})
- SET_PROPERTY(TARGET ${KWSYS_NAMESPACE} PROPERTY C_INCLUDE_WHAT_YOU_USE "")
- SET_PROPERTY(TARGET ${KWSYS_NAMESPACE} PROPERTY CXX_INCLUDE_WHAT_YOU_USE "")
- SET_PROPERTY(TARGET ${KWSYS_NAMESPACE} PROPERTY LABELS ${KWSYS_LABELS_LIB})
+ IF(KWSYS_SPLIT_OBJECTS_FROM_INTERFACE)
+ SET(KWSYS_TARGET_INTERFACE ${KWSYS_NAMESPACE}_interface)
+ SET(KWSYS_TARGET_OBJECT ${KWSYS_NAMESPACE}_objects)
+ SET(KWSYS_TARGET_LINK ${KWSYS_NAMESPACE})
+ SET(KWSYS_LINK_DEPENDENCY INTERFACE)
+ ADD_LIBRARY(${KWSYS_TARGET_OBJECT} OBJECT
+ ${KWSYS_C_SRCS} ${KWSYS_CXX_SRCS})
+ IF(KWSYS_BUILD_SHARED)
+ 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
+ ${KWSYS_TARGET_INTERFACE})
+ TARGET_SOURCES(${KWSYS_TARGET_LINK} INTERFACE
+ $<TARGET_OBJECTS:${KWSYS_TARGET_OBJECT}>)
+ ELSE()
+ SET(KWSYS_TARGET_INTERFACE ${KWSYS_NAMESPACE})
+ SET(KWSYS_TARGET_OBJECT ${KWSYS_NAMESPACE})
+ SET(KWSYS_TARGET_LINK ${KWSYS_NAMESPACE})
+ SET(KWSYS_LINK_DEPENDENCY PUBLIC)
+ ADD_LIBRARY(${KWSYS_TARGET_INTERFACE} ${KWSYS_LIBRARY_TYPE}
+ ${KWSYS_C_SRCS} ${KWSYS_CXX_SRCS})
+ ENDIF()
+ 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_NAMESPACE} ${CMAKE_DL_LIBS})
+ TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
+ ${CMAKE_DL_LIBS})
ENDIF()
ENDIF()
IF(KWSYS_USE_SystemInformation)
IF(WIN32)
- TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE} ws2_32)
+ TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY} ws2_32)
IF(KWSYS_SYS_HAS_PSAPI)
- TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE} 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_NAMESPACE} ${EXECINFO_LIB})
+ TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
+ ${EXECINFO_LIB})
ENDIF()
IF (KWSYS_CXX_HAS_DLADDR)
# for symbol lookup using dladdr
- TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE} ${CMAKE_DL_LIBS})
+ TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
+ ${CMAKE_DL_LIBS})
ENDIF()
IF (CMAKE_SYSTEM_NAME STREQUAL "SunOS")
- TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE} socket)
+ TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
+ socket)
ENDIF()
ENDIF()
ENDIF()
# Apply user-defined target properties to the library.
IF(KWSYS_PROPERTIES_CXX)
- SET_TARGET_PROPERTIES(${KWSYS_NAMESPACE} PROPERTIES
- ${KWSYS_PROPERTIES_CXX}
- )
+ SET_TARGET_PROPERTIES(${KWSYS_TARGET_INTERFACE} PROPERTIES
+ ${KWSYS_PROPERTIES_CXX})
+ ENDIF()
+
+ # Set up include usage requirement
+ IF(COMMAND TARGET_INCLUDE_DIRECTORIES)
+ TARGET_INCLUDE_DIRECTORIES(${KWSYS_TARGET_INTERFACE} INTERFACE
+ ${CMAKE_CURRENT_BINARY_DIR})
ENDIF()
# Create an install target for the library.
IF(KWSYS_INSTALL_LIBRARY_RULE)
- INSTALL(TARGETS ${KWSYS_NAMESPACE} ${KWSYS_INSTALL_LIBRARY_RULE})
+ INSTALL(TARGETS ${KWSYS_TARGET_INTERFACE} ${KWSYS_INSTALL_LIBRARY_RULE})
ENDIF()
ENDIF()
# Add a C-only library if requested.
IF(KWSYS_ENABLE_C AND KWSYS_C_SRCS)
- ADD_LIBRARY(${KWSYS_NAMESPACE}_c ${KWSYS_LIBRARY_TYPE} ${KWSYS_C_SRCS})
- SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}_c PROPERTY LABELS ${KWSYS_LABELS_LIB})
+ IF(KWSYS_SPLIT_OBJECTS_FROM_INTERFACE)
+ SET(KWSYS_TARGET_C_INTERFACE ${KWSYS_NAMESPACE}_c_interface)
+ SET(KWSYS_TARGET_C_OBJECT ${KWSYS_NAMESPACE}_c_object)
+ SET(KWSYS_TARGET_C_LINK ${KWSYS_NAMESPACE}_c)
+ SET(KWSYS_LINK_DEPENDENCY INTERFACE)
+ ADD_LIBRARY(${KWSYS_TARGET_C_OBJECT} OBJECT ${KWSYS_C_SRCS})
+ IF(KWSYS_BUILD_SHARED)
+ 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
+ ${KWSYS_TARGET_C_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_LINK_DEPENDENCY PUBLIC)
+ ADD_LIBRARY(${KWSYS_TARGET_C_INTERFACE} ${KWSYS_LIBRARY_TYPE}
+ ${KWSYS_C_SRCS})
+ 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_NAMESPACE}_c PROPERTIES
- ${KWSYS_PROPERTIES_C}
- )
+ SET_TARGET_PROPERTIES(${KWSYS_TARGET_C_INTERFACE} PROPERTIES
+ ${KWSYS_PROPERTIES_C})
ENDIF()
# Create an install target for the library.
IF(KWSYS_INSTALL_LIBRARY_RULE)
- INSTALL(TARGETS ${KWSYS_NAMESPACE}_c ${KWSYS_INSTALL_LIBRARY_RULE})
- ENDIF()
+ INSTALL(TARGETS ${KWSYS_TARGET_C_INTERFACE} ${KWSYS_INSTALL_LIBRARY_RULE})
+ ENDIF()
ENDIF()
# For building kwsys itself, we use a macro defined on the command
@@ -913,7 +991,7 @@ 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_NAMESPACE}_c)
+ TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestsC ${KWSYS_TARGET_C_LINK})
FOREACH(test ${KWSYS_C_TESTS})
ADD_TEST(kwsys.${test} ${EXEC_DIR}/${KWSYS_NAMESPACE}TestsC ${test} ${KWSYS_TEST_ARGS_${test}})
SET_PROPERTY(TEST kwsys.${test} PROPERTY LABELS ${KWSYS_LABELS_TEST})
@@ -943,10 +1021,12 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
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_NAMESPACE})
+ TARGET_LINK_LIBRARIES(testConsoleBufChild ${KWSYS_TARGET_LINK})
SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS}
testConsoleBuf
)
@@ -965,17 +1045,19 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
# 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_NAMESPACE})
+ ADD_DEPENDENCIES(${KWSYS_NAMESPACE}TestDynload ${KWSYS_TARGET_INTERFACE})
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_NAMESPACE})
+ 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}")
@@ -1026,7 +1108,7 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
# 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_NAMESPACE}_c)
+ TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestProcess ${KWSYS_TARGET_C_LINK})
IF(NOT CYGWIN)
SET(KWSYS_TEST_PROCESS_7 7)
ENDIF()
@@ -1039,8 +1121,12 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
# Some Apple compilers produce bad optimizations in this source.
IF(APPLE AND CMAKE_C_COMPILER_ID MATCHES "^(GNU|LLVM)$")
SET_SOURCE_FILES_PROPERTIES(testProcess.c PROPERTIES COMPILE_FLAGS -O0)
- ELSEIF(CMAKE_C_COMPILER_ID STREQUAL "XL")
+ ELSEIF(CMAKE_C_COMPILER_ID STREQUAL "XL" AND
+ NOT (CMAKE_SYSTEM MATCHES "Linux.*ppc64le" AND
+ NOT CMAKE_C_COMPILER_VERSION VERSION_LESS "13.1.1"))
# Tell IBM XL not to warn about our test infinite loop
+ # v13.1.1 and newer on Linux ppc64le is clang based and does not accept
+ # the -qsuppress option
SET_PROPERTY(SOURCE testProcess.c PROPERTY COMPILE_FLAGS -qsuppress=1500-010)
ENDIF()
@@ -1050,7 +1136,7 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
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_NAMESPACE}_c)
+ 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})
diff --git a/thirdparty/KWSys/adios2sys/CONTRIBUTING.rst b/thirdparty/KWSys/adios2sys/CONTRIBUTING.rst
index d71832a1bc5b2eae1fa671b01fc85834cd3901de..70a313e05865087c232c3ed33a8075aa20b2d3d7 100644
--- a/thirdparty/KWSys/adios2sys/CONTRIBUTING.rst
+++ b/thirdparty/KWSys/adios2sys/CONTRIBUTING.rst
@@ -27,10 +27,12 @@ copies of KWSys within dependent projects can be updated to get the changes.
Code Style
==========
-We use `clang-format`_ to define our style for C++ code in the KWSys source
-tree. See the `.clang-format`_ configuration file for our style settings.
-Use ``clang-format`` version 3.8 or higher to format source files.
-See also the `clang-format.bash`_ script.
+We use `clang-format`_ version **3.8** 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`: .clang-format
diff --git a/thirdparty/KWSys/adios2sys/CommandLineArguments.cxx b/thirdparty/KWSys/adios2sys/CommandLineArguments.cxx
index 226263cc941b15867699e0840da83ddacda68c23..5613bd7abe30a3374d855f902fe0dc3aa35bcebd 100644
--- a/thirdparty/KWSys/adios2sys/CommandLineArguments.cxx
+++ b/thirdparty/KWSys/adios2sys/CommandLineArguments.cxx
@@ -41,8 +41,6 @@
namespace KWSYS_NAMESPACE {
-//----------------------------------------------------------------------------
-//============================================================================
struct CommandLineArgumentsCallbackStructure
{
const char* Argument;
@@ -91,10 +89,7 @@ public:
VectorOfStrings UnusedArguments;
};
-//============================================================================
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
CommandLineArguments::CommandLineArguments()
{
this->Internals = new CommandLineArguments::Internal;
@@ -103,13 +98,11 @@ CommandLineArguments::CommandLineArguments()
this->StoreUnusedArgumentsFlag = false;
}
-//----------------------------------------------------------------------------
CommandLineArguments::~CommandLineArguments()
{
delete this->Internals;
}
-//----------------------------------------------------------------------------
void CommandLineArguments::Initialize(int argc, const char* const argv[])
{
int cc;
@@ -121,26 +114,22 @@ 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));
}
-//----------------------------------------------------------------------------
void CommandLineArguments::Initialize()
{
this->Internals->Argv.clear();
this->Internals->LastArgument = 0;
}
-//----------------------------------------------------------------------------
void CommandLineArguments::ProcessArgument(const char* arg)
{
this->Internals->Argv.push_back(arg);
}
-//----------------------------------------------------------------------------
bool CommandLineArguments::GetMatchedArguments(
std::vector<std::string>* matches, const std::string& arg)
{
@@ -164,7 +153,6 @@ bool CommandLineArguments::GetMatchedArguments(
return !matches->empty();
}
-//----------------------------------------------------------------------------
int CommandLineArguments::Parse()
{
std::vector<std::string>::size_type cc;
@@ -286,7 +274,6 @@ int CommandLineArguments::Parse()
return 1;
}
-//----------------------------------------------------------------------------
void CommandLineArguments::GetRemainingArguments(int* argc, char*** argv)
{
CommandLineArguments::Internal::VectorOfStrings::size_type size =
@@ -310,7 +297,6 @@ void CommandLineArguments::GetRemainingArguments(int* argc, char*** argv)
*argv = args;
}
-//----------------------------------------------------------------------------
void CommandLineArguments::GetUnusedArguments(int* argc, char*** argv)
{
CommandLineArguments::Internal::VectorOfStrings::size_type size =
@@ -334,7 +320,6 @@ void CommandLineArguments::GetUnusedArguments(int* argc, char*** argv)
*argv = args;
}
-//----------------------------------------------------------------------------
void CommandLineArguments::DeleteRemainingArguments(int argc, char*** argv)
{
int cc;
@@ -344,7 +329,6 @@ void CommandLineArguments::DeleteRemainingArguments(int argc, char*** argv)
delete[] * argv;
}
-//----------------------------------------------------------------------------
void CommandLineArguments::AddCallback(const char* argument,
ArgumentTypeEnum type,
CallbackType callback, void* call_data,
@@ -363,7 +347,6 @@ void CommandLineArguments::AddCallback(const char* argument,
this->GenerateHelp();
}
-//----------------------------------------------------------------------------
void CommandLineArguments::AddArgument(const char* argument,
ArgumentTypeEnum type,
VariableTypeEnum vtype, void* variable,
@@ -382,7 +365,6 @@ void CommandLineArguments::AddArgument(const char* argument,
this->GenerateHelp();
}
-//----------------------------------------------------------------------------
#define CommandLineArgumentsAddArgumentMacro(type, ctype) \
void CommandLineArguments::AddArgument(const char* argument, \
ArgumentTypeEnum type, \
@@ -392,22 +374,24 @@ void CommandLineArguments::AddArgument(const char* argument,
variable, help); \
}
+/* clang-format off */
CommandLineArgumentsAddArgumentMacro(BOOL, bool)
- CommandLineArgumentsAddArgumentMacro(INT, int)
- CommandLineArgumentsAddArgumentMacro(DOUBLE, double)
- CommandLineArgumentsAddArgumentMacro(STRING, char*)
- CommandLineArgumentsAddArgumentMacro(STL_STRING, std::string)
-
- CommandLineArgumentsAddArgumentMacro(VECTOR_BOOL, std::vector<bool>)
- CommandLineArgumentsAddArgumentMacro(VECTOR_INT, std::vector<int>)
- CommandLineArgumentsAddArgumentMacro(VECTOR_DOUBLE,
- std::vector<double>)
- CommandLineArgumentsAddArgumentMacro(VECTOR_STRING,
- std::vector<char*>)
- CommandLineArgumentsAddArgumentMacro(
- VECTOR_STL_STRING, std::vector<std::string>)
-
-//----------------------------------------------------------------------------
+CommandLineArgumentsAddArgumentMacro(INT, int)
+CommandLineArgumentsAddArgumentMacro(DOUBLE, double)
+CommandLineArgumentsAddArgumentMacro(STRING, char*)
+CommandLineArgumentsAddArgumentMacro(STL_STRING, std::string)
+
+CommandLineArgumentsAddArgumentMacro(VECTOR_BOOL, std::vector<bool>)
+CommandLineArgumentsAddArgumentMacro(VECTOR_INT, std::vector<int>)
+CommandLineArgumentsAddArgumentMacro(VECTOR_DOUBLE, std::vector<double>)
+CommandLineArgumentsAddArgumentMacro(VECTOR_STRING, std::vector<char*>)
+CommandLineArgumentsAddArgumentMacro(VECTOR_STL_STRING,
+ std::vector<std::string>)
+#ifdef HELP_CLANG_FORMAT
+;
+#endif
+/* clang-format on */
+
#define CommandLineArgumentsAddBooleanArgumentMacro(type, ctype) \
void CommandLineArguments::AddBooleanArgument( \
const char* argument, ctype* variable, const char* help) \
@@ -416,29 +400,28 @@ CommandLineArgumentsAddArgumentMacro(BOOL, bool)
CommandLineArguments::type##_TYPE, variable, help); \
}
- CommandLineArgumentsAddBooleanArgumentMacro(BOOL, bool)
- CommandLineArgumentsAddBooleanArgumentMacro(INT, int)
- CommandLineArgumentsAddBooleanArgumentMacro(DOUBLE,
- double)
- CommandLineArgumentsAddBooleanArgumentMacro(STRING,
- char*)
- CommandLineArgumentsAddBooleanArgumentMacro(
- STL_STRING, std::string)
+/* clang-format off */
+CommandLineArgumentsAddBooleanArgumentMacro(BOOL, bool)
+CommandLineArgumentsAddBooleanArgumentMacro(INT, int)
+CommandLineArgumentsAddBooleanArgumentMacro(DOUBLE, double)
+CommandLineArgumentsAddBooleanArgumentMacro(STRING, char*)
+CommandLineArgumentsAddBooleanArgumentMacro(STL_STRING, std::string)
+#ifdef HELP_CLANG_FORMAT
+;
+#endif
+/* clang-format on */
- //----------------------------------------------------------------------------
- void CommandLineArguments::SetClientData(void* client_data)
+void CommandLineArguments::SetClientData(void* client_data)
{
this->Internals->ClientData = client_data;
}
-//----------------------------------------------------------------------------
void CommandLineArguments::SetUnknownArgumentCallback(
CommandLineArguments::ErrorCallbackType callback)
{
this->Internals->UnknownArgumentCallback = callback;
}
-//----------------------------------------------------------------------------
const char* CommandLineArguments::GetHelp(const char* arg)
{
CommandLineArguments::Internal::CallbacksMap::iterator it =
@@ -461,7 +444,6 @@ const char* CommandLineArguments::GetHelp(const char* arg)
return cs->Help;
}
-//----------------------------------------------------------------------------
void CommandLineArguments::SetLineLength(unsigned int ll)
{
if (ll < 9 || ll > 1000) {
@@ -471,19 +453,16 @@ void CommandLineArguments::SetLineLength(unsigned int ll)
this->GenerateHelp();
}
-//----------------------------------------------------------------------------
const char* CommandLineArguments::GetArgv0()
{
return this->Internals->Argv0.c_str();
}
-//----------------------------------------------------------------------------
unsigned int CommandLineArguments::GetLastArgument()
{
return static_cast<unsigned int>(this->Internals->LastArgument + 1);
}
-//----------------------------------------------------------------------------
void CommandLineArguments::GenerateHelp()
{
std::ostringstream str;
@@ -633,7 +612,6 @@ void CommandLineArguments::GenerateHelp()
this->Help = str.str();
}
-//----------------------------------------------------------------------------
void CommandLineArguments::PopulateVariable(bool* variable,
const std::string& value)
{
@@ -646,7 +624,6 @@ void CommandLineArguments::PopulateVariable(bool* variable,
}
}
-//----------------------------------------------------------------------------
void CommandLineArguments::PopulateVariable(int* variable,
const std::string& value)
{
@@ -658,7 +635,6 @@ void CommandLineArguments::PopulateVariable(int* variable,
// }
}
-//----------------------------------------------------------------------------
void CommandLineArguments::PopulateVariable(double* variable,
const std::string& value)
{
@@ -670,7 +646,6 @@ void CommandLineArguments::PopulateVariable(double* variable,
// }
}
-//----------------------------------------------------------------------------
void CommandLineArguments::PopulateVariable(char** variable,
const std::string& value)
{
@@ -682,14 +657,12 @@ void CommandLineArguments::PopulateVariable(char** variable,
strcpy(*variable, value.c_str());
}
-//----------------------------------------------------------------------------
void CommandLineArguments::PopulateVariable(std::string* variable,
const std::string& value)
{
*variable = value;
}
-//----------------------------------------------------------------------------
void CommandLineArguments::PopulateVariable(std::vector<bool>* variable,
const std::string& value)
{
@@ -702,7 +675,6 @@ void CommandLineArguments::PopulateVariable(std::vector<bool>* variable,
variable->push_back(val);
}
-//----------------------------------------------------------------------------
void CommandLineArguments::PopulateVariable(std::vector<int>* variable,
const std::string& value)
{
@@ -714,7 +686,6 @@ void CommandLineArguments::PopulateVariable(std::vector<int>* variable,
// }
}
-//----------------------------------------------------------------------------
void CommandLineArguments::PopulateVariable(std::vector<double>* variable,
const std::string& value)
{
@@ -726,7 +697,6 @@ void CommandLineArguments::PopulateVariable(std::vector<double>* variable,
// }
}
-//----------------------------------------------------------------------------
void CommandLineArguments::PopulateVariable(std::vector<char*>* variable,
const std::string& value)
{
@@ -735,14 +705,12 @@ void CommandLineArguments::PopulateVariable(std::vector<char*>* variable,
variable->push_back(var);
}
-//----------------------------------------------------------------------------
void CommandLineArguments::PopulateVariable(std::vector<std::string>* variable,
const std::string& value)
{
variable->push_back(value);
}
-//----------------------------------------------------------------------------
bool CommandLineArguments::PopulateVariable(
CommandLineArgumentsCallbackStructure* cs, const char* value)
{
diff --git a/thirdparty/KWSys/adios2sys/ConsoleBuf.hxx.in b/thirdparty/KWSys/adios2sys/ConsoleBuf.hxx.in
index 32e680ca64010d6ccebf58d1975cf72d19092394..46d65a865f2d1a01b8c90e4a851c732ef61e6790 100644
--- a/thirdparty/KWSys/adios2sys/ConsoleBuf.hxx.in
+++ b/thirdparty/KWSys/adios2sys/ConsoleBuf.hxx.in
@@ -338,7 +338,7 @@ private:
}
bool decodeInputBuffer(const std::string buffer, std::wstring& wbuffer)
{
- int length = int(buffer.length());
+ size_t length = buffer.length();
if (length == 0) {
wbuffer = std::wstring();
return true;
@@ -353,11 +353,12 @@ private:
data += BOMsize;
length -= BOMsize;
}
- const int wlength =
- MultiByteToWideChar(actualCodepage, 0, data, length, NULL, 0);
+ const size_t wlength = static_cast<size_t>(MultiByteToWideChar(
+ actualCodepage, 0, data, static_cast<int>(length), NULL, 0));
wchar_t* wbuf = new wchar_t[wlength];
const bool success =
- MultiByteToWideChar(actualCodepage, 0, data, length, wbuf, wlength) > 0
+ MultiByteToWideChar(actualCodepage, 0, data, static_cast<int>(length),
+ wbuf, static_cast<int>(wlength)) > 0
? true
: false;
wbuffer = std::wstring(wbuf, wlength);
diff --git a/thirdparty/KWSys/adios2sys/Directory.cxx b/thirdparty/KWSys/adios2sys/Directory.cxx
index 3c31b49ebdcadcd6cc7a3775d7a4524ea3070d18..5141d451929bc2499fa1e45e046b25063ff479a5 100644
--- a/thirdparty/KWSys/adios2sys/Directory.cxx
+++ b/thirdparty/KWSys/adios2sys/Directory.cxx
@@ -20,7 +20,6 @@
namespace KWSYS_NAMESPACE {
-//----------------------------------------------------------------------------
class DirectoryInternals
{
public:
@@ -31,25 +30,21 @@ public:
std::string Path;
};
-//----------------------------------------------------------------------------
Directory::Directory()
{
this->Internal = new DirectoryInternals;
}
-//----------------------------------------------------------------------------
Directory::~Directory()
{
delete this->Internal;
}
-//----------------------------------------------------------------------------
unsigned long Directory::GetNumberOfFiles() const
{
return static_cast<unsigned long>(this->Internal->Files.size());
}
-//----------------------------------------------------------------------------
const char* Directory::GetFile(unsigned long dindex) const
{
if (dindex >= this->Internal->Files.size()) {
@@ -58,13 +53,11 @@ const char* Directory::GetFile(unsigned long dindex) const
return this->Internal->Files[dindex].c_str();
}
-//----------------------------------------------------------------------------
const char* Directory::GetPath() const
{
return this->Internal->Path.c_str();
}
-//----------------------------------------------------------------------------
void Directory::Clear()
{
this->Internal->Path.resize(0);
@@ -116,7 +109,7 @@ bool Directory::Load(const std::string& name)
// Make sure the slashes in the wildcard suffix are consistent with the
// rest of the path
buf = new char[n + 2 + 1];
- if (name.find('\\') != name.npos) {
+ if (name.find('\\') != std::string::npos) {
sprintf(buf, "%s\\*", name.c_str());
} else {
sprintf(buf, "%s/*", name.c_str());
diff --git a/thirdparty/KWSys/adios2sys/DynamicLoader.cxx b/thirdparty/KWSys/adios2sys/DynamicLoader.cxx
index e494db69c8efccab9327290d7c3063b3b4ee074e..1b4596a4efbdbbad9814c6a6da80667591bdd24e 100644
--- a/thirdparty/KWSys/adios2sys/DynamicLoader.cxx
+++ b/thirdparty/KWSys/adios2sys/DynamicLoader.cxx
@@ -26,20 +26,17 @@
// the static methods of DynamicLoader.
#if !KWSYS_SUPPORTS_SHARED_LIBS
-//----------------------------------------------------------------------------
// Implementation for environments without dynamic libs
#include <string.h> // for strerror()
namespace KWSYS_NAMESPACE {
-//----------------------------------------------------------------------------
DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(
const std::string& libname)
{
return 0;
}
-//----------------------------------------------------------------------------
int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
{
if (!lib) {
@@ -49,14 +46,12 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
return 1;
}
-//----------------------------------------------------------------------------
DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
DynamicLoader::LibraryHandle lib, const std::string& sym)
{
return 0;
}
-//----------------------------------------------------------------------------
const char* DynamicLoader::LastError()
{
return "General error";
@@ -65,21 +60,18 @@ const char* DynamicLoader::LastError()
} // namespace KWSYS_NAMESPACE
#elif defined(__hpux)
-//----------------------------------------------------------------------------
// Implementation for HPUX machines
#include <dl.h>
#include <errno.h>
namespace KWSYS_NAMESPACE {
-//----------------------------------------------------------------------------
DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(
const std::string& libname)
{
return shl_load(libname.c_str(), BIND_DEFERRED | DYNAMIC_PATH, 0L);
}
-//----------------------------------------------------------------------------
int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
{
if (!lib) {
@@ -88,7 +80,6 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
return !shl_unload(lib);
}
-//----------------------------------------------------------------------------
DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
DynamicLoader::LibraryHandle lib, const std::string& sym)
{
@@ -132,14 +123,12 @@ const char* DynamicLoader::LastError()
} // namespace KWSYS_NAMESPACE
#elif defined(__APPLE__) && (MAC_OS_X_VERSION_MAX_ALLOWED < 1030)
-//----------------------------------------------------------------------------
// Implementation for Mac OS X 10.2.x and earlier
#include <mach-o/dyld.h>
#include <string.h> // for strlen
namespace KWSYS_NAMESPACE {
-//----------------------------------------------------------------------------
DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(
const std::string& libname)
{
@@ -158,7 +147,6 @@ DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(
return handle;
}
-//----------------------------------------------------------------------------
int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
{
// NSUNLINKMODULE_OPTION_KEEP_MEMORY_MAPPED
@@ -170,7 +158,6 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
return success;
}
-//----------------------------------------------------------------------------
DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
DynamicLoader::LibraryHandle lib, const std::string& sym)
{
@@ -191,7 +178,6 @@ DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
return *reinterpret_cast<DynamicLoader::SymbolPointer*>(&result);
}
-//----------------------------------------------------------------------------
const char* DynamicLoader::LastError()
{
return 0;
@@ -200,13 +186,11 @@ const char* DynamicLoader::LastError()
} // namespace KWSYS_NAMESPACE
#elif defined(_WIN32) && !defined(__CYGWIN__)
-//----------------------------------------------------------------------------
// Implementation for Windows win32 code but not cygwin
#include <windows.h>
namespace KWSYS_NAMESPACE {
-//----------------------------------------------------------------------------
DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(
const std::string& libname)
{
@@ -220,13 +204,11 @@ DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(
return lh;
}
-//----------------------------------------------------------------------------
int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
{
return (int)FreeLibrary(lib);
}
-//----------------------------------------------------------------------------
DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
DynamicLoader::LibraryHandle lib, const std::string& sym)
{
@@ -274,7 +256,6 @@ DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
#endif
}
-//----------------------------------------------------------------------------
const char* DynamicLoader::LastError()
{
LPVOID lpMsgBuf = NULL;
@@ -299,7 +280,6 @@ const char* DynamicLoader::LastError()
} // namespace KWSYS_NAMESPACE
#elif defined(__BEOS__)
-//----------------------------------------------------------------------------
// Implementation for BeOS / Haiku
#include <string.h> // for strerror()
@@ -310,7 +290,6 @@ namespace KWSYS_NAMESPACE {
static image_id last_dynamic_err = B_OK;
-//----------------------------------------------------------------------------
DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(
const std::string& libname)
{
@@ -325,7 +304,6 @@ DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(
return rc + 1;
}
-//----------------------------------------------------------------------------
int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
{
if (!lib) {
@@ -343,7 +321,6 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
return 1;
}
-//----------------------------------------------------------------------------
DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
DynamicLoader::LibraryHandle lib, const std::string& sym)
{
@@ -372,7 +349,6 @@ DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
return result.psym;
}
-//----------------------------------------------------------------------------
const char* DynamicLoader::LastError()
{
const char* retval = strerror(last_dynamic_err);
@@ -383,7 +359,6 @@ const char* DynamicLoader::LastError()
} // namespace KWSYS_NAMESPACE
#elif defined(__MINT__)
-//----------------------------------------------------------------------------
// Implementation for FreeMiNT on Atari
#define _GNU_SOURCE /* for program_invocation_name */
#include <dld.h>
@@ -393,7 +368,6 @@ const char* DynamicLoader::LastError()
namespace KWSYS_NAMESPACE {
-//----------------------------------------------------------------------------
DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(
const std::string& libname)
{
@@ -404,7 +378,6 @@ DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(
return (void*)name;
}
-//----------------------------------------------------------------------------
int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
{
dld_unlink_by_file((char*)lib, 0);
@@ -412,7 +385,6 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
return 0;
}
-//----------------------------------------------------------------------------
DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
DynamicLoader::LibraryHandle lib, const std::string& sym)
{
@@ -426,7 +398,6 @@ DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
return result.psym;
}
-//----------------------------------------------------------------------------
const char* DynamicLoader::LastError()
{
return dld_strerror(dld_errno);
@@ -435,21 +406,18 @@ const char* DynamicLoader::LastError()
} // namespace KWSYS_NAMESPACE
#else
-//----------------------------------------------------------------------------
// Default implementation for *NIX systems (including Mac OS X 10.3 and
// later) which use dlopen
#include <dlfcn.h>
namespace KWSYS_NAMESPACE {
-//----------------------------------------------------------------------------
DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(
const std::string& libname)
{
return dlopen(libname.c_str(), RTLD_LAZY);
}
-//----------------------------------------------------------------------------
int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
{
if (lib) {
@@ -460,7 +428,6 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
return 0;
}
-//----------------------------------------------------------------------------
DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
DynamicLoader::LibraryHandle lib, const std::string& sym)
{
@@ -474,7 +441,6 @@ DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
return result.psym;
}
-//----------------------------------------------------------------------------
const char* DynamicLoader::LastError()
{
return dlerror();
diff --git a/thirdparty/KWSys/adios2sys/EncodingCXX.cxx b/thirdparty/KWSys/adios2sys/EncodingCXX.cxx
index 641c0e6a8e6ad1c5b027431555ec2eab78b4256a..b1e54c958aa1398fce4465baf5e8bdb127b4e557 100644
--- a/thirdparty/KWSys/adios2sys/EncodingCXX.cxx
+++ b/thirdparty/KWSys/adios2sys/EncodingCXX.cxx
@@ -147,11 +147,11 @@ std::wstring Encoding::ToWide(const std::string& str)
wstr += ToWide(str.c_str() + pos);
}
nullPos = str.find('\0', pos);
- if (nullPos != str.npos) {
+ if (nullPos != std::string::npos) {
pos = nullPos + 1;
wstr += wchar_t('\0');
}
- } while (nullPos != str.npos);
+ } while (nullPos != std::string::npos);
#endif
return wstr;
}
@@ -181,11 +181,11 @@ std::string Encoding::ToNarrow(const std::wstring& str)
nstr += ToNarrow(str.c_str() + pos);
}
nullPos = str.find(wchar_t('\0'), pos);
- if (nullPos != str.npos) {
+ if (nullPos != std::string::npos) {
pos = nullPos + 1;
nstr += '\0';
}
- } while (nullPos != str.npos);
+ } while (nullPos != std::string::npos);
#endif
return nstr;
}
diff --git a/thirdparty/KWSys/adios2sys/FStream.hxx.in b/thirdparty/KWSys/adios2sys/FStream.hxx.in
index d4bc6c9c729795d107a1fb7d653b3563ed0dd492..a4c65fe30c86a3fe0041bd0ce0eb4c1c4c20b8b9 100644
--- a/thirdparty/KWSys/adios2sys/FStream.hxx.in
+++ b/thirdparty/KWSys/adios2sys/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::ToWide(s);
+ const std::wstring wstr = Encoding::ToWindowsExtendedPath(s);
return static_cast<basic_filebuf*>(my_base_type::open(wstr.c_str(), mode));
}
#endif
@@ -93,7 +93,7 @@ public:
#if defined(_MSC_VER)
const bool success = buf_->open(file_name, mode) != 0;
#else
- const std::wstring wstr = Encoding::ToWide(file_name);
+ const std::wstring wstr = Encoding::ToWindowsExtendedPath(file_name);
bool success = false;
std::wstring cmode = getcmode(mode);
file_ = _wfopen(wstr.c_str(), cmode.c_str());
diff --git a/thirdparty/KWSys/adios2sys/Glob.cxx b/thirdparty/KWSys/adios2sys/Glob.cxx
index fa8760d6654e30edcfff34b62337eb406f1369f7..d2f0b8516664c7edb9a4bfa62c0ef71cdf06017a 100644
--- a/thirdparty/KWSys/adios2sys/Glob.cxx
+++ b/thirdparty/KWSys/adios2sys/Glob.cxx
@@ -37,7 +37,6 @@ namespace KWSYS_NAMESPACE {
#define KWSYS_GLOB_SUPPORT_NETWORK_PATHS
#endif
-//----------------------------------------------------------------------------
class GlobInternals
{
public:
@@ -45,7 +44,6 @@ public:
std::vector<kwsys::RegularExpression> Expressions;
};
-//----------------------------------------------------------------------------
Glob::Glob()
{
this->Internals = new GlobInternals;
@@ -62,19 +60,16 @@ Glob::Glob()
this->RecurseListDirs = false;
}
-//----------------------------------------------------------------------------
Glob::~Glob()
{
delete this->Internals;
}
-//----------------------------------------------------------------------------
std::vector<std::string>& Glob::GetFiles()
{
return this->Internals->Files;
}
-//----------------------------------------------------------------------------
std::string Glob::PatternToRegex(const std::string& pattern,
bool require_whole_string, bool preserve_case)
{
@@ -183,7 +178,6 @@ std::string Glob::PatternToRegex(const std::string& pattern,
return regex;
}
-//----------------------------------------------------------------------------
bool Glob::RecurseDirectory(std::string::size_type start,
const std::string& dir, GlobMessages* messages)
{
@@ -277,7 +271,6 @@ bool Glob::RecurseDirectory(std::string::size_type start,
return true;
}
-//----------------------------------------------------------------------------
void Glob::ProcessDirectory(std::string::size_type start,
const std::string& dir, GlobMessages* messages)
{
@@ -337,7 +330,6 @@ void Glob::ProcessDirectory(std::string::size_type start,
}
}
-//----------------------------------------------------------------------------
bool Glob::FindFiles(const std::string& inexpr, GlobMessages* messages)
{
std::string cexpr;
@@ -420,14 +412,12 @@ bool Glob::FindFiles(const std::string& inexpr, GlobMessages* messages)
return true;
}
-//----------------------------------------------------------------------------
void Glob::AddExpression(const std::string& expr)
{
this->Internals->Expressions.push_back(
kwsys::RegularExpression(this->PatternToRegex(expr)));
}
-//----------------------------------------------------------------------------
void Glob::SetRelative(const char* dir)
{
if (!dir) {
@@ -437,7 +427,6 @@ void Glob::SetRelative(const char* dir)
this->Relative = dir;
}
-//----------------------------------------------------------------------------
const char* Glob::GetRelative()
{
if (this->Relative.empty()) {
@@ -446,7 +435,6 @@ const char* Glob::GetRelative()
return this->Relative.c_str();
}
-//----------------------------------------------------------------------------
void Glob::AddFile(std::vector<std::string>& files, const std::string& file)
{
if (!this->Relative.empty()) {
diff --git a/thirdparty/KWSys/adios2sys/MD5.c b/thirdparty/KWSys/adios2sys/MD5.c
index 1310c6474fc6e9b96303510cd1b27aaf41ea8828..3188fb67acd19cc679b58392b20e85be28885237 100644
--- a/thirdparty/KWSys/adios2sys/MD5.c
+++ b/thirdparty/KWSys/adios2sys/MD5.c
@@ -13,8 +13,6 @@
#include <stdlib.h> /* malloc, free */
#include <string.h> /* memcpy, strlen */
-/*--------------------------------------------------------------------------*/
-
/* This MD5 implementation has been taken from a third party. Slight
modifications to the arrangement of the code have been made to put
it in a single source file instead of a separate header and
@@ -425,14 +423,12 @@ static void md5_finish(md5_state_t* pms, md5_byte_t digest[16])
#pragma clang diagnostic pop
#endif
-/*--------------------------------------------------------------------------*/
/* Wrap up the MD5 state in our opaque structure. */
struct kwsysMD5_s
{
md5_state_t md5_state;
};
-/*--------------------------------------------------------------------------*/
kwsysMD5* kwsysMD5_New(void)
{
/* Allocate a process control structure. */
@@ -443,7 +439,6 @@ kwsysMD5* kwsysMD5_New(void)
return md5;
}
-/*--------------------------------------------------------------------------*/
void kwsysMD5_Delete(kwsysMD5* md5)
{
/* Make sure we have an instance. */
@@ -455,13 +450,11 @@ void kwsysMD5_Delete(kwsysMD5* md5)
free(md5);
}
-/*--------------------------------------------------------------------------*/
void kwsysMD5_Initialize(kwsysMD5* md5)
{
md5_init(&md5->md5_state);
}
-/*--------------------------------------------------------------------------*/
void kwsysMD5_Append(kwsysMD5* md5, unsigned char const* data, int length)
{
size_t dlen;
@@ -473,13 +466,11 @@ void kwsysMD5_Append(kwsysMD5* md5, unsigned char const* data, int length)
md5_append(&md5->md5_state, (md5_byte_t const*)data, dlen);
}
-/*--------------------------------------------------------------------------*/
void kwsysMD5_Finalize(kwsysMD5* md5, unsigned char digest[16])
{
md5_finish(&md5->md5_state, (md5_byte_t*)digest);
}
-/*--------------------------------------------------------------------------*/
void kwsysMD5_FinalizeHex(kwsysMD5* md5, char buffer[32])
{
unsigned char digest[16];
@@ -487,7 +478,6 @@ void kwsysMD5_FinalizeHex(kwsysMD5* md5, char buffer[32])
kwsysMD5_DigestToHex(digest, buffer);
}
-/*--------------------------------------------------------------------------*/
void kwsysMD5_DigestToHex(unsigned char const digest[16], char buffer[32])
{
/* Map from 4-bit index to hexadecimal representation. */
diff --git a/thirdparty/KWSys/adios2sys/Process.h.in b/thirdparty/KWSys/adios2sys/Process.h.in
index b8349a66a148c0a6172560ec659f0c74450420d1..237001c604d2aaa31a2942ae7756b47d7e3a273c 100644
--- a/thirdparty/KWSys/adios2sys/Process.h.in
+++ b/thirdparty/KWSys/adios2sys/Process.h.in
@@ -42,7 +42,6 @@
#define kwsysProcess_State_Expired kwsys_ns(Process_State_Expired)
#define kwsysProcess_State_Killed kwsys_ns(Process_State_Killed)
#define kwsysProcess_State_Disowned kwsys_ns(Process_State_Disowned)
-#define kwsysProcess_GetState kwsys_ns(Process_GetState)
#define kwsysProcess_State_e kwsys_ns(Process_State_e)
#define kwsysProcess_Exception_None kwsys_ns(Process_Exception_None)
#define kwsysProcess_Exception_Fault kwsys_ns(Process_Exception_Fault)
@@ -50,12 +49,21 @@
#define kwsysProcess_Exception_Interrupt kwsys_ns(Process_Exception_Interrupt)
#define kwsysProcess_Exception_Numerical kwsys_ns(Process_Exception_Numerical)
#define kwsysProcess_Exception_Other kwsys_ns(Process_Exception_Other)
-#define kwsysProcess_GetExitException kwsys_ns(Process_GetExitException)
#define kwsysProcess_Exception_e kwsys_ns(Process_Exception_e)
+#define kwsysProcess_GetState kwsys_ns(Process_GetState)
+#define kwsysProcess_GetExitException kwsys_ns(Process_GetExitException)
#define kwsysProcess_GetExitCode kwsys_ns(Process_GetExitCode)
#define kwsysProcess_GetExitValue kwsys_ns(Process_GetExitValue)
#define kwsysProcess_GetErrorString kwsys_ns(Process_GetErrorString)
#define kwsysProcess_GetExceptionString kwsys_ns(Process_GetExceptionString)
+#define kwsysProcess_GetStateByIndex kwsys_ns(Process_GetStateByIndex)
+#define kwsysProcess_GetExitExceptionByIndex \
+ kwsys_ns(Process_GetExitExceptionByIndex)
+#define kwsysProcess_GetExitCodeByIndex kwsys_ns(Process_GetExitCodeByIndex)
+#define kwsysProcess_GetExitValueByIndex kwsys_ns(Process_GetExitValueByIndex)
+#define kwsysProcess_GetExceptionStringByIndex \
+ kwsys_ns(Process_GetExceptionStringByIndex)
+#define kwsysProcess_GetExitCodeByIndex kwsys_ns(Process_GetExitCodeByIndex)
#define kwsysProcess_Execute kwsys_ns(Process_Execute)
#define kwsysProcess_Disown kwsys_ns(Process_Disown)
#define kwsysProcess_WaitForData kwsys_ns(Process_WaitForData)
@@ -297,6 +305,67 @@ kwsysEXPORT const char* kwsysProcess_GetErrorString(kwsysProcess* cp);
*/
kwsysEXPORT const char* kwsysProcess_GetExceptionString(kwsysProcess* cp);
+/**
+* Get the current state of the Process instance. Possible states are:
+*
+* kwsysProcess_StateByIndex_Starting = Execute has not yet been called.
+* kwsysProcess_StateByIndex_Exception = Child process exited abnormally.
+* kwsysProcess_StateByIndex_Exited = Child process exited normally.
+* kwsysProcess_StateByIndex_Error = Error getting the child return code.
+*/
+kwsysEXPORT int kwsysProcess_GetStateByIndex(kwsysProcess* cp, int idx);
+enum kwsysProcess_StateByIndex_e
+{
+ kwsysProcess_StateByIndex_Starting = kwsysProcess_State_Starting,
+ kwsysProcess_StateByIndex_Exception = kwsysProcess_State_Exception,
+ kwsysProcess_StateByIndex_Exited = kwsysProcess_State_Exited,
+ kwsysProcess_StateByIndex_Error = kwsysProcess_State_Error
+};
+
+/**
+* When GetState returns "Exception", this method returns a
+* platform-independent description of the exceptional behavior that
+* caused the child to terminate abnormally. Possible exceptions are:
+*
+* kwsysProcess_Exception_None = No exceptional behavior occurred.
+* kwsysProcess_Exception_Fault = Child crashed with a memory fault.
+* kwsysProcess_Exception_Illegal = Child crashed with an illegal
+* instruction.
+* kwsysProcess_Exception_Interrupt = Child was interrupted by user
+* (Cntl-C/Break).
+* kwsysProcess_Exception_Numerical = Child crashed with a numerical
+* exception.
+* kwsysProcess_Exception_Other = Child terminated for another reason.
+*/
+kwsysEXPORT int kwsysProcess_GetExitExceptionByIndex(kwsysProcess* cp,
+ int idx);
+
+/**
+* When GetState returns "Exited" or "Exception", this method returns
+* the platform-specific raw exit code of the process. UNIX platforms
+* should use WIFEXITED/WEXITSTATUS and WIFSIGNALED/WTERMSIG to access
+* this value. Windows users should compare the value to the various
+* EXCEPTION_* values.
+*
+* If GetState returns "Exited", use GetExitValue to get the
+* platform-independent child return value.
+*/
+kwsysEXPORT int kwsysProcess_GetExitCodeByIndex(kwsysProcess* cp, int idx);
+
+/**
+* When GetState returns "Exited", this method returns the child's
+* platform-independent exit code (such as the value returned by the
+* child's main).
+*/
+kwsysEXPORT int kwsysProcess_GetExitValueByIndex(kwsysProcess* cp, int idx);
+
+/**
+* When GetState returns "Exception", this method returns a string
+* describing the problem. Otherwise, it returns NULL.
+*/
+kwsysEXPORT const char* kwsysProcess_GetExceptionStringByIndex(
+ kwsysProcess* cp, int idx);
+
/**
* Start executing the child process.
*/
diff --git a/thirdparty/KWSys/adios2sys/ProcessUNIX.c b/thirdparty/KWSys/adios2sys/ProcessUNIX.c
index ed0909543b4f3679ed7491cdb5b0fb9498745625..9ebcfce592759922ce8fdb5cc02882ea2aae5e10 100644
--- a/thirdparty/KWSys/adios2sys/ProcessUNIX.c
+++ b/thirdparty/KWSys/adios2sys/ProcessUNIX.c
@@ -140,7 +140,6 @@ typedef struct kwsysProcessCreateInformation_s
int ErrorPipe[2];
} kwsysProcessCreateInformation;
-/*--------------------------------------------------------------------------*/
static void kwsysProcessVolatileFree(volatile void* p);
static int kwsysProcessInitialize(kwsysProcess* cp);
static void kwsysProcessCleanup(kwsysProcess* cp, int error);
@@ -166,7 +165,8 @@ static kwsysProcessTime kwsysProcessTimeAdd(kwsysProcessTime in1,
kwsysProcessTime in2);
static kwsysProcessTime kwsysProcessTimeSubtract(kwsysProcessTime in1,
kwsysProcessTime in2);
-static void kwsysProcessSetExitException(kwsysProcess* cp, int sig);
+static void kwsysProcessSetExitExceptionByIndex(kwsysProcess* cp, int sig,
+ int idx);
static void kwsysProcessChildErrorExit(int errorPipe);
static void kwsysProcessRestoreDefaultSignalHandlers(void);
static pid_t kwsysProcessFork(kwsysProcess* cp,
@@ -184,7 +184,26 @@ static void kwsysProcessesSignalHandler(int signum, siginfo_t* info,
static void kwsysProcessesSignalHandler(int signum);
#endif
-/*--------------------------------------------------------------------------*/
+/* A structure containing results data for each process. */
+typedef struct kwsysProcessResults_s kwsysProcessResults;
+struct kwsysProcessResults_s
+{
+ /* The status of the child process. */
+ int State;
+
+ /* The exceptional behavior that terminated the process, if any. */
+ int ExitException;
+
+ /* The process exit code. */
+ int ExitCode;
+
+ /* The process return code, if any. */
+ int ExitValue;
+
+ /* Description for the ExitException. */
+ char ExitExceptionString[KWSYSPE_PIPE_BUFFER_SIZE + 1];
+};
+
/* Structure containing data used to implement the child's execution. */
struct kwsysProcess_s
{
@@ -255,28 +274,18 @@ struct kwsysProcess_s
/* The number of children still executing. */
int CommandsLeft;
- /* The current status of the child process. Must be atomic because
+ /* The status of the process structure. Must be atomic because
the signal handler checks this to avoid a race. */
volatile sig_atomic_t State;
- /* The exceptional behavior that terminated the child process, if
- * any. */
- int ExitException;
-
- /* The exit code of the child process. */
- int ExitCode;
-
- /* The exit value of the child process, if any. */
- int ExitValue;
-
/* Whether the process was killed. */
volatile sig_atomic_t Killed;
/* Buffer for error message in case of failure. */
char ErrorMessage[KWSYSPE_PIPE_BUFFER_SIZE + 1];
- /* Description for the ExitException. */
- char ExitExceptionString[KWSYSPE_PIPE_BUFFER_SIZE + 1];
+ /* process results. */
+ kwsysProcessResults* ProcessResults;
/* The exit codes of each child process in the pipeline. */
int* CommandExitCodes;
@@ -301,7 +310,6 @@ struct kwsysProcess_s
char* RealWorkingDirectory;
};
-/*--------------------------------------------------------------------------*/
kwsysProcess* kwsysProcess_New(void)
{
/* Allocate a process control structure. */
@@ -328,7 +336,6 @@ kwsysProcess* kwsysProcess_New(void)
return cp;
}
-/*--------------------------------------------------------------------------*/
void kwsysProcess_Delete(kwsysProcess* cp)
{
/* Make sure we have an instance. */
@@ -354,10 +361,10 @@ void kwsysProcess_Delete(kwsysProcess* cp)
if (cp->CommandExitCodes) {
free(cp->CommandExitCodes);
}
+ free(cp->ProcessResults);
free(cp);
}
-/*--------------------------------------------------------------------------*/
int kwsysProcess_SetCommand(kwsysProcess* cp, char const* const* command)
{
int i;
@@ -382,7 +389,6 @@ int kwsysProcess_SetCommand(kwsysProcess* cp, char const* const* command)
return 1;
}
-/*--------------------------------------------------------------------------*/
int kwsysProcess_AddCommand(kwsysProcess* cp, char const* const* command)
{
int newNumberOfCommands;
@@ -462,7 +468,6 @@ int kwsysProcess_AddCommand(kwsysProcess* cp, char const* const* command)
return 1;
}
-/*--------------------------------------------------------------------------*/
void kwsysProcess_SetTimeout(kwsysProcess* cp, double timeout)
{
if (!cp) {
@@ -476,7 +481,6 @@ void kwsysProcess_SetTimeout(kwsysProcess* cp, double timeout)
cp->TimeoutTime.tv_sec = -1;
}
-/*--------------------------------------------------------------------------*/
int kwsysProcess_SetWorkingDirectory(kwsysProcess* cp, const char* dir)
{
if (!cp) {
@@ -502,7 +506,6 @@ int kwsysProcess_SetWorkingDirectory(kwsysProcess* cp, const char* dir)
return 1;
}
-/*--------------------------------------------------------------------------*/
int kwsysProcess_SetPipeFile(kwsysProcess* cp, int prPipe, const char* file)
{
char** pfile;
@@ -543,7 +546,6 @@ int kwsysProcess_SetPipeFile(kwsysProcess* cp, int prPipe, const char* file)
return 1;
}
-/*--------------------------------------------------------------------------*/
void kwsysProcess_SetPipeShared(kwsysProcess* cp, int prPipe, int shared)
{
if (!cp) {
@@ -572,7 +574,6 @@ void kwsysProcess_SetPipeShared(kwsysProcess* cp, int prPipe, int shared)
}
}
-/*--------------------------------------------------------------------------*/
void kwsysProcess_SetPipeNative(kwsysProcess* cp, int prPipe, int p[2])
{
int* pPipeNative = 0;
@@ -612,7 +613,6 @@ void kwsysProcess_SetPipeNative(kwsysProcess* cp, int prPipe, int p[2])
}
}
-/*--------------------------------------------------------------------------*/
int kwsysProcess_GetOption(kwsysProcess* cp, int optionId)
{
if (!cp) {
@@ -633,7 +633,6 @@ int kwsysProcess_GetOption(kwsysProcess* cp, int optionId)
}
}
-/*--------------------------------------------------------------------------*/
void kwsysProcess_SetOption(kwsysProcess* cp, int optionId, int value)
{
if (!cp) {
@@ -658,31 +657,32 @@ void kwsysProcess_SetOption(kwsysProcess* cp, int optionId, int value)
}
}
-/*--------------------------------------------------------------------------*/
int kwsysProcess_GetState(kwsysProcess* cp)
{
return cp ? cp->State : kwsysProcess_State_Error;
}
-/*--------------------------------------------------------------------------*/
int kwsysProcess_GetExitException(kwsysProcess* cp)
{
- return cp ? cp->ExitException : kwsysProcess_Exception_Other;
+ return (cp && cp->ProcessResults && (cp->NumberOfCommands > 0))
+ ? cp->ProcessResults[cp->NumberOfCommands - 1].ExitException
+ : kwsysProcess_Exception_Other;
}
-/*--------------------------------------------------------------------------*/
int kwsysProcess_GetExitCode(kwsysProcess* cp)
{
- return cp ? cp->ExitCode : 0;
+ return (cp && cp->ProcessResults && (cp->NumberOfCommands > 0))
+ ? cp->ProcessResults[cp->NumberOfCommands - 1].ExitCode
+ : 0;
}
-/*--------------------------------------------------------------------------*/
int kwsysProcess_GetExitValue(kwsysProcess* cp)
{
- return cp ? cp->ExitValue : -1;
+ return (cp && cp->ProcessResults && (cp->NumberOfCommands > 0))
+ ? cp->ProcessResults[cp->NumberOfCommands - 1].ExitValue
+ : -1;
}
-/*--------------------------------------------------------------------------*/
const char* kwsysProcess_GetErrorString(kwsysProcess* cp)
{
if (!cp) {
@@ -693,18 +693,58 @@ const char* kwsysProcess_GetErrorString(kwsysProcess* cp)
return "Success";
}
-/*--------------------------------------------------------------------------*/
const char* kwsysProcess_GetExceptionString(kwsysProcess* cp)
{
- if (!cp) {
+ if (!(cp && cp->ProcessResults && (cp->NumberOfCommands > 0))) {
return "GetExceptionString called with NULL process management structure";
} else if (cp->State == kwsysProcess_State_Exception) {
- return cp->ExitExceptionString;
+ return cp->ProcessResults[cp->NumberOfCommands - 1].ExitExceptionString;
+ }
+ return "No exception";
+}
+
+/* the index should be in array bound. */
+#define KWSYSPE_IDX_CHK(RET) \
+ if (!cp || idx >= cp->NumberOfCommands || idx < 0) { \
+ return RET; \
+ }
+
+int kwsysProcess_GetStateByIndex(kwsysProcess* cp, int idx)
+{
+ KWSYSPE_IDX_CHK(kwsysProcess_State_Error)
+ return cp->ProcessResults[idx].State;
+}
+
+int kwsysProcess_GetExitExceptionByIndex(kwsysProcess* cp, int idx)
+{
+ KWSYSPE_IDX_CHK(kwsysProcess_Exception_Other)
+ return cp->ProcessResults[idx].ExitException;
+}
+
+int kwsysProcess_GetExitValueByIndex(kwsysProcess* cp, int idx)
+{
+ KWSYSPE_IDX_CHK(-1)
+ return cp->ProcessResults[idx].ExitValue;
+}
+
+int kwsysProcess_GetExitCodeByIndex(kwsysProcess* cp, int idx)
+{
+ KWSYSPE_IDX_CHK(-1)
+ return cp->CommandExitCodes[idx];
+}
+
+const char* kwsysProcess_GetExceptionStringByIndex(kwsysProcess* cp, int idx)
+{
+ KWSYSPE_IDX_CHK("GetExceptionString called with NULL process management "
+ "structure or index out of bound")
+ if (cp->ProcessResults[idx].State == kwsysProcess_StateByIndex_Exception) {
+ return cp->ProcessResults[idx].ExitExceptionString;
}
return "No exception";
}
-/*--------------------------------------------------------------------------*/
+#undef KWSYSPE_IDX_CHK
+
void kwsysProcess_Execute(kwsysProcess* cp)
{
int i;
@@ -990,7 +1030,6 @@ void kwsysProcess_Execute(kwsysProcess* cp)
cp->Detached = cp->OptionDetach;
}
-/*--------------------------------------------------------------------------*/
kwsysEXPORT void kwsysProcess_Disown(kwsysProcess* cp)
{
/* Make sure a detached child process is running. */
@@ -1009,7 +1048,6 @@ kwsysEXPORT void kwsysProcess_Disown(kwsysProcess* cp)
cp->State = kwsysProcess_State_Disowned;
}
-/*--------------------------------------------------------------------------*/
typedef struct kwsysProcessWaitData_s
{
int Expired;
@@ -1021,7 +1059,6 @@ typedef struct kwsysProcessWaitData_s
static int kwsysProcessWaitForPipe(kwsysProcess* cp, char** data, int* length,
kwsysProcessWaitData* wd);
-/*--------------------------------------------------------------------------*/
int kwsysProcess_WaitForData(kwsysProcess* cp, char** data, int* length,
double* userTimeout)
{
@@ -1083,7 +1120,6 @@ int kwsysProcess_WaitForData(kwsysProcess* cp, char** data, int* length,
}
}
-/*--------------------------------------------------------------------------*/
static int kwsysProcessWaitForPipe(kwsysProcess* cp, char** data, int* length,
kwsysProcessWaitData* wd)
{
@@ -1285,10 +1321,8 @@ static int kwsysProcessWaitForPipe(kwsysProcess* cp, char** data, int* length,
#endif
}
-/*--------------------------------------------------------------------------*/
int kwsysProcess_WaitForExit(kwsysProcess* cp, double* userTimeout)
{
- int status = 0;
int prPipe = 0;
/* Make sure we are executing a process. */
@@ -1319,10 +1353,6 @@ int kwsysProcess_WaitForExit(kwsysProcess* cp, double* userTimeout)
cp->State = kwsysProcess_State_Error;
return 1;
}
-
- /* Use the status of the last process in the pipeline. */
- status = cp->CommandExitCodes[cp->NumberOfCommands - 1];
-
/* Determine the outcome. */
if (cp->Killed) {
/* We killed the child. */
@@ -1330,29 +1360,36 @@ int kwsysProcess_WaitForExit(kwsysProcess* cp, double* userTimeout)
} else if (cp->TimeoutExpired) {
/* The timeout expired. */
cp->State = kwsysProcess_State_Expired;
- } else if (WIFEXITED(status)) {
- /* The child exited normally. */
- cp->State = kwsysProcess_State_Exited;
- cp->ExitException = kwsysProcess_Exception_None;
- cp->ExitCode = status;
- cp->ExitValue = (int)WEXITSTATUS(status);
- } else if (WIFSIGNALED(status)) {
- /* The child received an unhandled signal. */
- cp->State = kwsysProcess_State_Exception;
- cp->ExitCode = status;
- kwsysProcessSetExitException(cp, (int)WTERMSIG(status));
} else {
- /* Error getting the child return code. */
- strcpy(cp->ErrorMessage, "Error getting child return code.");
- cp->State = kwsysProcess_State_Error;
+ /* The children exited. Report the outcome of the child processes. */
+ for (prPipe = 0; prPipe < cp->NumberOfCommands; ++prPipe) {
+ cp->ProcessResults[prPipe].ExitCode = cp->CommandExitCodes[prPipe];
+ if (WIFEXITED(cp->ProcessResults[prPipe].ExitCode)) {
+ /* The child exited normally. */
+ cp->ProcessResults[prPipe].State = kwsysProcess_StateByIndex_Exited;
+ cp->ProcessResults[prPipe].ExitException = kwsysProcess_Exception_None;
+ cp->ProcessResults[prPipe].ExitValue =
+ (int)WEXITSTATUS(cp->ProcessResults[prPipe].ExitCode);
+ } else if (WIFSIGNALED(cp->ProcessResults[prPipe].ExitCode)) {
+ /* The child received an unhandled signal. */
+ cp->ProcessResults[prPipe].State = kwsysProcess_State_Exception;
+ kwsysProcessSetExitExceptionByIndex(
+ cp, (int)WTERMSIG(cp->ProcessResults[prPipe].ExitCode), prPipe);
+ } else {
+ /* Error getting the child return code. */
+ strcpy(cp->ProcessResults[prPipe].ExitExceptionString,
+ "Error getting child return code.");
+ cp->ProcessResults[prPipe].State = kwsysProcess_StateByIndex_Error;
+ }
+ }
+ /* support legacy state status value */
+ cp->State = cp->ProcessResults[cp->NumberOfCommands - 1].State;
}
-
/* Normal cleanup. */
kwsysProcessCleanup(cp, 0);
return 1;
}
-/*--------------------------------------------------------------------------*/
void kwsysProcess_Interrupt(kwsysProcess* cp)
{
int i;
@@ -1384,7 +1421,6 @@ void kwsysProcess_Interrupt(kwsysProcess* cp)
}
}
-/*--------------------------------------------------------------------------*/
void kwsysProcess_Kill(kwsysProcess* cp)
{
int i;
@@ -1431,7 +1467,6 @@ void kwsysProcess_Kill(kwsysProcess* cp)
cp->CommandsLeft = 0;
}
-/*--------------------------------------------------------------------------*/
/* Call the free() function with a pointer to volatile without causing
compiler warnings. */
static void kwsysProcessVolatileFree(volatile void* p)
@@ -1448,7 +1483,6 @@ static void kwsysProcessVolatileFree(volatile void* p)
#endif
}
-/*--------------------------------------------------------------------------*/
/* Initialize a process control structure for kwsysProcess_Execute. */
static int kwsysProcessInitialize(kwsysProcess* cp)
{
@@ -1474,11 +1508,7 @@ static int kwsysProcessInitialize(kwsysProcess* cp)
#endif
cp->State = kwsysProcess_State_Starting;
cp->Killed = 0;
- cp->ExitException = kwsysProcess_Exception_None;
- cp->ExitCode = 1;
- cp->ExitValue = 1;
cp->ErrorMessage[0] = 0;
- strcpy(cp->ExitExceptionString, "No exception");
oldForkPIDs = cp->ForkPIDs;
cp->ForkPIDs = (volatile pid_t*)malloc(sizeof(volatile pid_t) *
@@ -1504,6 +1534,23 @@ static int kwsysProcessInitialize(kwsysProcess* cp)
memset(cp->CommandExitCodes, 0,
sizeof(int) * (size_t)(cp->NumberOfCommands));
+ /* Allocate process result information for each process. */
+ free(cp->ProcessResults);
+ cp->ProcessResults = (kwsysProcessResults*)malloc(
+ sizeof(kwsysProcessResults) * (size_t)(cp->NumberOfCommands));
+ if (!cp->ProcessResults) {
+ return 0;
+ }
+ memset(cp->ProcessResults, 0,
+ sizeof(kwsysProcessResults) * (size_t)(cp->NumberOfCommands));
+ for (i = 0; i < cp->NumberOfCommands; i++) {
+ cp->ProcessResults[i].ExitException = kwsysProcess_Exception_None;
+ cp->ProcessResults[i].State = kwsysProcess_StateByIndex_Starting;
+ cp->ProcessResults[i].ExitCode = 1;
+ cp->ProcessResults[i].ExitValue = 1;
+ strcpy(cp->ProcessResults[i].ExitExceptionString, "No exception");
+ }
+
/* Allocate memory to save the real working directory. */
if (cp->WorkingDirectory) {
#if defined(MAXPATHLEN)
@@ -1523,7 +1570,6 @@ static int kwsysProcessInitialize(kwsysProcess* cp)
return 1;
}
-/*--------------------------------------------------------------------------*/
/* Free all resources used by the given kwsysProcess instance that were
allocated by kwsysProcess_Execute. */
static void kwsysProcessCleanup(kwsysProcess* cp, int error)
@@ -1590,7 +1636,6 @@ static void kwsysProcessCleanup(kwsysProcess* cp, int error)
}
}
-/*--------------------------------------------------------------------------*/
/* Close the given file descriptor if it is open. Reset its value to -1. */
static void kwsysProcessCleanupDescriptor(int* pfd)
{
@@ -1603,7 +1648,6 @@ static void kwsysProcessCleanupDescriptor(int* pfd)
}
}
-/*--------------------------------------------------------------------------*/
static void kwsysProcessClosePipes(kwsysProcess* cp)
{
int i;
@@ -1636,7 +1680,6 @@ static void kwsysProcessClosePipes(kwsysProcess* cp)
}
}
-/*--------------------------------------------------------------------------*/
static int kwsysProcessSetNonBlocking(int fd)
{
int flags = fcntl(fd, F_GETFL);
@@ -1646,12 +1689,10 @@ static int kwsysProcessSetNonBlocking(int fd)
return flags >= 0;
}
-/*--------------------------------------------------------------------------*/
#if defined(__VMS)
int decc$set_child_standard_streams(int fd1, int fd2, int fd3);
#endif
-/*--------------------------------------------------------------------------*/
static int kwsysProcessCreate(kwsysProcess* cp, int prIndex,
kwsysProcessCreateInformation* si)
{
@@ -1831,7 +1872,6 @@ static int kwsysProcessCreate(kwsysProcess* cp, int prIndex,
return 1;
}
-/*--------------------------------------------------------------------------*/
static void kwsysProcessDestroy(kwsysProcess* cp)
{
/* A child process has terminated. Reap it if it is one handled by
@@ -1880,7 +1920,6 @@ static void kwsysProcessDestroy(kwsysProcess* cp)
sigprocmask(SIG_SETMASK, &old_mask, 0);
}
-/*--------------------------------------------------------------------------*/
static int kwsysProcessSetupOutputPipeFile(int* p, const char* name)
{
int fout;
@@ -1906,7 +1945,6 @@ static int kwsysProcessSetupOutputPipeFile(int* p, const char* name)
return 1;
}
-/*--------------------------------------------------------------------------*/
static int kwsysProcessSetupOutputPipeNative(int* p, int des[2])
{
/* Close the existing descriptor. */
@@ -1925,7 +1963,6 @@ static int kwsysProcessSetupOutputPipeNative(int* p, int des[2])
return 1;
}
-/*--------------------------------------------------------------------------*/
/* 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,
@@ -1957,7 +1994,6 @@ static int kwsysProcessGetTimeoutTime(kwsysProcess* cp, double* userTimeout,
return 0;
}
-/*--------------------------------------------------------------------------*/
/* 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,
@@ -1992,7 +2028,6 @@ static int kwsysProcessGetTimeoutLeft(kwsysProcessTime* timeoutTime,
}
}
-/*--------------------------------------------------------------------------*/
static kwsysProcessTime kwsysProcessTimeGetCurrent(void)
{
kwsysProcessTime current;
@@ -2003,13 +2038,11 @@ static kwsysProcessTime kwsysProcessTimeGetCurrent(void)
return current;
}
-/*--------------------------------------------------------------------------*/
static double kwsysProcessTimeToDouble(kwsysProcessTime t)
{
return (double)t.tv_sec + (double)(t.tv_usec) * 0.000001;
}
-/*--------------------------------------------------------------------------*/
static kwsysProcessTime kwsysProcessTimeFromDouble(double d)
{
kwsysProcessTime t;
@@ -2018,14 +2051,12 @@ static kwsysProcessTime kwsysProcessTimeFromDouble(double d)
return t;
}
-/*--------------------------------------------------------------------------*/
static int kwsysProcessTimeLess(kwsysProcessTime in1, kwsysProcessTime in2)
{
return ((in1.tv_sec < in2.tv_sec) ||
((in1.tv_sec == in2.tv_sec) && (in1.tv_usec < in2.tv_usec)));
}
-/*--------------------------------------------------------------------------*/
static kwsysProcessTime kwsysProcessTimeAdd(kwsysProcessTime in1,
kwsysProcessTime in2)
{
@@ -2039,7 +2070,6 @@ static kwsysProcessTime kwsysProcessTimeAdd(kwsysProcessTime in1,
return out;
}
-/*--------------------------------------------------------------------------*/
static kwsysProcessTime kwsysProcessTimeSubtract(kwsysProcessTime in1,
kwsysProcessTime in2)
{
@@ -2053,11 +2083,11 @@ static kwsysProcessTime kwsysProcessTimeSubtract(kwsysProcessTime in1,
return out;
}
-/*--------------------------------------------------------------------------*/
#define KWSYSPE_CASE(type, str) \
- cp->ExitException = kwsysProcess_Exception_##type; \
- strcpy(cp->ExitExceptionString, str)
-static void kwsysProcessSetExitException(kwsysProcess* cp, int sig)
+ cp->ProcessResults[idx].ExitException = kwsysProcess_Exception_##type; \
+ strcpy(cp->ProcessResults[idx].ExitExceptionString, str)
+static void kwsysProcessSetExitExceptionByIndex(kwsysProcess* cp, int sig,
+ int idx)
{
switch (sig) {
#ifdef SIGSEGV
@@ -2243,14 +2273,13 @@ static void kwsysProcessSetExitException(kwsysProcess* cp, int sig)
#endif
#endif
default:
- cp->ExitException = kwsysProcess_Exception_Other;
- sprintf(cp->ExitExceptionString, "Signal %d", sig);
+ cp->ProcessResults[idx].ExitException = kwsysProcess_Exception_Other;
+ sprintf(cp->ProcessResults[idx].ExitExceptionString, "Signal %d", sig);
break;
}
}
#undef KWSYSPE_CASE
-/*--------------------------------------------------------------------------*/
/* When the child process encounters an error before its program is
invoked, this is called to report the error to the parent and
exit. */
@@ -2269,7 +2298,6 @@ static void kwsysProcessChildErrorExit(int errorPipe)
_exit(1);
}
-/*--------------------------------------------------------------------------*/
/* Restores all signal handlers to their default values. */
static void kwsysProcessRestoreDefaultSignalHandlers(void)
{
@@ -2377,13 +2405,11 @@ static void kwsysProcessRestoreDefaultSignalHandlers(void)
#endif
}
-/*--------------------------------------------------------------------------*/
static void kwsysProcessExit(void)
{
_exit(0);
}
-/*--------------------------------------------------------------------------*/
#if !defined(__VMS)
static pid_t kwsysProcessFork(kwsysProcess* cp,
kwsysProcessCreateInformation* si)
@@ -2433,7 +2459,6 @@ static pid_t kwsysProcessFork(kwsysProcess* cp,
}
#endif
-/*--------------------------------------------------------------------------*/
/* We try to obtain process information by invoking the ps command.
Here we define the command to call on each platform and the
corresponding parsing format string. The parsing format should
@@ -2457,7 +2482,6 @@ static pid_t kwsysProcessFork(kwsysProcess* cp,
#define KWSYSPE_PS_FORMAT "%d %d %*[^\n]\n"
#endif
-/*--------------------------------------------------------------------------*/
static void kwsysProcessKill(pid_t process_id)
{
#if defined(__linux__) || defined(__CYGWIN__)
@@ -2561,7 +2585,6 @@ static void kwsysProcessKill(pid_t process_id)
#endif
}
-/*--------------------------------------------------------------------------*/
#if defined(__VMS)
int decc$feature_get_index(const char* name);
int decc$feature_set_value(int index, int mode, int value);
@@ -2574,7 +2597,6 @@ static int kwsysProcessSetVMSFeature(const char* name, int value)
}
#endif
-/*--------------------------------------------------------------------------*/
/* Global set of executing processes for use by the signal handler.
This global instance will be zero-initialized by the compiler. */
typedef struct kwsysProcessInstances_s
@@ -2590,7 +2612,6 @@ static struct sigaction kwsysProcessesOldSigChldAction;
static struct sigaction kwsysProcessesOldSigIntAction;
static struct sigaction kwsysProcessesOldSigTermAction;
-/*--------------------------------------------------------------------------*/
static void kwsysProcessesUpdate(kwsysProcessInstances* newProcesses)
{
/* Block signals while we update the set of pipes to check.
@@ -2611,7 +2632,6 @@ static void kwsysProcessesUpdate(kwsysProcessInstances* newProcesses)
sigprocmask(SIG_SETMASK, &oldset, 0);
}
-/*--------------------------------------------------------------------------*/
static int kwsysProcessesAdd(kwsysProcess* cp)
{
/* Create a pipe through which the signal handler can notify the
@@ -2721,7 +2741,6 @@ static int kwsysProcessesAdd(kwsysProcess* cp)
return 1;
}
-/*--------------------------------------------------------------------------*/
static void kwsysProcessesRemove(kwsysProcess* cp)
{
/* Attempt to remove the given signal pipe from the signal handler set. */
@@ -2772,7 +2791,6 @@ static void kwsysProcessesRemove(kwsysProcess* cp)
kwsysProcessCleanupDescriptor(&cp->SignalPipe);
}
-/*--------------------------------------------------------------------------*/
static void kwsysProcessesSignalHandler(int signum
#if KWSYSPE_USE_SIGINFO
,
@@ -2884,7 +2902,6 @@ static void kwsysProcessesSignalHandler(int signum
errno = old_errno;
}
-/*--------------------------------------------------------------------------*/
void kwsysProcess_ResetStartTime(kwsysProcess* cp)
{
if (!cp) {
diff --git a/thirdparty/KWSys/adios2sys/ProcessWin32.c b/thirdparty/KWSys/adios2sys/ProcessWin32.c
index d10c7339a7b134a763f696a1261205e943e04e4e..5183e3d2c96ec05345328a98689572b85429cab8 100644
--- a/thirdparty/KWSys/adios2sys/ProcessWin32.c
+++ b/thirdparty/KWSys/adios2sys/ProcessWin32.c
@@ -86,7 +86,6 @@ typedef struct kwsysProcessCreateInformation_s
HANDLE hStdError;
} kwsysProcessCreateInformation;
-/*--------------------------------------------------------------------------*/
typedef struct kwsysProcessPipeData_s kwsysProcessPipeData;
static DWORD WINAPI kwsysProcessPipeThreadRead(LPVOID ptd);
static void kwsysProcessPipeThreadReadPipe(kwsysProcess* cp,
@@ -119,6 +118,8 @@ static kwsysProcessTime kwsysProcessTimeAdd(kwsysProcessTime in1,
static kwsysProcessTime kwsysProcessTimeSubtract(kwsysProcessTime in1,
kwsysProcessTime in2);
static void kwsysProcessSetExitException(kwsysProcess* cp, int code);
+static void kwsysProcessSetExitExceptionByIndex(kwsysProcess* cp, int code,
+ int idx);
static void kwsysProcessKillTree(int pid);
static void kwsysProcessDisablePipeThreads(kwsysProcess* cp);
static int kwsysProcessesInitialize(void);
@@ -129,7 +130,6 @@ static int kwsysProcessesAdd(HANDLE hProcess, DWORD dwProcessId,
static void kwsysProcessesRemove(HANDLE hProcess);
static BOOL WINAPI kwsysCtrlHandler(DWORD dwCtrlType);
-/*--------------------------------------------------------------------------*/
/* A structure containing synchronization data for each thread. */
typedef struct kwsysProcessPipeSync_s kwsysProcessPipeSync;
struct kwsysProcessPipeSync_s
@@ -147,7 +147,6 @@ struct kwsysProcessPipeSync_s
HANDLE Reset;
};
-/*--------------------------------------------------------------------------*/
/* A structure containing data for each pipe's threads. */
struct kwsysProcessPipeData_s
{
@@ -183,7 +182,26 @@ struct kwsysProcessPipeData_s
HANDLE Write;
};
-/*--------------------------------------------------------------------------*/
+/* A structure containing results data for each process. */
+typedef struct kwsysProcessResults_s kwsysProcessResults;
+struct kwsysProcessResults_s
+{
+ /* The status of the process. */
+ int State;
+
+ /* The exceptional behavior that terminated the process, if any. */
+ int ExitException;
+
+ /* The process exit code. */
+ DWORD ExitCode;
+
+ /* The process return code, if any. */
+ int ExitValue;
+
+ /* Description for the ExitException. */
+ char ExitExceptionString[KWSYSPE_PIPE_BUFFER_SIZE + 1];
+};
+
/* Structure containing data used to implement the child's execution. */
struct kwsysProcess_s
{
@@ -249,15 +267,6 @@ struct kwsysProcess_s
/* ------------- Data managed per call to Execute ------------- */
- /* The exceptional behavior that terminated the process, if any. */
- int ExitException;
-
- /* The process exit code. */
- DWORD ExitCode;
-
- /* The process return code, if any. */
- int ExitValue;
-
/* Index of last pipe to report data, if any. */
int CurrentIndex;
@@ -289,8 +298,8 @@ struct kwsysProcess_s
/* Buffer for error messages. */
char ErrorMessage[KWSYSPE_PIPE_BUFFER_SIZE + 1];
- /* Description for the ExitException. */
- char ExitExceptionString[KWSYSPE_PIPE_BUFFER_SIZE + 1];
+ /* process results. */
+ kwsysProcessResults* ProcessResults;
/* Windows process information data. */
PROCESS_INFORMATION* ProcessInformation;
@@ -308,7 +317,6 @@ struct kwsysProcess_s
HANDLE PipeChildStd[3];
};
-/*--------------------------------------------------------------------------*/
kwsysProcess* kwsysProcess_New(void)
{
int i;
@@ -447,7 +455,6 @@ kwsysProcess* kwsysProcess_New(void)
return cp;
}
-/*--------------------------------------------------------------------------*/
void kwsysProcess_Delete(kwsysProcess* cp)
{
int i;
@@ -519,10 +526,10 @@ void kwsysProcess_Delete(kwsysProcess* cp)
if (cp->CommandExitCodes) {
free(cp->CommandExitCodes);
}
+ free(cp->ProcessResults);
free(cp);
}
-/*--------------------------------------------------------------------------*/
int kwsysProcess_SetCommand(kwsysProcess* cp, char const* const* command)
{
int i;
@@ -543,7 +550,6 @@ int kwsysProcess_SetCommand(kwsysProcess* cp, char const* const* command)
return 1;
}
-/*--------------------------------------------------------------------------*/
int kwsysProcess_AddCommand(kwsysProcess* cp, char const* const* command)
{
int newNumberOfCommands;
@@ -639,7 +645,6 @@ int kwsysProcess_AddCommand(kwsysProcess* cp, char const* const* command)
return 1;
}
-/*--------------------------------------------------------------------------*/
void kwsysProcess_SetTimeout(kwsysProcess* cp, double timeout)
{
if (!cp) {
@@ -653,7 +658,6 @@ void kwsysProcess_SetTimeout(kwsysProcess* cp, double timeout)
cp->TimeoutTime.QuadPart = -1;
}
-/*--------------------------------------------------------------------------*/
int kwsysProcess_SetWorkingDirectory(kwsysProcess* cp, const char* dir)
{
if (!cp) {
@@ -685,7 +689,6 @@ int kwsysProcess_SetWorkingDirectory(kwsysProcess* cp, const char* dir)
return 1;
}
-/*--------------------------------------------------------------------------*/
int kwsysProcess_SetPipeFile(kwsysProcess* cp, int pipe, const char* file)
{
char** pfile;
@@ -727,7 +730,6 @@ int kwsysProcess_SetPipeFile(kwsysProcess* cp, int pipe, const char* file)
return 1;
}
-/*--------------------------------------------------------------------------*/
void kwsysProcess_SetPipeShared(kwsysProcess* cp, int pipe, int shared)
{
if (!cp) {
@@ -756,7 +758,6 @@ void kwsysProcess_SetPipeShared(kwsysProcess* cp, int pipe, int shared)
}
}
-/*--------------------------------------------------------------------------*/
void kwsysProcess_SetPipeNative(kwsysProcess* cp, int pipe, HANDLE p[2])
{
HANDLE* pPipeNative = 0;
@@ -796,7 +797,6 @@ void kwsysProcess_SetPipeNative(kwsysProcess* cp, int pipe, HANDLE p[2])
}
}
-/*--------------------------------------------------------------------------*/
int kwsysProcess_GetOption(kwsysProcess* cp, int optionId)
{
if (!cp) {
@@ -819,7 +819,6 @@ int kwsysProcess_GetOption(kwsysProcess* cp, int optionId)
}
}
-/*--------------------------------------------------------------------------*/
void kwsysProcess_SetOption(kwsysProcess* cp, int optionId, int value)
{
if (!cp) {
@@ -847,31 +846,32 @@ void kwsysProcess_SetOption(kwsysProcess* cp, int optionId, int value)
}
}
-/*--------------------------------------------------------------------------*/
int kwsysProcess_GetState(kwsysProcess* cp)
{
return cp ? cp->State : kwsysProcess_State_Error;
}
-/*--------------------------------------------------------------------------*/
int kwsysProcess_GetExitException(kwsysProcess* cp)
{
- return cp ? cp->ExitException : kwsysProcess_Exception_Other;
+ return (cp && cp->ProcessResults && (cp->NumberOfCommands > 0))
+ ? cp->ProcessResults[cp->NumberOfCommands - 1].ExitException
+ : kwsysProcess_Exception_Other;
}
-/*--------------------------------------------------------------------------*/
int kwsysProcess_GetExitValue(kwsysProcess* cp)
{
- return cp ? cp->ExitValue : -1;
+ return (cp && cp->ProcessResults && (cp->NumberOfCommands > 0))
+ ? cp->ProcessResults[cp->NumberOfCommands - 1].ExitValue
+ : -1;
}
-/*--------------------------------------------------------------------------*/
int kwsysProcess_GetExitCode(kwsysProcess* cp)
{
- return cp ? cp->ExitCode : 0;
+ return (cp && cp->ProcessResults && (cp->NumberOfCommands > 0))
+ ? cp->ProcessResults[cp->NumberOfCommands - 1].ExitCode
+ : 0;
}
-/*--------------------------------------------------------------------------*/
const char* kwsysProcess_GetErrorString(kwsysProcess* cp)
{
if (!cp) {
@@ -882,18 +882,59 @@ const char* kwsysProcess_GetErrorString(kwsysProcess* cp)
return "Success";
}
-/*--------------------------------------------------------------------------*/
const char* kwsysProcess_GetExceptionString(kwsysProcess* cp)
{
- if (!cp) {
+ if (!(cp && cp->ProcessResults && (cp->NumberOfCommands > 0))) {
return "GetExceptionString called with NULL process management structure";
} else if (cp->State == kwsysProcess_State_Exception) {
- return cp->ExitExceptionString;
+ return cp->ProcessResults[cp->NumberOfCommands - 1].ExitExceptionString;
}
return "No exception";
}
-/*--------------------------------------------------------------------------*/
+/* the index should be in array bound. */
+#define KWSYSPE_IDX_CHK(RET) \
+ if (!cp || idx >= cp->NumberOfCommands || idx < 0) { \
+ KWSYSPE_DEBUG((stderr, "array index out of bound\n")); \
+ return RET; \
+ }
+
+int kwsysProcess_GetStateByIndex(kwsysProcess* cp, int idx)
+{
+ KWSYSPE_IDX_CHK(kwsysProcess_State_Error)
+ return cp->ProcessResults[idx].State;
+}
+
+int kwsysProcess_GetExitExceptionByIndex(kwsysProcess* cp, int idx)
+{
+ KWSYSPE_IDX_CHK(kwsysProcess_Exception_Other)
+ return cp->ProcessResults[idx].ExitException;
+}
+
+int kwsysProcess_GetExitValueByIndex(kwsysProcess* cp, int idx)
+{
+ KWSYSPE_IDX_CHK(-1)
+ return cp->ProcessResults[idx].ExitValue;
+}
+
+int kwsysProcess_GetExitCodeByIndex(kwsysProcess* cp, int idx)
+{
+ KWSYSPE_IDX_CHK(-1)
+ return cp->CommandExitCodes[idx];
+}
+
+const char* kwsysProcess_GetExceptionStringByIndex(kwsysProcess* cp, int idx)
+{
+ KWSYSPE_IDX_CHK("GetExceptionString called with NULL process management "
+ "structure or index out of bound")
+ if (cp->ProcessResults[idx].State == kwsysProcess_StateByIndex_Exception) {
+ return cp->ProcessResults[idx].ExitExceptionString;
+ }
+ return "No exception";
+}
+
+#undef KWSYSPE_IDX_CHK
+
void kwsysProcess_Execute(kwsysProcess* cp)
{
int i;
@@ -1135,7 +1176,6 @@ void kwsysProcess_Execute(kwsysProcess* cp)
cp->Detached = cp->OptionDetach;
}
-/*--------------------------------------------------------------------------*/
void kwsysProcess_Disown(kwsysProcess* cp)
{
int i;
@@ -1162,8 +1202,6 @@ void kwsysProcess_Disown(kwsysProcess* cp)
cp->State = kwsysProcess_State_Disowned;
}
-/*--------------------------------------------------------------------------*/
-
int kwsysProcess_WaitForData(kwsysProcess* cp, char** data, int* length,
double* userTimeout)
{
@@ -1289,7 +1327,6 @@ int kwsysProcess_WaitForData(kwsysProcess* cp, char** data, int* length,
}
}
-/*--------------------------------------------------------------------------*/
int kwsysProcess_WaitForExit(kwsysProcess* cp, double* userTimeout)
{
int i;
@@ -1338,25 +1375,29 @@ int kwsysProcess_WaitForExit(kwsysProcess* cp, double* userTimeout)
/* The timeout expired. */
cp->State = kwsysProcess_State_Expired;
} else {
- /* The children exited. Report the outcome of the last process. */
- cp->ExitCode = cp->CommandExitCodes[cp->NumberOfCommands - 1];
- if ((cp->ExitCode & 0xF0000000) == 0xC0000000) {
- /* Child terminated due to exceptional behavior. */
- cp->State = kwsysProcess_State_Exception;
- cp->ExitValue = 1;
- kwsysProcessSetExitException(cp, cp->ExitCode);
- } else {
- /* Child exited without exception. */
- cp->State = kwsysProcess_State_Exited;
- cp->ExitException = kwsysProcess_Exception_None;
- cp->ExitValue = cp->ExitCode;
+ /* The children exited. Report the outcome of the child processes. */
+ for (i = 0; i < cp->NumberOfCommands; ++i) {
+ cp->ProcessResults[i].ExitCode = cp->CommandExitCodes[i];
+ if ((cp->ProcessResults[i].ExitCode & 0xF0000000) == 0xC0000000) {
+ /* Child terminated due to exceptional behavior. */
+ cp->ProcessResults[i].State = kwsysProcess_StateByIndex_Exception;
+ cp->ProcessResults[i].ExitValue = 1;
+ kwsysProcessSetExitExceptionByIndex(cp, cp->ProcessResults[i].ExitCode,
+ i);
+ } else {
+ /* Child exited without exception. */
+ cp->ProcessResults[i].State = kwsysProcess_StateByIndex_Exited;
+ cp->ProcessResults[i].ExitException = kwsysProcess_Exception_None;
+ cp->ProcessResults[i].ExitValue = cp->ProcessResults[i].ExitCode;
+ }
}
+ /* support legacy state status value */
+ cp->State = cp->ProcessResults[cp->NumberOfCommands - 1].State;
}
return 1;
}
-/*--------------------------------------------------------------------------*/
void kwsysProcess_Interrupt(kwsysProcess* cp)
{
int i;
@@ -1394,7 +1435,6 @@ void kwsysProcess_Interrupt(kwsysProcess* cp)
}
}
-/*--------------------------------------------------------------------------*/
void kwsysProcess_Kill(kwsysProcess* cp)
{
int i;
@@ -1429,8 +1469,6 @@ void kwsysProcess_Kill(kwsysProcess* cp)
for them to exit. */
}
-/*--------------------------------------------------------------------------*/
-
/*
Function executed for each pipe's thread. Argument is a pointer to
the kwsysProcessPipeData instance for this thread.
@@ -1451,8 +1489,6 @@ DWORD WINAPI kwsysProcessPipeThreadRead(LPVOID ptd)
return 0;
}
-/*--------------------------------------------------------------------------*/
-
/*
Function called in each pipe's thread to handle data for one
execution of a subprocess.
@@ -1494,8 +1530,6 @@ void kwsysProcessPipeThreadReadPipe(kwsysProcess* cp, kwsysProcessPipeData* td)
ReleaseSemaphore(td->Reader.Go, 1, 0);
}
-/*--------------------------------------------------------------------------*/
-
/*
Function executed for each pipe's thread. Argument is a pointer to
the kwsysProcessPipeData instance for this thread.
@@ -1516,8 +1550,6 @@ DWORD WINAPI kwsysProcessPipeThreadWake(LPVOID ptd)
return 0;
}
-/*--------------------------------------------------------------------------*/
-
/*
Function called in each pipe's thread to handle reading thread
wakeup for one execution of a subprocess.
@@ -1540,23 +1572,34 @@ void kwsysProcessPipeThreadWakePipe(kwsysProcess* cp, kwsysProcessPipeData* td)
}
}
-/*--------------------------------------------------------------------------*/
/* Initialize a process control structure for kwsysProcess_Execute. */
int kwsysProcessInitialize(kwsysProcess* cp)
{
+ int i;
/* Reset internal status flags. */
cp->TimeoutExpired = 0;
cp->Terminated = 0;
cp->Killed = 0;
- cp->ExitException = kwsysProcess_Exception_None;
- cp->ExitCode = 1;
- cp->ExitValue = 1;
- /* Reset error data. */
- cp->ErrorMessage[0] = 0;
- strcpy(cp->ExitExceptionString, "No exception");
+ free(cp->ProcessResults);
+ /* Allocate process result information for each process. */
+ cp->ProcessResults = (kwsysProcessResults*)malloc(
+ sizeof(kwsysProcessResults) * (cp->NumberOfCommands));
+ if (!cp->ProcessResults) {
+ return 0;
+ }
+ ZeroMemory(cp->ProcessResults,
+ sizeof(kwsysProcessResults) * cp->NumberOfCommands);
+ for (i = 0; i < cp->NumberOfCommands; i++) {
+ cp->ProcessResults[i].ExitException = kwsysProcess_Exception_None;
+ cp->ProcessResults[i].State = kwsysProcess_StateByIndex_Starting;
+ cp->ProcessResults[i].ExitCode = 1;
+ cp->ProcessResults[i].ExitValue = 1;
+ strcpy(cp->ProcessResults[i].ExitExceptionString, "No exception");
+ }
/* Allocate process information for each process. */
+ free(cp->ProcessInformation);
cp->ProcessInformation = (PROCESS_INFORMATION*)malloc(
sizeof(PROCESS_INFORMATION) * cp->NumberOfCommands);
if (!cp->ProcessInformation) {
@@ -1596,7 +1639,6 @@ int kwsysProcessInitialize(kwsysProcess* cp)
}
}
{
- int i;
for (i = 0; i < 3; ++i) {
cp->PipeChildStd[i] = INVALID_HANDLE_VALUE;
}
@@ -1605,7 +1647,6 @@ int kwsysProcessInitialize(kwsysProcess* cp)
return 1;
}
-/*--------------------------------------------------------------------------*/
static DWORD kwsysProcessCreateChildHandle(PHANDLE out, HANDLE in, int isStdIn)
{
DWORD flags;
@@ -1641,7 +1682,6 @@ static DWORD kwsysProcessCreateChildHandle(PHANDLE out, HANDLE in, int isStdIn)
}
}
-/*--------------------------------------------------------------------------*/
DWORD kwsysProcessCreate(kwsysProcess* cp, int index,
kwsysProcessCreateInformation* si)
{
@@ -1706,7 +1746,6 @@ DWORD kwsysProcessCreate(kwsysProcess* cp, int index,
return error;
}
-/*--------------------------------------------------------------------------*/
void kwsysProcessDestroy(kwsysProcess* cp, int event)
{
int i;
@@ -1756,7 +1795,6 @@ void kwsysProcessDestroy(kwsysProcess* cp, int event)
}
}
-/*--------------------------------------------------------------------------*/
DWORD kwsysProcessSetupOutputPipeFile(PHANDLE phandle, const char* name)
{
HANDLE fout;
@@ -1784,7 +1822,6 @@ DWORD kwsysProcessSetupOutputPipeFile(PHANDLE phandle, const char* name)
return ERROR_SUCCESS;
}
-/*--------------------------------------------------------------------------*/
void kwsysProcessSetupSharedPipe(DWORD nStdHandle, PHANDLE handle)
{
/* Close the existing handle. */
@@ -1793,7 +1830,6 @@ void kwsysProcessSetupSharedPipe(DWORD nStdHandle, PHANDLE handle)
*handle = GetStdHandle(nStdHandle);
}
-/*--------------------------------------------------------------------------*/
void kwsysProcessSetupPipeNative(HANDLE native, PHANDLE handle)
{
/* Close the existing handle. */
@@ -1802,8 +1838,6 @@ void kwsysProcessSetupPipeNative(HANDLE native, PHANDLE handle)
*handle = native;
}
-/*--------------------------------------------------------------------------*/
-
/* Close the given handle if it is open. Reset its value to 0. */
void kwsysProcessCleanupHandle(PHANDLE h)
{
@@ -1816,8 +1850,6 @@ void kwsysProcessCleanupHandle(PHANDLE h)
}
}
-/*--------------------------------------------------------------------------*/
-
/* Close all handles created by kwsysProcess_Execute. */
void kwsysProcessCleanup(kwsysProcess* cp, DWORD error)
{
@@ -1902,7 +1934,6 @@ void kwsysProcessCleanup(kwsysProcess* cp, DWORD error)
}
}
-/*--------------------------------------------------------------------------*/
void kwsysProcessCleanErrorMessage(kwsysProcess* cp)
{
/* Remove trailing period and newline, if any. */
@@ -1920,7 +1951,6 @@ void kwsysProcessCleanErrorMessage(kwsysProcess* cp)
}
}
-/*--------------------------------------------------------------------------*/
/* Get the time at which either the process or user timeout will
expire. Returns 1 if the user timeout is first, and 0 otherwise. */
int kwsysProcessGetTimeoutTime(kwsysProcess* cp, double* userTimeout,
@@ -1952,7 +1982,6 @@ int kwsysProcessGetTimeoutTime(kwsysProcess* cp, double* userTimeout,
return 0;
}
-/*--------------------------------------------------------------------------*/
/* Get the length of time before the given timeout time arrives.
Returns 1 if the time has already arrived, and 0 otherwise. */
int kwsysProcessGetTimeoutLeft(kwsysProcessTime* timeoutTime,
@@ -1982,7 +2011,6 @@ int kwsysProcessGetTimeoutLeft(kwsysProcessTime* timeoutTime,
}
}
-/*--------------------------------------------------------------------------*/
kwsysProcessTime kwsysProcessTimeGetCurrent()
{
kwsysProcessTime current;
@@ -1993,19 +2021,16 @@ kwsysProcessTime kwsysProcessTimeGetCurrent()
return current;
}
-/*--------------------------------------------------------------------------*/
DWORD kwsysProcessTimeToDWORD(kwsysProcessTime t)
{
return (DWORD)(t.QuadPart * 0.0001);
}
-/*--------------------------------------------------------------------------*/
double kwsysProcessTimeToDouble(kwsysProcessTime t)
{
return t.QuadPart * 0.0000001;
}
-/*--------------------------------------------------------------------------*/
kwsysProcessTime kwsysProcessTimeFromDouble(double d)
{
kwsysProcessTime t;
@@ -2013,13 +2038,11 @@ kwsysProcessTime kwsysProcessTimeFromDouble(double d)
return t;
}
-/*--------------------------------------------------------------------------*/
int kwsysProcessTimeLess(kwsysProcessTime in1, kwsysProcessTime in2)
{
return in1.QuadPart < in2.QuadPart;
}
-/*--------------------------------------------------------------------------*/
kwsysProcessTime kwsysProcessTimeAdd(kwsysProcessTime in1,
kwsysProcessTime in2)
{
@@ -2028,7 +2051,6 @@ kwsysProcessTime kwsysProcessTimeAdd(kwsysProcessTime in1,
return out;
}
-/*--------------------------------------------------------------------------*/
kwsysProcessTime kwsysProcessTimeSubtract(kwsysProcessTime in1,
kwsysProcessTime in2)
{
@@ -2037,11 +2059,11 @@ kwsysProcessTime kwsysProcessTimeSubtract(kwsysProcessTime in1,
return out;
}
-/*--------------------------------------------------------------------------*/
#define KWSYSPE_CASE(type, str) \
- cp->ExitException = kwsysProcess_Exception_##type; \
- strcpy(cp->ExitExceptionString, str)
-static void kwsysProcessSetExitException(kwsysProcess* cp, int code)
+ cp->ProcessResults[idx].ExitException = kwsysProcess_Exception_##type; \
+ strcpy(cp->ProcessResults[idx].ExitExceptionString, str)
+static void kwsysProcessSetExitExceptionByIndex(kwsysProcess* cp, int code,
+ int idx)
{
switch (code) {
case STATUS_CONTROL_C_EXIT:
@@ -2120,9 +2142,9 @@ static void kwsysProcessSetExitException(kwsysProcess* cp, int code)
case STATUS_NO_MEMORY:
default:
- cp->ExitException = kwsysProcess_Exception_Other;
- _snprintf(cp->ExitExceptionString, KWSYSPE_PIPE_BUFFER_SIZE,
- "Exit code 0x%x\n", code);
+ cp->ProcessResults[idx].ExitException = kwsysProcess_Exception_Other;
+ _snprintf(cp->ProcessResults[idx].ExitExceptionString,
+ KWSYSPE_PIPE_BUFFER_SIZE, "Exit code 0x%x\n", code);
break;
}
}
@@ -2136,7 +2158,6 @@ static int kwsysProcess_List_NextProcess(kwsysProcess_List* self);
static int kwsysProcess_List_GetCurrentProcessId(kwsysProcess_List* self);
static int kwsysProcess_List_GetCurrentParentId(kwsysProcess_List* self);
-/*--------------------------------------------------------------------------*/
/* Windows NT 4 API definitions. */
#define STATUS_INFO_LENGTH_MISMATCH ((NTSTATUS)0xC0000004L)
typedef LONG NTSTATUS;
@@ -2168,7 +2189,6 @@ struct _SYSTEM_PROCESS_INFORMATION
ULONG InheritedFromProcessId;
};
-/*--------------------------------------------------------------------------*/
/* Toolhelp32 API definitions. */
#define TH32CS_SNAPPROCESS 0x00000002
#if defined(_WIN64)
@@ -2192,7 +2212,6 @@ struct tagPROCESSENTRY32
char szExeFile[MAX_PATH];
};
-/*--------------------------------------------------------------------------*/
/* Windows API function types. */
typedef HANDLE(WINAPI* CreateToolhelp32SnapshotType)(DWORD, DWORD);
typedef BOOL(WINAPI* Process32FirstType)(HANDLE, LPPROCESSENTRY32);
@@ -2200,7 +2219,6 @@ typedef BOOL(WINAPI* Process32NextType)(HANDLE, LPPROCESSENTRY32);
typedef NTSTATUS(WINAPI* ZwQuerySystemInformationType)(ULONG, PVOID, ULONG,
PULONG);
-/*--------------------------------------------------------------------------*/
static int kwsysProcess_List__New_NT4(kwsysProcess_List* self);
static int kwsysProcess_List__New_Snapshot(kwsysProcess_List* self);
static void kwsysProcess_List__Delete_NT4(kwsysProcess_List* self);
@@ -2233,7 +2251,6 @@ struct kwsysProcess_List_s
PROCESSENTRY32 CurrentEntry;
};
-/*--------------------------------------------------------------------------*/
static kwsysProcess_List* kwsysProcess_List_New(void)
{
OSVERSIONINFO osv;
@@ -2279,7 +2296,6 @@ static kwsysProcess_List* kwsysProcess_List_New(void)
return self;
}
-/*--------------------------------------------------------------------------*/
static void kwsysProcess_List_Delete(kwsysProcess_List* self)
{
if (self) {
@@ -2292,7 +2308,6 @@ static void kwsysProcess_List_Delete(kwsysProcess_List* self)
}
}
-/*--------------------------------------------------------------------------*/
static int kwsysProcess_List_Update(kwsysProcess_List* self)
{
return self ? (self->NT4 ? kwsysProcess_List__Update_NT4(self)
@@ -2300,7 +2315,6 @@ static int kwsysProcess_List_Update(kwsysProcess_List* self)
: 0;
}
-/*--------------------------------------------------------------------------*/
static int kwsysProcess_List_GetCurrentProcessId(kwsysProcess_List* self)
{
return self ? (self->NT4 ? kwsysProcess_List__GetProcessId_NT4(self)
@@ -2308,7 +2322,6 @@ static int kwsysProcess_List_GetCurrentProcessId(kwsysProcess_List* self)
: -1;
}
-/*--------------------------------------------------------------------------*/
static int kwsysProcess_List_GetCurrentParentId(kwsysProcess_List* self)
{
return self ? (self->NT4 ? kwsysProcess_List__GetParentId_NT4(self)
@@ -2316,7 +2329,6 @@ static int kwsysProcess_List_GetCurrentParentId(kwsysProcess_List* self)
: -1;
}
-/*--------------------------------------------------------------------------*/
static int kwsysProcess_List_NextProcess(kwsysProcess_List* self)
{
return (self ? (self->NT4 ? kwsysProcess_List__Next_NT4(self)
@@ -2324,7 +2336,6 @@ static int kwsysProcess_List_NextProcess(kwsysProcess_List* self)
: 0);
}
-/*--------------------------------------------------------------------------*/
static int kwsysProcess_List__New_NT4(kwsysProcess_List* self)
{
/* Get a handle to the NT runtime module that should already be
@@ -2348,7 +2359,6 @@ static int kwsysProcess_List__New_NT4(kwsysProcess_List* self)
return self->Buffer ? 1 : 0;
}
-/*--------------------------------------------------------------------------*/
static void kwsysProcess_List__Delete_NT4(kwsysProcess_List* self)
{
/* Free the process information buffer. */
@@ -2357,7 +2367,6 @@ static void kwsysProcess_List__Delete_NT4(kwsysProcess_List* self)
}
}
-/*--------------------------------------------------------------------------*/
static int kwsysProcess_List__Update_NT4(kwsysProcess_List* self)
{
self->CurrentInfo = 0;
@@ -2387,7 +2396,6 @@ static int kwsysProcess_List__Update_NT4(kwsysProcess_List* self)
}
}
-/*--------------------------------------------------------------------------*/
static int kwsysProcess_List__Next_NT4(kwsysProcess_List* self)
{
if (self->CurrentInfo) {
@@ -2401,19 +2409,16 @@ static int kwsysProcess_List__Next_NT4(kwsysProcess_List* self)
return 0;
}
-/*--------------------------------------------------------------------------*/
static int kwsysProcess_List__GetProcessId_NT4(kwsysProcess_List* self)
{
return self->CurrentInfo ? self->CurrentInfo->ProcessId : -1;
}
-/*--------------------------------------------------------------------------*/
static int kwsysProcess_List__GetParentId_NT4(kwsysProcess_List* self)
{
return self->CurrentInfo ? self->CurrentInfo->InheritedFromProcessId : -1;
}
-/*--------------------------------------------------------------------------*/
static int kwsysProcess_List__New_Snapshot(kwsysProcess_List* self)
{
/* Get a handle to the Windows runtime module that should already be
@@ -2436,7 +2441,6 @@ static int kwsysProcess_List__New_Snapshot(kwsysProcess_List* self)
: 0;
}
-/*--------------------------------------------------------------------------*/
static void kwsysProcess_List__Delete_Snapshot(kwsysProcess_List* self)
{
if (self->Snapshot) {
@@ -2444,7 +2448,6 @@ static void kwsysProcess_List__Delete_Snapshot(kwsysProcess_List* self)
}
}
-/*--------------------------------------------------------------------------*/
static int kwsysProcess_List__Update_Snapshot(kwsysProcess_List* self)
{
if (self->Snapshot) {
@@ -2464,7 +2467,6 @@ static int kwsysProcess_List__Update_Snapshot(kwsysProcess_List* self)
return 1;
}
-/*--------------------------------------------------------------------------*/
static int kwsysProcess_List__Next_Snapshot(kwsysProcess_List* self)
{
if (self->Snapshot) {
@@ -2477,19 +2479,16 @@ static int kwsysProcess_List__Next_Snapshot(kwsysProcess_List* self)
return 0;
}
-/*--------------------------------------------------------------------------*/
static int kwsysProcess_List__GetProcessId_Snapshot(kwsysProcess_List* self)
{
return self->Snapshot ? self->CurrentEntry.th32ProcessID : -1;
}
-/*--------------------------------------------------------------------------*/
static int kwsysProcess_List__GetParentId_Snapshot(kwsysProcess_List* self)
{
return self->Snapshot ? self->CurrentEntry.th32ParentProcessID : -1;
}
-/*--------------------------------------------------------------------------*/
static void kwsysProcessKill(DWORD pid)
{
HANDLE h = OpenProcess(PROCESS_TERMINATE, 0, pid);
@@ -2500,7 +2499,6 @@ static void kwsysProcessKill(DWORD pid)
}
}
-/*--------------------------------------------------------------------------*/
static void kwsysProcessKillTree(int pid)
{
kwsysProcess_List* plist = kwsysProcess_List_New();
@@ -2516,7 +2514,6 @@ static void kwsysProcessKillTree(int pid)
}
}
-/*--------------------------------------------------------------------------*/
static void kwsysProcessDisablePipeThreads(kwsysProcess* cp)
{
int i;
@@ -2568,7 +2565,6 @@ static void kwsysProcessDisablePipeThreads(kwsysProcess* cp)
}
}
-/*--------------------------------------------------------------------------*/
/* Global set of executing processes for use by the Ctrl handler.
This global instance will be zero-initialized by the compiler.
@@ -2598,7 +2594,6 @@ typedef struct kwsysProcessInstances_s
} kwsysProcessInstances;
static kwsysProcessInstances kwsysProcesses;
-/*--------------------------------------------------------------------------*/
/* Initialize critial section and set up console Ctrl handler. You MUST call
this before using any other kwsysProcesses* functions below. */
static int kwsysProcessesInitialize(void)
@@ -2617,7 +2612,6 @@ static int kwsysProcessesInitialize(void)
return 1;
}
-/*--------------------------------------------------------------------------*/
/* The Ctrl handler waits on the global list of processes. To prevent an
orphaned process, do not create a new process if the Ctrl handler is
already running. Do so by using this function to check if it is ok to
@@ -2636,7 +2630,6 @@ static int kwsysTryEnterCreateProcessSection(void)
}
}
-/*--------------------------------------------------------------------------*/
/* Matching function on successful kwsysTryEnterCreateProcessSection return.
Make sure you called kwsysProcessesAdd if applicable before calling this.*/
static void kwsysLeaveCreateProcessSection(void)
@@ -2644,7 +2637,6 @@ static void kwsysLeaveCreateProcessSection(void)
LeaveCriticalSection(&kwsysProcesses.Lock);
}
-/*--------------------------------------------------------------------------*/
/* Add new process to global process list. The Ctrl handler will wait for
the process to exit before it returns. Do not close the process handle
until after calling kwsysProcessesRemove. The newProcessGroup parameter
@@ -2702,7 +2694,6 @@ static int kwsysProcessesAdd(HANDLE hProcess, DWORD dwProcessid,
return 1;
}
-/*--------------------------------------------------------------------------*/
/* Removes process to global process list. */
static void kwsysProcessesRemove(HANDLE hProcess)
{
@@ -2738,7 +2729,6 @@ static void kwsysProcessesRemove(HANDLE hProcess)
LeaveCriticalSection(&kwsysProcesses.Lock);
}
-/*--------------------------------------------------------------------------*/
static BOOL WINAPI kwsysCtrlHandler(DWORD dwCtrlType)
{
size_t i;
@@ -2774,7 +2764,6 @@ static BOOL WINAPI kwsysCtrlHandler(DWORD dwCtrlType)
return FALSE;
}
-/*--------------------------------------------------------------------------*/
void kwsysProcess_ResetStartTime(kwsysProcess* cp)
{
if (!cp) {
diff --git a/thirdparty/KWSys/adios2sys/SharedForward.h.in b/thirdparty/KWSys/adios2sys/SharedForward.h.in
index c9ae135529812c2f7b05330d6f5c0335a0d91b33..f638267ec5710dbd5ae349052b6ac8e522d86b3d 100644
--- a/thirdparty/KWSys/adios2sys/SharedForward.h.in
+++ b/thirdparty/KWSys/adios2sys/SharedForward.h.in
@@ -72,8 +72,6 @@
#pragma warn - 8019
#endif
-/*--------------------------------------------------------------------------*/
-
/* Full path to the directory in which this executable is built. Do
not include a trailing slash. */
#if !defined(@KWSYS_NAMESPACE@_SHARED_FORWARD_DIR_BUILD)
@@ -159,7 +157,6 @@
#undef KWSYS_SHARED_FORWARD_OPTION_LDD
#endif
-/*--------------------------------------------------------------------------*/
/* Include needed system headers. */
#include <errno.h>
@@ -180,7 +177,6 @@
#include <unistd.h>
#endif
-/*--------------------------------------------------------------------------*/
/* Configuration for this platform. */
/* The path separator for this platform. */
@@ -292,7 +288,6 @@ static const char kwsys_shared_forward_path_slash[2] = {
#endif
#ifdef KWSYS_SHARED_FORWARD_ESCAPE_ARGV
-/*--------------------------------------------------------------------------*/
typedef struct kwsys_sf_arg_info_s
{
const char* arg;
@@ -300,7 +295,6 @@ typedef struct kwsys_sf_arg_info_s
int quote;
} kwsys_sf_arg_info;
-/*--------------------------------------------------------------------------*/
static kwsys_sf_arg_info kwsys_sf_get_arg_info(const char* in)
{
/* Initialize information. */
@@ -354,7 +348,6 @@ static kwsys_sf_arg_info kwsys_sf_get_arg_info(const char* in)
return info;
}
-/*--------------------------------------------------------------------------*/
static char* kwsys_sf_get_arg(kwsys_sf_arg_info info, char* out)
{
/* String iterator. */
@@ -413,7 +406,6 @@ static char* kwsys_sf_get_arg(kwsys_sf_arg_info info, char* out)
}
#endif
-/*--------------------------------------------------------------------------*/
/* Function to convert a logical or relative path to a physical full path. */
static int kwsys_shared_forward_realpath(const char* in_path, char* out_path)
{
@@ -428,7 +420,6 @@ static int kwsys_shared_forward_realpath(const char* in_path, char* out_path)
#endif
}
-/*--------------------------------------------------------------------------*/
static int kwsys_shared_forward_samepath(const char* file1, const char* file2)
{
#if defined(_WIN32)
@@ -458,7 +449,6 @@ static int kwsys_shared_forward_samepath(const char* file1, const char* file2)
#endif
}
-/*--------------------------------------------------------------------------*/
/* Function to report a system error message. */
static void kwsys_shared_forward_strerror(char* message)
{
@@ -481,7 +471,6 @@ static void kwsys_shared_forward_strerror(char* message)
#endif
}
-/*--------------------------------------------------------------------------*/
/* Functions to execute a child process. */
static void kwsys_shared_forward_execvp(const char* cmd,
char const* const* argv)
@@ -521,7 +510,6 @@ static void kwsys_shared_forward_execvp(const char* cmd,
#endif
}
-/*--------------------------------------------------------------------------*/
/* Function to get the directory containing the given file or directory. */
static void kwsys_shared_forward_dirname(const char* begin, char* result)
{
@@ -557,7 +545,6 @@ static void kwsys_shared_forward_dirname(const char* begin, char* result)
}
}
-/*--------------------------------------------------------------------------*/
/* Function to check if a file exists and is executable. */
static int kwsys_shared_forward_is_executable(const char* f)
{
@@ -578,7 +565,6 @@ static int kwsys_shared_forward_is_executable(const char* f)
}
}
-/*--------------------------------------------------------------------------*/
/* Function to locate the executable currently running. */
static int kwsys_shared_forward_self_path(const char* argv0, char* result)
{
@@ -644,7 +630,6 @@ static int kwsys_shared_forward_self_path(const char* argv0, char* result)
return 0;
}
-/*--------------------------------------------------------------------------*/
/* Function to convert a specified path to a full path. If it is not
already full, it is taken relative to the self path. */
static int kwsys_shared_forward_fullpath(const char* self_path,
@@ -681,7 +666,6 @@ static int kwsys_shared_forward_fullpath(const char* self_path,
return 1;
}
-/*--------------------------------------------------------------------------*/
/* Function to compute the library search path and executable name
based on the self path. */
static int kwsys_shared_forward_get_settings(const char* self_path,
@@ -773,7 +757,6 @@ static int kwsys_shared_forward_get_settings(const char* self_path,
return 1;
}
-/*--------------------------------------------------------------------------*/
/* Function to print why execution of a command line failed. */
static void kwsys_shared_forward_print_failure(char const* const* argv)
{
@@ -791,7 +774,6 @@ static void kwsys_shared_forward_print_failure(char const* const* argv)
static char kwsys_shared_forward_ldpath[65535] =
KWSYS_SHARED_FORWARD_LDPATH "=";
-/*--------------------------------------------------------------------------*/
/* Main driver function to be called from main. */
static int @KWSYS_NAMESPACE@_shared_forward_to_real(int argc, char** argv_in)
{
diff --git a/thirdparty/KWSys/adios2sys/System.c b/thirdparty/KWSys/adios2sys/System.c
index 43c60c5722c7882f60994dcb4e9ba0f5a5adea6b..b9af8e9d9ef2084e26b139102d642e3c6bf8933a 100644
--- a/thirdparty/KWSys/adios2sys/System.c
+++ b/thirdparty/KWSys/adios2sys/System.c
@@ -22,7 +22,6 @@ typedef ptrdiff_t kwsysSystem_ptrdiff_t;
typedef int kwsysSystem_ptrdiff_t;
#endif
-/*--------------------------------------------------------------------------*/
static int kwsysSystem__AppendByte(char* local, char** begin, char** end,
int* size, char c)
{
@@ -47,7 +46,6 @@ static int kwsysSystem__AppendByte(char* local, char** begin, char** end,
return 1;
}
-/*--------------------------------------------------------------------------*/
static int kwsysSystem__AppendArgument(char** local, char*** begin,
char*** end, int* size, char* arg_local,
char** arg_begin, char** arg_end,
@@ -91,7 +89,6 @@ static int kwsysSystem__AppendArgument(char** local, char*** begin,
return 1;
}
-/*--------------------------------------------------------------------------*/
#define KWSYSPE_LOCAL_BYTE_COUNT 1024
#define KWSYSPE_LOCAL_ARGS_COUNT 32
static char** kwsysSystem__ParseUnixCommand(const char* command, int flags)
@@ -227,7 +224,6 @@ static char** kwsysSystem__ParseUnixCommand(const char* command, int flags)
return newCommand;
}
-/*--------------------------------------------------------------------------*/
char** kwsysSystem_Parse_CommandForUnix(const char* command, int flags)
{
/* Validate the flags. */
diff --git a/thirdparty/KWSys/adios2sys/SystemInformation.cxx b/thirdparty/KWSys/adios2sys/SystemInformation.cxx
index 70f1a434ed914f0008ffe1abec8fd69c00ec072a..86fdccdc7f3123f4929bac05248b5c8536499482 100644
--- a/thirdparty/KWSys/adios2sys/SystemInformation.cxx
+++ b/thirdparty/KWSys/adios2sys/SystemInformation.cxx
@@ -838,7 +838,6 @@ void SystemInformation::RunMemoryCheck()
this->Implementation->RunMemoryCheck();
}
-// --------------------------------------------------------------
// SystemInformationImplementation starts here
#define STORE_TLBCACHE_INFO(x, y) x = (x < (y)) ? (y) : x
@@ -846,30 +845,6 @@ void SystemInformation::RunMemoryCheck()
#define CLASSICAL_CPU_FREQ_LOOP 10000000
#define RDTSC_INSTRUCTION _asm _emit 0x0f _asm _emit 0x31
-#define MMX_FEATURE 0x00000001
-#define MMX_PLUS_FEATURE 0x00000002
-#define SSE_FEATURE 0x00000004
-#define SSE2_FEATURE 0x00000008
-#define AMD_3DNOW_FEATURE 0x00000010
-#define AMD_3DNOW_PLUS_FEATURE 0x00000020
-#define IA64_FEATURE 0x00000040
-#define MP_CAPABLE 0x00000080
-#define HYPERTHREAD_FEATURE 0x00000100
-#define SERIALNUMBER_FEATURE 0x00000200
-#define APIC_FEATURE 0x00000400
-#define SSE_FP_FEATURE 0x00000800
-#define SSE_MMX_FEATURE 0x00001000
-#define CMOV_FEATURE 0x00002000
-#define MTRR_FEATURE 0x00004000
-#define L1CACHE_FEATURE 0x00008000
-#define L2CACHE_FEATURE 0x00010000
-#define L3CACHE_FEATURE 0x00020000
-#define ACPI_FEATURE 0x00040000
-#define THERMALMONITOR_FEATURE 0x00080000
-#define TEMPSENSEDIODE_FEATURE 0x00100000
-#define FREQUENCYID_FEATURE 0x00200000
-#define VOLTAGEID_FREQUENCY 0x00400000
-
// Status Flag
#define HT_NOT_CAPABLE 0
#define HT_ENABLED 1
@@ -943,7 +918,8 @@ int LoadLines(const char* fileName, std::vector<std::string>& lines)
// ****************************************************************************
template <typename T>
-int NameValue(std::vector<std::string>& lines, std::string name, T& value)
+int NameValue(std::vector<std::string> const& lines, std::string const& name,
+ T& value)
{
size_t nLines = lines.size();
for (size_t i = 0; i < nLines; ++i) {
@@ -1314,7 +1290,6 @@ private:
int ReportPath;
};
-// --------------------------------------------------------------------------
std::ostream& operator<<(std::ostream& os, const SymbolProperties& sp)
{
#if defined(KWSYS_SYSTEMINFORMATION_HAS_SYMBOL_LOOKUP)
@@ -1333,7 +1308,6 @@ std::ostream& operator<<(std::ostream& os, const SymbolProperties& sp)
return os;
}
-// --------------------------------------------------------------------------
SymbolProperties::SymbolProperties()
{
// not using an initializer list
@@ -1352,20 +1326,18 @@ SymbolProperties::SymbolProperties()
this->GetLineNumber();
}
-// --------------------------------------------------------------------------
std::string SymbolProperties::GetFileName(const std::string& path) const
{
std::string file(path);
if (!this->ReportPath) {
size_t at = file.rfind("/");
if (at != std::string::npos) {
- file = file.substr(at + 1, std::string::npos);
+ file = file.substr(at + 1);
}
}
return file;
}
-// --------------------------------------------------------------------------
std::string SymbolProperties::GetBinary() const
{
// only linux has proc fs
@@ -1386,7 +1358,6 @@ std::string SymbolProperties::GetBinary() const
return this->GetFileName(this->Binary);
}
-// --------------------------------------------------------------------------
std::string SymbolProperties::Demangle(const char* symbol) const
{
std::string result = safes(symbol);
@@ -1406,7 +1377,6 @@ std::string SymbolProperties::Demangle(const char* symbol) const
return result;
}
-// --------------------------------------------------------------------------
void SymbolProperties::Initialize(void* address)
{
this->Address = address;
@@ -1425,7 +1395,6 @@ void SymbolProperties::Initialize(void* address)
}
#endif // don't define this class if we're not using it
-// --------------------------------------------------------------------------
#if defined(_WIN32) || defined(__CYGWIN__)
#define KWSYS_SYSTEMINFORMATION_USE_GetSystemTimes
#endif
@@ -1875,11 +1844,11 @@ int SystemInformationImplementation::GetProcessorCacheSize()
int SystemInformationImplementation::GetProcessorCacheXSize(long int dwCacheID)
{
switch (dwCacheID) {
- case L1CACHE_FEATURE:
+ case SystemInformation::CPU_FEATURE_L1CACHE:
return this->Features.L1CacheSize;
- case L2CACHE_FEATURE:
+ case SystemInformation::CPU_FEATURE_L2CACHE:
return this->Features.L2CacheSize;
- case L3CACHE_FEATURE:
+ case SystemInformation::CPU_FEATURE_L3CACHE:
return this->Features.L3CacheSize;
}
return -1;
@@ -1890,104 +1859,121 @@ bool SystemInformationImplementation::DoesCPUSupportFeature(long int dwFeature)
bool bHasFeature = false;
// Check for MMX instructions.
- if (((dwFeature & MMX_FEATURE) != 0) && this->Features.HasMMX)
+ if (((dwFeature & SystemInformation::CPU_FEATURE_MMX) != 0) &&
+ this->Features.HasMMX)
bHasFeature = true;
// Check for MMX+ instructions.
- if (((dwFeature & MMX_PLUS_FEATURE) != 0) &&
+ if (((dwFeature & SystemInformation::CPU_FEATURE_MMX_PLUS) != 0) &&
this->Features.ExtendedFeatures.HasMMXPlus)
bHasFeature = true;
// Check for SSE FP instructions.
- if (((dwFeature & SSE_FEATURE) != 0) && this->Features.HasSSE)
+ if (((dwFeature & SystemInformation::CPU_FEATURE_SSE) != 0) &&
+ this->Features.HasSSE)
bHasFeature = true;
// Check for SSE FP instructions.
- if (((dwFeature & SSE_FP_FEATURE) != 0) && this->Features.HasSSEFP)
+ if (((dwFeature & SystemInformation::CPU_FEATURE_SSE_FP) != 0) &&
+ this->Features.HasSSEFP)
bHasFeature = true;
// Check for SSE MMX instructions.
- if (((dwFeature & SSE_MMX_FEATURE) != 0) &&
+ if (((dwFeature & SystemInformation::CPU_FEATURE_SSE_MMX) != 0) &&
this->Features.ExtendedFeatures.HasSSEMMX)
bHasFeature = true;
// Check for SSE2 instructions.
- if (((dwFeature & SSE2_FEATURE) != 0) && this->Features.HasSSE2)
+ if (((dwFeature & SystemInformation::CPU_FEATURE_SSE2) != 0) &&
+ this->Features.HasSSE2)
bHasFeature = true;
// Check for 3DNow! instructions.
- if (((dwFeature & AMD_3DNOW_FEATURE) != 0) &&
+ if (((dwFeature & SystemInformation::CPU_FEATURE_AMD_3DNOW) != 0) &&
this->Features.ExtendedFeatures.Has3DNow)
bHasFeature = true;
// Check for 3DNow+ instructions.
- if (((dwFeature & AMD_3DNOW_PLUS_FEATURE) != 0) &&
+ if (((dwFeature & SystemInformation::CPU_FEATURE_AMD_3DNOW_PLUS) != 0) &&
this->Features.ExtendedFeatures.Has3DNowPlus)
bHasFeature = true;
// Check for IA64 instructions.
- if (((dwFeature & IA64_FEATURE) != 0) && this->Features.HasIA64)
+ if (((dwFeature & SystemInformation::CPU_FEATURE_IA64) != 0) &&
+ this->Features.HasIA64)
bHasFeature = true;
// Check for MP capable.
- if (((dwFeature & MP_CAPABLE) != 0) &&
+ if (((dwFeature & SystemInformation::CPU_FEATURE_MP_CAPABLE) != 0) &&
this->Features.ExtendedFeatures.SupportsMP)
bHasFeature = true;
// Check for a serial number for the processor.
- if (((dwFeature & SERIALNUMBER_FEATURE) != 0) && this->Features.HasSerial)
+ if (((dwFeature & SystemInformation::CPU_FEATURE_SERIALNUMBER) != 0) &&
+ this->Features.HasSerial)
bHasFeature = true;
// Check for a local APIC in the processor.
- if (((dwFeature & APIC_FEATURE) != 0) && this->Features.HasAPIC)
+ if (((dwFeature & SystemInformation::CPU_FEATURE_APIC) != 0) &&
+ this->Features.HasAPIC)
bHasFeature = true;
// Check for CMOV instructions.
- if (((dwFeature & CMOV_FEATURE) != 0) && this->Features.HasCMOV)
+ if (((dwFeature & SystemInformation::CPU_FEATURE_CMOV) != 0) &&
+ this->Features.HasCMOV)
bHasFeature = true;
// Check for MTRR instructions.
- if (((dwFeature & MTRR_FEATURE) != 0) && this->Features.HasMTRR)
+ if (((dwFeature & SystemInformation::CPU_FEATURE_MTRR) != 0) &&
+ this->Features.HasMTRR)
bHasFeature = true;
// Check for L1 cache size.
- if (((dwFeature & L1CACHE_FEATURE) != 0) &&
+ if (((dwFeature & SystemInformation::CPU_FEATURE_L1CACHE) != 0) &&
(this->Features.L1CacheSize != -1))
bHasFeature = true;
// Check for L2 cache size.
- if (((dwFeature & L2CACHE_FEATURE) != 0) &&
+ if (((dwFeature & SystemInformation::CPU_FEATURE_L2CACHE) != 0) &&
(this->Features.L2CacheSize != -1))
bHasFeature = true;
// Check for L3 cache size.
- if (((dwFeature & L3CACHE_FEATURE) != 0) &&
+ if (((dwFeature & SystemInformation::CPU_FEATURE_L3CACHE) != 0) &&
(this->Features.L3CacheSize != -1))
bHasFeature = true;
// Check for ACPI capability.
- if (((dwFeature & ACPI_FEATURE) != 0) && this->Features.HasACPI)
+ if (((dwFeature & SystemInformation::CPU_FEATURE_ACPI) != 0) &&
+ this->Features.HasACPI)
bHasFeature = true;
// Check for thermal monitor support.
- if (((dwFeature & THERMALMONITOR_FEATURE) != 0) && this->Features.HasThermal)
+ if (((dwFeature & SystemInformation::CPU_FEATURE_THERMALMONITOR) != 0) &&
+ this->Features.HasThermal)
bHasFeature = true;
// Check for temperature sensing diode support.
- if (((dwFeature & TEMPSENSEDIODE_FEATURE) != 0) &&
+ if (((dwFeature & SystemInformation::CPU_FEATURE_TEMPSENSEDIODE) != 0) &&
this->Features.ExtendedFeatures.PowerManagement.HasTempSenseDiode)
bHasFeature = true;
// Check for frequency ID support.
- if (((dwFeature & FREQUENCYID_FEATURE) != 0) &&
+ if (((dwFeature & SystemInformation::CPU_FEATURE_FREQUENCYID) != 0) &&
this->Features.ExtendedFeatures.PowerManagement.HasFrequencyID)
bHasFeature = true;
// Check for voltage ID support.
- if (((dwFeature & VOLTAGEID_FREQUENCY) != 0) &&
+ if (((dwFeature & SystemInformation::CPU_FEATURE_VOLTAGEID_FREQUENCY) !=
+ 0) &&
this->Features.ExtendedFeatures.PowerManagement.HasVoltageID)
bHasFeature = true;
+ // Check for FPU support.
+ if (((dwFeature & SystemInformation::CPU_FEATURE_FPU) != 0) &&
+ this->Features.HasFPU)
+ bHasFeature = true;
+
return bHasFeature;
}
@@ -3356,11 +3342,11 @@ std::string SystemInformationImplementation::ExtractValueFromCpuInfoFile(
std::string buffer, const char* word, size_t init)
{
size_t pos = buffer.find(word, init);
- if (pos != buffer.npos) {
+ if (pos != std::string::npos) {
this->CurrentPositionInFile = pos;
pos = buffer.find(":", pos);
size_t pos2 = buffer.find("\n", pos);
- if (pos != buffer.npos && pos2 != buffer.npos) {
+ if (pos != std::string::npos && pos2 != std::string::npos) {
// It may happen that the beginning matches, but this is still not the
// requested key.
// An example is looking for "cpu" when "cpu family" comes first. So we
@@ -3375,7 +3361,7 @@ std::string SystemInformationImplementation::ExtractValueFromCpuInfoFile(
return buffer.substr(pos + 2, pos2 - pos - 2);
}
}
- this->CurrentPositionInFile = buffer.npos;
+ this->CurrentPositionInFile = std::string::npos;
return "";
}
@@ -3402,7 +3388,7 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile()
// Number of logical CPUs (combination of multiple processors, multi-core
// and SMT)
size_t pos = buffer.find("processor\t");
- while (pos != buffer.npos) {
+ while (pos != std::string::npos) {
this->NumberOfLogicalCPU++;
pos = buffer.find("processor\t", pos + 1);
}
@@ -3411,7 +3397,7 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile()
// Count sockets.
std::set<int> PhysicalIDs;
std::string idc = this->ExtractValueFromCpuInfoFile(buffer, "physical id");
- while (this->CurrentPositionInFile != buffer.npos) {
+ while (this->CurrentPositionInFile != std::string::npos) {
int id = atoi(idc.c_str());
PhysicalIDs.insert(id);
idc = this->ExtractValueFromCpuInfoFile(buffer, "physical id",
@@ -3521,7 +3507,7 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile()
this->ExtractValueFromCpuInfoFile(buffer, cachename[index]);
if (!cacheSize.empty()) {
pos = cacheSize.find(" KB");
- if (pos != cacheSize.npos) {
+ if (pos != std::string::npos) {
cacheSize = cacheSize.substr(0, pos);
}
this->Features.L1CacheSize += atoi(cacheSize.c_str());
@@ -4600,10 +4586,10 @@ std::string SystemInformationImplementation::ExtractValueFromSysCtl(
const char* word)
{
size_t pos = this->SysCtlBuffer.find(word);
- if (pos != this->SysCtlBuffer.npos) {
+ if (pos != std::string::npos) {
pos = this->SysCtlBuffer.find(": ", pos);
size_t pos2 = this->SysCtlBuffer.find("\n", pos);
- if (pos != this->SysCtlBuffer.npos && pos2 != this->SysCtlBuffer.npos) {
+ if (pos != std::string::npos && pos2 != std::string::npos) {
return this->SysCtlBuffer.substr(pos + 2, pos2 - pos - 2);
}
}
@@ -4675,14 +4661,14 @@ std::string SystemInformationImplementation::ParseValueFromKStat(
args.push_back("-p");
std::string command = arguments;
- size_t start = command.npos;
+ size_t start = std::string::npos;
size_t pos = command.find(' ', 0);
- while (pos != command.npos) {
+ while (pos != std::string::npos) {
bool inQuotes = false;
// Check if we are between quotes
size_t b0 = command.find('"', 0);
size_t b1 = command.find('"', b0 + 1);
- while (b0 != command.npos && b1 != command.npos && b1 > b0) {
+ while (b0 != std::string::npos && b1 != std::string::npos && b1 > b0) {
if (pos > b0 && pos < b1) {
inQuotes = true;
break;
@@ -4696,7 +4682,7 @@ std::string SystemInformationImplementation::ParseValueFromKStat(
// Remove the quotes if any
size_t quotes = arg.find('"');
- while (quotes != arg.npos) {
+ while (quotes != std::string::npos) {
arg.erase(quotes, 1);
quotes = arg.find('"');
}
@@ -4879,11 +4865,11 @@ bool SystemInformationImplementation::QueryQNXMemory()
args.clear();
size_t pos = buffer.find("System RAM:");
- if (pos == buffer.npos)
+ if (pos == std::string::npos)
return false;
pos = buffer.find(":", pos);
size_t pos2 = buffer.find("M (", pos);
- if (pos2 == buffer.npos)
+ if (pos2 == std::string::npos)
return false;
pos++;
@@ -4937,11 +4923,11 @@ bool SystemInformationImplementation::QueryQNXProcessor()
args.clear();
size_t pos = buffer.find("Processor1:");
- if (pos == buffer.npos)
+ if (pos == std::string::npos)
return false;
size_t pos2 = buffer.find("MHz", pos);
- if (pos2 == buffer.npos)
+ if (pos2 == std::string::npos)
return false;
size_t pos3 = pos2;
@@ -4951,9 +4937,9 @@ bool SystemInformationImplementation::QueryQNXProcessor()
this->CPUSpeedInMHz = atoi(buffer.substr(pos3 + 1, pos2 - pos3 - 1).c_str());
pos2 = buffer.find(" Stepping", pos);
- if (pos2 != buffer.npos) {
+ if (pos2 != std::string::npos) {
pos2 = buffer.find(" ", pos2 + 1);
- if (pos2 != buffer.npos && pos2 < pos3) {
+ if (pos2 != std::string::npos && pos2 < pos3) {
this->ChipID.Revision =
atoi(buffer.substr(pos2 + 1, pos3 - pos2).c_str());
}
@@ -4963,7 +4949,7 @@ bool SystemInformationImplementation::QueryQNXProcessor()
do {
pos = buffer.find("\nProcessor", pos + 1);
++this->NumberOfPhysicalCPU;
- } while (pos != buffer.npos);
+ } while (pos != std::string::npos);
this->NumberOfLogicalCPU = 1;
return true;
diff --git a/thirdparty/KWSys/adios2sys/SystemInformation.hxx.in b/thirdparty/KWSys/adios2sys/SystemInformation.hxx.in
index 54e7fc10b93e8fff4a389319d934955ec4234018..516c505c595f9ca3a1105b939ac6e07641653452 100644
--- a/thirdparty/KWSys/adios2sys/SystemInformation.hxx.in
+++ b/thirdparty/KWSys/adios2sys/SystemInformation.hxx.in
@@ -25,6 +25,33 @@ class @KWSYS_NAMESPACE@_EXPORT SystemInformation
friend class SystemInformationImplementation;
SystemInformationImplementation* Implementation;
+public:
+ // possible parameter values for DoesCPUSupportFeature()
+ static const long int CPU_FEATURE_MMX = 1 << 0;
+ static const long int CPU_FEATURE_MMX_PLUS = 1 << 1;
+ static const long int CPU_FEATURE_SSE = 1 << 2;
+ static const long int CPU_FEATURE_SSE2 = 1 << 3;
+ static const long int CPU_FEATURE_AMD_3DNOW = 1 << 4;
+ static const long int CPU_FEATURE_AMD_3DNOW_PLUS = 1 << 5;
+ static const long int CPU_FEATURE_IA64 = 1 << 6;
+ static const long int CPU_FEATURE_MP_CAPABLE = 1 << 7;
+ static const long int CPU_FEATURE_HYPERTHREAD = 1 << 8;
+ static const long int CPU_FEATURE_SERIALNUMBER = 1 << 9;
+ static const long int CPU_FEATURE_APIC = 1 << 10;
+ static const long int CPU_FEATURE_SSE_FP = 1 << 11;
+ static const long int CPU_FEATURE_SSE_MMX = 1 << 12;
+ static const long int CPU_FEATURE_CMOV = 1 << 13;
+ static const long int CPU_FEATURE_MTRR = 1 << 14;
+ static const long int CPU_FEATURE_L1CACHE = 1 << 15;
+ static const long int CPU_FEATURE_L2CACHE = 1 << 16;
+ static const long int CPU_FEATURE_L3CACHE = 1 << 17;
+ static const long int CPU_FEATURE_ACPI = 1 << 18;
+ static const long int CPU_FEATURE_THERMALMONITOR = 1 << 19;
+ static const long int CPU_FEATURE_TEMPSENSEDIODE = 1 << 20;
+ static const long int CPU_FEATURE_FREQUENCYID = 1 << 21;
+ static const long int CPU_FEATURE_VOLTAGEID_FREQUENCY = 1 << 22;
+ static const long int CPU_FEATURE_FPU = 1 << 23;
+
public:
SystemInformation();
~SystemInformation();
diff --git a/thirdparty/KWSys/adios2sys/SystemTools.cxx b/thirdparty/KWSys/adios2sys/SystemTools.cxx
index b6da368c1186c5761d15f4274ec90eea99af12a7..c5bbd416a39e4ee92ad9e08b4cac7a77c85b00f9 100644
--- a/thirdparty/KWSys/adios2sys/SystemTools.cxx
+++ b/thirdparty/KWSys/adios2sys/SystemTools.cxx
@@ -547,15 +547,13 @@ bool SystemTools::HasEnv(const std::string& key)
return SystemTools::HasEnv(key.c_str());
}
-//----------------------------------------------------------------------------
-
#if KWSYS_CXX_HAS_UNSETENV
/* unsetenv("A") removes A from the environment.
On older platforms it returns void instead of int. */
static int kwsysUnPutEnv(const std::string& env)
{
size_t pos = env.find('=');
- if (pos != env.npos) {
+ if (pos != std::string::npos) {
std::string name = env.substr(0, pos);
unsetenv(name.c_str());
} else {
@@ -571,7 +569,7 @@ static int kwsysUnPutEnv(const std::string& env)
{
int err = 0;
size_t pos = env.find('=');
- size_t const len = pos == env.npos ? env.size() : pos;
+ size_t const len = pos == std::string::npos ? env.size() : pos;
size_t const sz = len + 1;
char local_buf[256];
char* buf = sz > sizeof(local_buf) ? (char*)malloc(sz) : local_buf;
@@ -605,7 +603,7 @@ static int kwsysUnPutEnv(std::string const& env)
{
std::wstring wEnv = Encoding::ToWide(env);
size_t const pos = wEnv.find('=');
- size_t const len = pos == wEnv.npos ? wEnv.size() : pos;
+ size_t const len = pos == std::string::npos ? wEnv.size() : pos;
wEnv.resize(len + 1, L'=');
wchar_t* newEnv = _wcsdup(wEnv.c_str());
if (!newEnv) {
@@ -621,7 +619,7 @@ static int kwsysUnPutEnv(std::string const& env)
static int kwsysUnPutEnv(const std::string& env)
{
size_t pos = env.find('=');
- size_t const len = pos == env.npos ? env.size() : pos;
+ size_t const len = pos == std::string::npos ? env.size() : pos;
int in = 0;
int out = 0;
while (environ[in]) {
@@ -639,8 +637,6 @@ static int kwsysUnPutEnv(const std::string& env)
}
#endif
-//----------------------------------------------------------------------------
-
#if KWSYS_CXX_HAS_SETENV
/* setenv("A", "B", 1) will set A=B in the environment and makes its
@@ -648,7 +644,7 @@ static int kwsysUnPutEnv(const std::string& env)
bool SystemTools::PutEnv(const std::string& env)
{
size_t pos = env.find('=');
- if (pos != env.npos) {
+ if (pos != std::string::npos) {
std::string name = env.substr(0, pos);
return setenv(name.c_str(), env.c_str() + pos + 1, 1) == 0;
} else {
@@ -731,8 +727,6 @@ bool SystemTools::UnPutEnv(const std::string& env)
#endif
-//----------------------------------------------------------------------------
-
const char* SystemTools::GetExecutableExtension()
{
#if defined(_WIN32) || defined(__CYGWIN__) || defined(__VMS)
@@ -1144,7 +1138,6 @@ bool SystemTools::SameFile(const std::string& file1, const std::string& file2)
#endif
}
-//----------------------------------------------------------------------------
bool SystemTools::PathExists(const std::string& path)
{
if (path.empty()) {
@@ -1167,7 +1160,6 @@ bool SystemTools::PathExists(const std::string& path)
#endif
}
-//----------------------------------------------------------------------------
bool SystemTools::FileExists(const char* filename)
{
if (!filename) {
@@ -1176,7 +1168,6 @@ bool SystemTools::FileExists(const char* filename)
return SystemTools::FileExists(std::string(filename));
}
-//----------------------------------------------------------------------------
bool SystemTools::FileExists(const std::string& filename)
{
if (filename.empty()) {
@@ -1203,7 +1194,6 @@ bool SystemTools::FileExists(const std::string& filename)
#endif
}
-//----------------------------------------------------------------------------
bool SystemTools::FileExists(const char* filename, bool isFile)
{
if (!filename) {
@@ -1212,7 +1202,6 @@ bool SystemTools::FileExists(const char* filename, bool isFile)
return SystemTools::FileExists(std::string(filename), isFile);
}
-//----------------------------------------------------------------------------
bool SystemTools::FileExists(const std::string& filename, bool isFile)
{
if (SystemTools::FileExists(filename)) {
@@ -1223,7 +1212,6 @@ bool SystemTools::FileExists(const std::string& filename, bool isFile)
return false;
}
-//----------------------------------------------------------------------------
bool SystemTools::TestFileAccess(const char* filename,
TestFilePermissions permissions)
{
@@ -1233,7 +1221,6 @@ bool SystemTools::TestFileAccess(const char* filename,
return SystemTools::TestFileAccess(std::string(filename), permissions);
}
-//----------------------------------------------------------------------------
bool SystemTools::TestFileAccess(const std::string& filename,
TestFilePermissions permissions)
{
@@ -1255,7 +1242,6 @@ bool SystemTools::TestFileAccess(const std::string& filename,
#endif
}
-//----------------------------------------------------------------------------
int SystemTools::Stat(const char* path, SystemTools::Stat_t* buf)
{
if (!path) {
@@ -1265,7 +1251,6 @@ int SystemTools::Stat(const char* path, SystemTools::Stat_t* buf)
return SystemTools::Stat(std::string(path), buf);
}
-//----------------------------------------------------------------------------
int SystemTools::Stat(const std::string& path, SystemTools::Stat_t* buf)
{
if (path.empty()) {
@@ -1287,7 +1272,6 @@ int SystemTools::Stat(const std::string& path, SystemTools::Stat_t* buf)
#endif
}
-//----------------------------------------------------------------------------
#ifdef __CYGWIN__
bool SystemTools::PathCygwinToWin32(const char* path, char* win32_path)
{
@@ -1737,7 +1721,7 @@ std::string SystemTools::CropString(const std::string& s, size_t max_len)
size_t middle = max_len / 2;
n += s.substr(0, middle);
- n += s.substr(s.size() - (max_len - middle), std::string::npos);
+ n += s.substr(s.size() - (max_len - middle));
if (max_len > 2) {
n[middle] = '.';
@@ -1752,7 +1736,6 @@ std::string SystemTools::CropString(const std::string& s, size_t max_len)
return n;
}
-//----------------------------------------------------------------------------
std::vector<kwsys::String> SystemTools::SplitString(const std::string& p,
char sep, bool isPath)
{
@@ -1777,7 +1760,6 @@ std::vector<kwsys::String> SystemTools::SplitString(const std::string& p,
return paths;
}
-//----------------------------------------------------------------------------
int SystemTools::EstimateFormatLength(const char* format, va_list ap)
{
if (!format) {
@@ -1868,7 +1850,7 @@ static void ConvertVMSToUnix(std::string& path)
{
std::string::size_type rootEnd = path.find(":[");
std::string::size_type pathEnd = path.find("]");
- if (rootEnd != path.npos) {
+ if (rootEnd != std::string::npos) {
std::string root = path.substr(0, rootEnd);
std::string pathPart = path.substr(rootEnd + 2, pathEnd - rootEnd - 2);
const char* pathCString = pathPart.c_str();
@@ -2165,7 +2147,6 @@ bool SystemTools::FilesDiffer(const std::string& source,
return false;
}
-//----------------------------------------------------------------------------
/**
* Copy a file named by "source" to the file named by "destination".
*/
@@ -2269,7 +2250,6 @@ bool SystemTools::CopyFileAlways(const std::string& source,
return true;
}
-//----------------------------------------------------------------------------
bool SystemTools::CopyAFile(const std::string& source,
const std::string& destination, bool always)
{
@@ -3550,7 +3530,6 @@ static std::string GetCasePathName(std::string const& pathIn)
}
#endif
-//----------------------------------------------------------------------------
std::string SystemTools::GetActualCaseForPath(const std::string& p)
{
#ifndef _WIN32
@@ -3571,7 +3550,6 @@ std::string SystemTools::GetActualCaseForPath(const std::string& p)
#endif
}
-//----------------------------------------------------------------------------
const char* SystemTools::SplitPathRootComponent(const std::string& p,
std::string* root)
{
@@ -3638,7 +3616,6 @@ const char* SystemTools::SplitPathRootComponent(const std::string& p,
return c;
}
-//----------------------------------------------------------------------------
void SystemTools::SplitPath(const std::string& p,
std::vector<std::string>& components,
bool expand_home_dir)
@@ -3695,13 +3672,11 @@ void SystemTools::SplitPath(const std::string& p,
}
}
-//----------------------------------------------------------------------------
std::string SystemTools::JoinPath(const std::vector<std::string>& components)
{
return SystemTools::JoinPath(components.begin(), components.end());
}
-//----------------------------------------------------------------------------
std::string SystemTools::JoinPath(
std::vector<std::string>::const_iterator first,
std::vector<std::string>::const_iterator last)
@@ -3733,7 +3708,6 @@ std::string SystemTools::JoinPath(
return result;
}
-//----------------------------------------------------------------------------
bool SystemTools::ComparePath(const std::string& c1, const std::string& c2)
{
#if defined(_WIN32) || defined(__APPLE__)
@@ -3749,7 +3723,6 @@ bool SystemTools::ComparePath(const std::string& c1, const std::string& c2)
#endif
}
-//----------------------------------------------------------------------------
bool SystemTools::Split(const std::string& str,
std::vector<std::string>& lines, char separator)
{
@@ -3770,7 +3743,6 @@ bool SystemTools::Split(const std::string& str,
return true;
}
-//----------------------------------------------------------------------------
bool SystemTools::Split(const std::string& str,
std::vector<std::string>& lines)
{
@@ -4354,7 +4326,7 @@ bool SystemTools::GetPermissions(const std::string& file, mode_t& mode)
mode |= S_IFREG;
}
size_t dotPos = file.rfind('.');
- const char* ext = dotPos == file.npos ? 0 : (file.c_str() + dotPos);
+ const char* ext = dotPos == std::string::npos ? 0 : (file.c_str() + dotPos);
if (ext && (Strucmp(ext, ".exe") == 0 || Strucmp(ext, ".com") == 0 ||
Strucmp(ext, ".cmd") == 0 || Strucmp(ext, ".bat") == 0)) {
mode |= (_S_IEXEC | (_S_IEXEC >> 3) | (_S_IEXEC >> 6));
@@ -4707,7 +4679,6 @@ std::string SystemTools::GetOperatingSystemNameAndVersion()
return res;
}
-// ----------------------------------------------------------------------
bool SystemTools::ParseURLProtocol(const std::string& URL,
std::string& protocol,
std::string& dataglom)
@@ -4726,7 +4697,6 @@ bool SystemTools::ParseURLProtocol(const std::string& URL,
return true;
}
-// ----------------------------------------------------------------------
bool SystemTools::ParseURL(const std::string& URL, std::string& protocol,
std::string& username, std::string& password,
std::string& hostname, std::string& dataport,
@@ -4757,7 +4727,6 @@ bool SystemTools::ParseURL(const std::string& URL, std::string& protocol,
return true;
}
-// ----------------------------------------------------------------------
// These must NOT be initialized. Default initialization to zero is
// necessary.
static unsigned int SystemToolsManagerCount;
diff --git a/thirdparty/KWSys/adios2sys/SystemTools.hxx.in b/thirdparty/KWSys/adios2sys/SystemTools.hxx.in
index 0849e1da8feffc93045aa10497438ab00d819748..1672e927face8efd9417f0f03b60cd336c23bffd 100644
--- a/thirdparty/KWSys/adios2sys/SystemTools.hxx.in
+++ b/thirdparty/KWSys/adios2sys/SystemTools.hxx.in
@@ -461,6 +461,10 @@ public:
* produce the original path. Home directory references are
* automatically expanded if expand_home_dir is true and this
* platform supports them.
+ *
+ * This does *not* normalize the input path. All components are
+ * preserved, including empty ones. Typically callers should use
+ * this only on paths that have already been normalized.
*/
static void SplitPath(const std::string& p,
std::vector<std::string>& components,
@@ -469,6 +473,10 @@ public:
/**
* Join components of a path name into a single string. See
* SplitPath for the format of the components.
+ *
+ * This does *not* normalize the input path. All components are
+ * preserved, including empty ones. Typically callers should use
+ * this only on paths that have already been normalized.
*/
static std::string JoinPath(const std::vector<std::string>& components);
static std::string JoinPath(std::vector<std::string>::const_iterator first,
diff --git a/thirdparty/KWSys/adios2sys/Terminal.c b/thirdparty/KWSys/adios2sys/Terminal.c
index c0b7f454b6dd27e47a0a76fd9b6dff0b95db8f8f..eaa5c7d43c2a64ccb362afe2b650811510a80e9a 100644
--- a/thirdparty/KWSys/adios2sys/Terminal.c
+++ b/thirdparty/KWSys/adios2sys/Terminal.c
@@ -9,7 +9,6 @@
#include "Terminal.h.in"
#endif
-/*--------------------------------------------------------------------------*/
/* Configure support for this platform. */
#if defined(_WIN32) || defined(__CYGWIN__)
#define KWSYS_TERMINAL_SUPPORT_CONSOLE
@@ -18,7 +17,6 @@
#define KWSYS_TERMINAL_ISATTY_WORKS
#endif
-/*--------------------------------------------------------------------------*/
/* Include needed system APIs. */
#include <stdarg.h> /* va_list */
@@ -36,7 +34,6 @@
#include <sys/stat.h> /* fstat */
#endif
-/*--------------------------------------------------------------------------*/
static int kwsysTerminalStreamIsVT100(FILE* stream, int default_vt100,
int default_tty);
static void kwsysTerminalSetVT100Color(FILE* stream, int color);
@@ -47,7 +44,6 @@ static void kwsysTerminalSetConsoleColor(HANDLE hOut,
FILE* stream, int color);
#endif
-/*--------------------------------------------------------------------------*/
void kwsysTerminal_cfprintf(int color, FILE* stream, const char* format, ...)
{
/* Setup the stream with the given color if possible. */
@@ -89,7 +85,6 @@ void kwsysTerminal_cfprintf(int color, FILE* stream, const char* format, ...)
}
}
-/*--------------------------------------------------------------------------*/
/* Detect cases when a stream is definitely not interactive. */
#if !defined(KWSYS_TERMINAL_ISATTY_WORKS)
static int kwsysTerminalStreamIsNotInteractive(FILE* stream)
@@ -106,7 +101,6 @@ static int kwsysTerminalStreamIsNotInteractive(FILE* stream)
}
#endif
-/*--------------------------------------------------------------------------*/
/* List of terminal names known to support VT100 color escape sequences. */
static const char* kwsysTerminalVT100Names[] = { "Eterm",
"ansi",
@@ -162,7 +156,6 @@ static const char* kwsysTerminalVT100Names[] = { "Eterm",
"xterm-termite",
0 };
-/*--------------------------------------------------------------------------*/
/* Detect whether a stream is displayed in a VT100-compatible terminal. */
static int kwsysTerminalStreamIsVT100(FILE* stream, int default_vt100,
int default_tty)
@@ -214,7 +207,6 @@ static int kwsysTerminalStreamIsVT100(FILE* stream, int default_vt100,
#endif
}
-/*--------------------------------------------------------------------------*/
/* VT100 escape sequence strings. */
#define KWSYS_TERMINAL_VT100_NORMAL "\33[0m"
#define KWSYS_TERMINAL_VT100_BOLD "\33[1m"
@@ -238,7 +230,6 @@ static int kwsysTerminalStreamIsVT100(FILE* stream, int default_vt100,
#define KWSYS_TERMINAL_VT100_BACKGROUND_CYAN "\33[46m"
#define KWSYS_TERMINAL_VT100_BACKGROUND_WHITE "\33[47m"
-/*--------------------------------------------------------------------------*/
/* Write VT100 escape sequences to the stream for the given color. */
static void kwsysTerminalSetVT100Color(FILE* stream, int color)
{
@@ -307,7 +298,6 @@ static void kwsysTerminalSetVT100Color(FILE* stream, int color)
}
}
-/*--------------------------------------------------------------------------*/
#if defined(KWSYS_TERMINAL_SUPPORT_CONSOLE)
#define KWSYS_TERMINAL_MASK_FOREGROUND \
diff --git a/thirdparty/KWSys/adios2sys/kwsysPlatformTestsC.c b/thirdparty/KWSys/adios2sys/kwsysPlatformTestsC.c
index d12fac0b6653aa8da1a7bebc8b08fbee040e1e33..64a361bbed1ebfd04af6bb21d163a3f85da9e2da 100644
--- a/thirdparty/KWSys/adios2sys/kwsysPlatformTestsC.c
+++ b/thirdparty/KWSys/adios2sys/kwsysPlatformTestsC.c
@@ -27,7 +27,6 @@
main(int argc, char* argv[])
#endif
-/*--------------------------------------------------------------------------*/
#ifdef TEST_KWSYS_C_HAS_PTRDIFF_T
#include <stddef.h>
int f(ptrdiff_t n)
@@ -43,7 +42,6 @@ int KWSYS_PLATFORM_TEST_C_MAIN()
}
#endif
-/*--------------------------------------------------------------------------*/
#ifdef TEST_KWSYS_C_HAS_SSIZE_T
#include <unistd.h>
int f(ssize_t n)
@@ -57,7 +55,6 @@ int KWSYS_PLATFORM_TEST_C_MAIN()
}
#endif
-/*--------------------------------------------------------------------------*/
#ifdef TEST_KWSYS_C_TYPE_MACROS
char* info_macros =
#if defined(__SIZEOF_SHORT__)
diff --git a/thirdparty/KWSys/adios2sys/testConsoleBuf.cxx b/thirdparty/KWSys/adios2sys/testConsoleBuf.cxx
index 3b8cdab69aae85eca1e09c076e8b60b08ea631ed..816a4338e69a941a343d1f330070a581d4630436 100644
--- a/thirdparty/KWSys/adios2sys/testConsoleBuf.cxx
+++ b/thirdparty/KWSys/adios2sys/testConsoleBuf.cxx
@@ -74,7 +74,6 @@ std::basic_streambuf<wchar_t>* errstream(const wchar_t* unused)
return std::wcerr.rdbuf();
}
-//----------------------------------------------------------------------------
template <typename T>
static void dumpBuffers(const T* expected, const T* received, size_t size)
{
@@ -107,7 +106,6 @@ static void dumpBuffers(const T* expected, const T* received, size_t size)
std::cerr << std::endl;
}
-//----------------------------------------------------------------------------
static bool createProcess(HANDLE hIn, HANDLE hOut, HANDLE hErr)
{
BOOL bInheritHandles = FALSE;
@@ -158,7 +156,6 @@ static bool createProcess(HANDLE hIn, HANDLE hOut, HANDLE hErr)
return success;
}
-//----------------------------------------------------------------------------
static void finishProcess(bool success)
{
if (success) {
@@ -172,7 +169,6 @@ static void finishProcess(bool success)
CloseHandle(processInfo.hThread);
}
-//----------------------------------------------------------------------------
static bool createPipe(PHANDLE readPipe, PHANDLE writePipe)
{
SECURITY_ATTRIBUTES securityAttributes;
@@ -183,7 +179,6 @@ static bool createPipe(PHANDLE readPipe, PHANDLE writePipe)
: true;
}
-//----------------------------------------------------------------------------
static void finishPipe(HANDLE readPipe, HANDLE writePipe)
{
if (readPipe != INVALID_HANDLE_VALUE) {
@@ -194,7 +189,6 @@ static void finishPipe(HANDLE readPipe, HANDLE writePipe)
}
}
-//----------------------------------------------------------------------------
static HANDLE createFile(LPCWSTR fileName)
{
SECURITY_ATTRIBUTES securityAttributes;
@@ -218,7 +212,6 @@ static HANDLE createFile(LPCWSTR fileName)
return file;
}
-//----------------------------------------------------------------------------
static void finishFile(HANDLE file)
{
if (file != INVALID_HANDLE_VALUE) {
@@ -226,8 +219,6 @@ static void finishFile(HANDLE file)
}
}
-//----------------------------------------------------------------------------
-
#ifndef MAPVK_VK_TO_VSC
#define MAPVK_VK_TO_VSC (0)
#endif
@@ -269,7 +260,6 @@ static void writeInputKeyEvent(INPUT_RECORD inputBuffer[], WCHAR chr)
inputBuffer[1].Event.KeyEvent.dwControlKeyState = 0;
}
-//----------------------------------------------------------------------------
static int testPipe()
{
int didFail = 1;
@@ -339,9 +329,8 @@ static int testPipe()
throw std::runtime_error("ReadFile#3 failed!");
}
buffer2[bytesRead] = 0;
- didFail =
- encodedTestString.compare(0, encodedTestString.npos, buffer2,
- encodedTestString.size()) == 0
+ didFail = encodedTestString.compare(0, std::string::npos, buffer2,
+ encodedTestString.size()) == 0
? 0
: 1;
}
@@ -377,7 +366,6 @@ static int testPipe()
return didFail;
}
-//----------------------------------------------------------------------------
static int testFile()
{
int didFail = 1;
@@ -446,9 +434,8 @@ static int testFile()
throw std::runtime_error("ReadFile#2 failed!");
}
buffer2[bytesRead] = 0;
- didFail =
- encodedTestString.compare(0, encodedTestString.npos, buffer2,
- encodedTestString.size()) == 0
+ didFail = encodedTestString.compare(0, std::string::npos, buffer2,
+ encodedTestString.size()) == 0
? 0
: 1;
}
@@ -487,7 +474,6 @@ static int testFile()
#define _WIN32_WINNT_VISTA 0x0600
#endif
-//----------------------------------------------------------------------------
static int testConsole()
{
int didFail = 1;
@@ -748,7 +734,6 @@ static int testConsole()
#endif
-//----------------------------------------------------------------------------
int testConsoleBuf(int, char* [])
{
int ret = 0;
diff --git a/thirdparty/KWSys/adios2sys/testConsoleBufChild.cxx b/thirdparty/KWSys/adios2sys/testConsoleBufChild.cxx
index 83bf545c536b85f029d3b0ba6c3639405784aaa9..6a743edcda18b11bd5b477807ccfa1647c78621c 100644
--- a/thirdparty/KWSys/adios2sys/testConsoleBufChild.cxx
+++ b/thirdparty/KWSys/adios2sys/testConsoleBufChild.cxx
@@ -16,7 +16,6 @@
#include "testConsoleBuf.hxx"
-//----------------------------------------------------------------------------
int main(int argc, const char* argv[])
{
#if defined(_WIN32)
diff --git a/thirdparty/KWSys/adios2sys/testEncoding.cxx b/thirdparty/KWSys/adios2sys/testEncoding.cxx
index 457e8a896ec3b3ffb32ec77fad58bd37ab80f820..2c5ef46eb96a7cd7b6eaa68c497a1f0f6e3adde4 100644
--- a/thirdparty/KWSys/adios2sys/testEncoding.cxx
+++ b/thirdparty/KWSys/adios2sys/testEncoding.cxx
@@ -22,7 +22,6 @@
#include "Encoding.hxx.in"
#endif
-//----------------------------------------------------------------------------
static const unsigned char helloWorldStrings[][32] = {
// English
{ 'H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', 0 },
@@ -50,7 +49,6 @@ static const unsigned char helloWorldStrings[][32] = {
{ 0 }
};
-//----------------------------------------------------------------------------
static int testHelloWorldEncoding()
{
int ret = 0;
@@ -262,7 +260,6 @@ static int testToWindowsExtendedPath()
#endif
}
-//----------------------------------------------------------------------------
int testEncoding(int, char* [])
{
const char* loc = setlocale(LC_ALL, "");
diff --git a/thirdparty/KWSys/adios2sys/testFStream.cxx b/thirdparty/KWSys/adios2sys/testFStream.cxx
index 670f5e7685b83faa820d231c129dce1df9fc7b68..a92a781c38f94b2fd04a199dd9dc1d0f5454f06b 100644
--- a/thirdparty/KWSys/adios2sys/testFStream.cxx
+++ b/thirdparty/KWSys/adios2sys/testFStream.cxx
@@ -20,7 +20,6 @@
#include <iostream>
-//----------------------------------------------------------------------------
static int testNoFile()
{
kwsys::ifstream in_file("NoSuchFile.txt");
@@ -69,7 +68,6 @@ static unsigned char file_data[num_test_files][max_test_file_size] = {
0x72, 0x00, 0x00, 0x00, 0x6C, 0x00, 0x00, 0x00, 0x64 },
};
-//----------------------------------------------------------------------------
static int testBOM()
{
// test various encodings in binary mode
@@ -104,7 +102,6 @@ static int testBOM()
return 0;
}
-//----------------------------------------------------------------------------
int testFStream(int, char* [])
{
int ret = 0;
diff --git a/thirdparty/KWSys/adios2sys/testSystemTools.cxx b/thirdparty/KWSys/adios2sys/testSystemTools.cxx
index d11bcaef87563d92f8b4f98ecdfa7249d0eaff49..e6fbf6cdafb8ae2197ac3b815ff8b3e5c6535b72 100644
--- a/thirdparty/KWSys/adios2sys/testSystemTools.cxx
+++ b/thirdparty/KWSys/adios2sys/testSystemTools.cxx
@@ -35,7 +35,6 @@
typedef unsigned short mode_t;
#endif
-//----------------------------------------------------------------------------
static const char* toUnixPaths[][2] = {
{ "/usr/local/bin/passwd", "/usr/local/bin/passwd" },
{ "/usr/lo cal/bin/pa sswd", "/usr/lo cal/bin/pa sswd" },
@@ -55,7 +54,8 @@ static const char* toUnixPaths[][2] = {
{ 0, 0 }
};
-static bool CheckConvertToUnixSlashes(std::string input, std::string output)
+static bool CheckConvertToUnixSlashes(std::string const& input,
+ std::string const& output)
{
std::string result = input;
kwsys::SystemTools::ConvertToUnixSlashes(result);
@@ -67,14 +67,14 @@ static bool CheckConvertToUnixSlashes(std::string input, std::string output)
return true;
}
-//----------------------------------------------------------------------------
static const char* checkEscapeChars[][4] = { { "1 foo 2 bar 2", "12", "\\",
"\\1 foo \\2 bar \\2" },
{ " {} ", "{}", "#", " #{#} " },
{ 0, 0, 0, 0 } };
-static bool CheckEscapeChars(std::string input, const char* chars_to_escape,
- char escape_char, std::string output)
+static bool CheckEscapeChars(std::string const& input,
+ const char* chars_to_escape, char escape_char,
+ std::string const& output)
{
std::string result = kwsys::SystemTools::EscapeChars(
input.c_str(), chars_to_escape, escape_char);
@@ -86,7 +86,6 @@ static bool CheckEscapeChars(std::string input, const char* chars_to_escape,
return true;
}
-//----------------------------------------------------------------------------
static bool CheckFileOperations()
{
bool res = true;
@@ -469,7 +468,6 @@ static bool CheckFileOperations()
return res;
}
-//----------------------------------------------------------------------------
static bool CheckStringOperations()
{
bool res = true;
@@ -613,8 +611,6 @@ static bool CheckStringOperations()
return res;
}
-//----------------------------------------------------------------------------
-
static bool CheckPutEnv(const std::string& env, const char* name,
const char* value)
{
@@ -842,7 +838,6 @@ static bool CheckGetLineFromStream()
return ret;
}
-//----------------------------------------------------------------------------
int testSystemTools(int, char* [])
{
bool res = true;
diff --git a/thirdparty/KWSys/update.sh b/thirdparty/KWSys/update.sh
index 44b7d9cba938968d4e8448c6d0fd1485d00d7882..53d24129ec3b2b9962517cc603e15079c74e8441 100755
--- a/thirdparty/KWSys/update.sh
+++ b/thirdparty/KWSys/update.sh
@@ -8,19 +8,25 @@ readonly name="KWSys"
readonly ownership="KWSys Upstream <kwrobot@kitware.com>"
readonly subtree="thirdparty/KWSys/adios2sys"
#readonly repo="https://gitlab.kitware.com/utils/kwsys.git"
-#readonly tag="0c4e58ec"
+#readonly tag="master"
-# This commit contains a patch so suppress noisy warnings. Use 'master' off
-# the main repo instead once its been merged
+# This commit contains a patch to allow object libraries for kwsys.
+# Use 'master' off the main repo instead once its been merged
readonly repo="https://gitlab.kitware.com/chuck.atkins/kwsys.git"
-readonly tag="0c4e58ec"
+readonly tag="ab645c9"
readonly shortlog="true"
readonly paths="
"
+git_archive_no_attributes () {
+ find . -name gitattributes | xargs git rm -f
+ git archive --prefix="$name-reduced/" HEAD -- $paths | \
+ tar -C "$extractdir" -x
+}
+
extract_source () {
- git_archive
+ git_archive_no_attributes
}
. "${BASH_SOURCE%/*}/../update-common.sh"