Merge branch 'upstream-kwsys' into update-kwsys

Source/kwsys/CMakeLists.txt

@@ -35,15 +35,6 @@
 #      SET(KWSYS_HEADER_ROOT ${PROJECT_BINARY_DIR})
 #      INCLUDE_DIRECTORIES(${PROJECT_BINARY_DIR})
 #
-#  KWSYS_IOS_FORCE_OLD = Force use of old non-ANSI C++ streams even if
-#                        new streams are available.  This may be used
-#                        by projects that cannot configure their
-#                        streams library.
-#    Example:
-#
-#      SET(KWSYS_IOS_FORCE_OLD 1)
-#
-#
 # Optional settings to setup install rules are as follows:
 #
 #  KWSYS_INSTALL_BIN_DIR     = The installation target directories into
@@ -351,105 +342,6 @@ ENDIF()
 # capabilities and parent project's request.  Enforce 0/1 as only
 # possible values for configuration into Configure.hxx.
 
-KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAVE_STD
-  "Checking whether STL classes are in std namespace" DIRECT)
-
-IF(KWSYS_IOS_FORCE_OLD)
-  SET(KWSYS_IOS_USE_ANSI 0)
-ELSE()
-  KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_USE_ANSI
-    "Checking whether ANSI stream headers are available" DIRECT)
-ENDIF()
-
-IF(KWSYS_IOS_USE_ANSI)
-  KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_HAVE_STD
-    "Checking whether ANSI streams are in std namespace" DIRECT)
-  KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_USE_SSTREAM
-    "Checking whether ANSI string stream is available" DIRECT)
-ELSE()
-  SET(KWSYS_IOS_HAVE_STD 0)
-  SET(KWSYS_IOS_USE_SSTREAM 0)
-ENDIF()
-
-IF(KWSYS_IOS_USE_SSTREAM)
-  SET(KWSYS_IOS_USE_STRSTREAM_H 0)
-  SET(KWSYS_IOS_USE_STRSTREA_H 0)
-ELSE()
-  KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_USE_STRSTREAM_H
-    "Checking whether strstream.h is available" DIRECT)
-  IF(KWSYS_IOS_USE_STRSTREAM_H)
-    SET(KWSYS_IOS_USE_STRSTREA_H 0)
-  ELSE()
-    KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_USE_STRSTREA_H
-      "Checking whether strstrea.h is available" DIRECT)
-  ENDIF()
-ENDIF()
-
-KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_CSTDDEF
-  "Checking whether header cstddef is available" DIRECT)
-
-SET(KWSYS_PLATFORM_CXX_TEST_DEFINES
-  -DKWSYS_STL_HAVE_STD=${KWSYS_STL_HAVE_STD})
-KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_STRING_HAVE_NEQ_CHAR
-  "Checking whether stl string has operator!= for char*" DIRECT)
-KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ITERATOR_TRAITS
-  "Checking whether stl has iterator_traits" DIRECT)
-IF(KWSYS_STL_HAS_ITERATOR_TRAITS)
-  SET(KWSYS_STL_HAS_ITERATOR_CATEGORY 0)
-  SET(KWSYS_STL_HAS___ITERATOR_CATEGORY 0)
-ELSE()
-  KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ITERATOR_CATEGORY
-    "Checking whether stl has old iterator_category" DIRECT)
-  IF(KWSYS_STL_HAS_ITERATOR_CATEGORY)
-    SET(KWSYS_STL_HAS___ITERATOR_CATEGORY 0)
-  ELSE()
-    KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS___ITERATOR_CATEGORY
-      "Checking whether stl has internal __iterator_category" DIRECT)
-  ENDIF()
-ENDIF()
-KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ALLOCATOR_TEMPLATE
-  "Checking whether stl has standard template allocator" DIRECT)
-IF(KWSYS_STL_HAS_ALLOCATOR_TEMPLATE)
-  SET(KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE 0)
-  KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ALLOCATOR_REBIND
-    "Checking for rebind member of stl allocator" DIRECT)
-  KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
-    "Checking for non-standard argument to stl allocator<>::max_size" DIRECT)
-ELSE()
-  KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE
-    "Checking whether stl has old non-template allocator" DIRECT)
-  SET(KWSYS_STL_HAS_ALLOCATOR_REBIND 0)
-  SET(KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT 0)
-ENDIF()
-KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_HAS_ALLOCATOR_OBJECTS
-  "Checking whether stl containers support allocator objects." DIRECT)
-IF(KWSYS_IOS_USE_ANSI AND NOT WATCOM)
-  # ANSI streams always have string operators.
-  SET(KWSYS_STL_STRING_HAVE_OSTREAM 1)
-  SET(KWSYS_STL_STRING_HAVE_ISTREAM 1)
-ELSE()
-  # There may not be string operators for old streams.
-  KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_STRING_HAVE_OSTREAM
-    "Checking whether stl string has ostream operator<<" DIRECT)
-  KWSYS_PLATFORM_CXX_TEST(KWSYS_STL_STRING_HAVE_ISTREAM
-    "Checking whether stl string has istream operator>>" DIRECT)
-ENDIF()
-SET(KWSYS_PLATFORM_CXX_TEST_DEFINES
-  -DKWSYS_IOS_USE_ANSI=${KWSYS_IOS_USE_ANSI}
-  -DKWSYS_IOS_HAVE_STD=${KWSYS_IOS_HAVE_STD})
-KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_HAVE_BINARY
-  "Checking whether ios has binary openmode" DIRECT)
-SET(KWSYS_PLATFORM_CXX_TEST_DEFINES)
-
-KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS
-  "Checking whether \"<>\" is needed for template friends" INVERT)
-KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_MEMBER_TEMPLATES
-  "Checking for member template support" DIRECT)
-KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_FULL_SPECIALIZATION
-  "Checking for standard template specialization syntax" DIRECT)
-KWSYS_PLATFORM_CXX_TEST(KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
-  "Checking whether argument dependent lookup is supported" DIRECT)
-
 IF(UNIX)
   KWSYS_PLATFORM_CXX_TEST(KWSYS_STAT_HAS_ST_MTIM
     "Checking whether struct stat has st_mtim member" DIRECT)
@@ -558,9 +450,6 @@ ENDIF()
 
 IF(KWSYS_USE_IOStream)
   # Determine whether iostreams support long long.
-  SET(KWSYS_PLATFORM_CXX_TEST_DEFINES
-    -DKWSYS_IOS_USE_ANSI=${KWSYS_IOS_USE_ANSI}
-    -DKWSYS_IOS_HAVE_STD=${KWSYS_IOS_HAVE_STD})
   IF(KWSYS_CXX_HAS_LONG_LONG)
     KWSYS_PLATFORM_CXX_TEST(KWSYS_IOS_HAS_ISTREAM_LONG_LONG
       "Checking if istream supports long long" DIRECT)
@@ -579,7 +468,6 @@ IF(KWSYS_USE_IOStream)
     SET(KWSYS_IOS_HAS_ISTREAM___INT64 0)
     SET(KWSYS_IOS_HAS_OSTREAM___INT64 0)
   ENDIF()
-  SET(KWSYS_PLATFORM_CXX_TEST_DEFINES)
 ENDIF()
 
 IF(KWSYS_NAMESPACE MATCHES "^kwsys$")
@@ -831,84 +719,6 @@ IF(KWSYS_INSTALL_DOC_DIR)
     ${KWSYS_INSTALL_LICENSE_OPTIONS})
 ENDIF()
 
-#-----------------------------------------------------------------------------
-# Create STL header wrappers to block warnings in the STL headers and
-# give standard names by which they may be included.
-SET(KWSYS_STL_HEADER_EXTRA_string 1)
-FOREACH(header
-  algorithm
-  deque
-  exception
-  functional
-  iterator
-  list
-  map
-  memory
-  new
-  numeric
-  queue
-  set
-  stack
-  stdexcept
-  string
-  utility
-  vector
-  )
-  # Configure the header wrapper.
-  SET(KWSYS_STL_HEADER "${header}")
-  IF(KWSYS_STL_HEADER_EXTRA_${header})
-    SET(KWSYS_STL_HEADER_EXTRA
-      "#define ${KWSYS_NAMESPACE}_stl_${header}_including_hxx\n# include <${KWSYS_NAMESPACE}/stl/${header}.hxx>\n#undef ${KWSYS_NAMESPACE}_stl_${header}_including_hxx\n")
-    CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/kwsys_stl_${header}.hxx.in
-                   ${KWSYS_HEADER_DIR}/stl/${header}.hxx
-                   @ONLY IMMEDIATE)
-    IF(KWSYS_INSTALL_INCLUDE_DIR)
-      INSTALL(FILES ${KWSYS_HEADER_DIR}/stl/${header}.hxx
-        DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}/stl
-        ${KWSYS_INSTALL_INCLUDE_OPTIONS})
-    ENDIF()
-  ELSE()
-    SET(KWSYS_STL_HEADER_EXTRA "")
-  ENDIF()
-  CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/kwsys_stl.hxx.in
-                 ${KWSYS_HEADER_DIR}/stl/${header}
-                 @ONLY IMMEDIATE)
-
-  # Create an install target for the header wrapper.
-  IF(KWSYS_INSTALL_INCLUDE_DIR)
-    INSTALL(FILES ${KWSYS_HEADER_DIR}/stl/${header}
-      DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}/stl
-      ${KWSYS_INSTALL_INCLUDE_OPTIONS})
-  ENDIF()
-ENDFOREACH()
-
-# Provide cstddef header.
-CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/kwsys_cstddef.hxx.in
-               ${KWSYS_HEADER_DIR}/cstddef
-               @ONLY IMMEDIATE)
-IF(KWSYS_INSTALL_INCLUDE_DIR)
-  INSTALL(FILES ${KWSYS_HEADER_DIR}/cstddef
-    DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}
-    ${KWSYS_INSTALL_INCLUDE_OPTIONS})
-ENDIF()
-
-#-----------------------------------------------------------------------------
-# Create streams header wrappers to give standard names by which they
-# may be included.
-FOREACH(header iostream fstream sstream iosfwd)
-  # Configure the header wrapper.
-  CONFIGURE_FILE(${PROJECT_SOURCE_DIR}/kwsys_ios_${header}.h.in
-                 ${KWSYS_HEADER_DIR}/ios/${header}
-                 @ONLY IMMEDIATE)
-
-  # Create an install target for the header wrapper.
-  IF(KWSYS_INSTALL_INCLUDE_DIR)
-    INSTALL(FILES ${KWSYS_HEADER_DIR}/ios/${header}
-      DESTINATION ${KWSYS_INSTALL_INCLUDE_DIR}/${KWSYS_NAMESPACE}/ios
-      ${KWSYS_INSTALL_INCLUDE_OPTIONS})
-  ENDIF()
-ENDFOREACH()
-
 #-----------------------------------------------------------------------------
 # Build a list of classes and headers we need to implement the
 # selected components.  Initialize with required components.

Source/kwsys/CommandLineArguments.cxx

@@ -15,22 +15,19 @@
 #include KWSYS_HEADER(Configure.hxx)
 #include KWSYS_HEADER(String.hxx)
 
-#include KWSYS_HEADER(stl/vector)
-#include KWSYS_HEADER(stl/map)
-#include KWSYS_HEADER(stl/set)
-#include KWSYS_HEADER(ios/sstream)
-#include KWSYS_HEADER(ios/iostream)
-
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
 # include "CommandLineArguments.hxx.in"
 # include "Configure.hxx.in"
-# include "kwsys_stl.hxx.in"
-# include "kwsys_ios_sstream.h.in"
-# include "kwsys_ios_iostream.h.in"
 #endif
 
+#include <vector>
+#include <map>
+#include <set>
+#include <sstream>
+#include <iostream>
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -45,7 +42,7 @@
 
 #if 0
 #  define CommandLineArguments_DEBUG(x) \
-  kwsys_ios::cout << __LINE__ << " CLA: " << x << kwsys_ios::endl
+  std::cout << __LINE__ << " CLA: " << x << std::endl
 #else
 #  define CommandLineArguments_DEBUG(x)
 #endif
@@ -67,11 +64,11 @@ struct CommandLineArgumentsCallbackStructure
 };
  
 class CommandLineArgumentsVectorOfStrings : 
-  public kwsys_stl::vector<kwsys::String> {};
+  public std::vector<kwsys::String> {};
 class CommandLineArgumentsSetOfStrings :
-  public kwsys_stl::set<kwsys::String> {};
+  public std::set<kwsys::String> {};
 class CommandLineArgumentsMapOfStrucs : 
-  public kwsys_stl::map<kwsys::String,
+  public std::map<kwsys::String,
     CommandLineArgumentsCallbackStructure> {};
 
 class CommandLineArgumentsInternal
@@ -152,8 +149,8 @@ void CommandLineArguments::ProcessArgument(const char* arg)
 
 //----------------------------------------------------------------------------
 bool CommandLineArguments::GetMatchedArguments(
-  kwsys_stl::vector<kwsys_stl::string>* matches,
-  const kwsys_stl::string& arg)
+  std::vector<std::string>* matches,
+  const std::string& arg)
 {
   matches->clear();
   CommandLineArguments::Internal::CallbacksMap::iterator it;
@@ -184,15 +181,15 @@ bool CommandLineArguments::GetMatchedArguments(
 //----------------------------------------------------------------------------
 int CommandLineArguments::Parse()
 {
-  kwsys_stl::vector<kwsys_stl::string>::size_type cc;
-  kwsys_stl::vector<kwsys_stl::string> matches;
+  std::vector<std::string>::size_type cc;
+  std::vector<std::string> matches;
   if ( this->StoreUnusedArgumentsFlag )
     {
     this->Internals->UnusedArguments.clear();
     }
   for ( cc = 0; cc < this->Internals->Argv.size(); cc ++ )
     {
-    const kwsys_stl::string& arg = this->Internals->Argv[cc]; 
+    const std::string& arg = this->Internals->Argv[cc];
     CommandLineArguments_DEBUG("Process argument: " << arg);
     this->Internals->LastArgument = cc;
     if ( this->GetMatchedArguments(&matches, arg) )
@@ -214,7 +211,7 @@ int CommandLineArguments::Parse()
       // additional value
       CommandLineArgumentsCallbackStructure *cs 
         = &this->Internals->Callbacks[matches[maxidx]];
-      const kwsys_stl::string& sarg = matches[maxidx];
+      const std::string& sarg = matches[maxidx];
       if ( cs->Argument != sarg )
         {
         abort();
@@ -267,7 +264,7 @@ int CommandLineArguments::Parse()
         CommandLineArguments_DEBUG("This is a multi argument: " << arg);
         for (cc++; cc < this->Internals->Argv.size(); ++ cc )
           {
-          const kwsys_stl::string& marg = this->Internals->Argv[cc];
+          const std::string& marg = this->Internals->Argv[cc];
           CommandLineArguments_DEBUG(" check multi argument value: " << marg);
           if ( this->GetMatchedArguments(&matches, marg) )
             {
@@ -288,7 +285,7 @@ int CommandLineArguments::Parse()
           }
         break;
       default:
-        kwsys_ios::cerr << "Got unknown argument type: \"" << cs->ArgumentType << "\"" << kwsys_ios::endl;
+        std::cerr << "Got unknown argument type: \"" << cs->ArgumentType << "\"" << std::endl;
         this->Internals->LastArgument --;
         return 0;
         }
@@ -313,7 +310,7 @@ int CommandLineArguments::Parse()
         }
       else
         {
-        kwsys_ios::cerr << "Got unknown argument: \"" << arg << "\"" << kwsys_ios::endl;
+        std::cerr << "Got unknown argument: \"" << arg << "\"" << std::endl;
         this->Internals->LastArgument --;
         return 0;
         }
@@ -430,13 +427,13 @@ CommandLineArgumentsAddArgumentMacro(BOOL,       bool)
 CommandLineArgumentsAddArgumentMacro(INT,        int)
 CommandLineArgumentsAddArgumentMacro(DOUBLE,     double)
 CommandLineArgumentsAddArgumentMacro(STRING,     char*)
-CommandLineArgumentsAddArgumentMacro(STL_STRING, kwsys_stl::string)
+CommandLineArgumentsAddArgumentMacro(STL_STRING, std::string)
 
-CommandLineArgumentsAddArgumentMacro(VECTOR_BOOL,       kwsys_stl::vector<bool>)
-CommandLineArgumentsAddArgumentMacro(VECTOR_INT,        kwsys_stl::vector<int>)
-CommandLineArgumentsAddArgumentMacro(VECTOR_DOUBLE,     kwsys_stl::vector<double>)
-CommandLineArgumentsAddArgumentMacro(VECTOR_STRING,     kwsys_stl::vector<char*>)
-CommandLineArgumentsAddArgumentMacro(VECTOR_STL_STRING, kwsys_stl::vector<kwsys_stl::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>)
 
 //----------------------------------------------------------------------------
 #define CommandLineArgumentsAddBooleanArgumentMacro(type, ctype) \
@@ -451,7 +448,7 @@ CommandLineArgumentsAddBooleanArgumentMacro(BOOL,       bool)
 CommandLineArgumentsAddBooleanArgumentMacro(INT,        int)
 CommandLineArgumentsAddBooleanArgumentMacro(DOUBLE,     double)
 CommandLineArgumentsAddBooleanArgumentMacro(STRING,     char*)
-CommandLineArgumentsAddBooleanArgumentMacro(STL_STRING, kwsys_stl::string)
+CommandLineArgumentsAddBooleanArgumentMacro(STL_STRING, std::string)
 
 //----------------------------------------------------------------------------
 void CommandLineArguments::SetClientData(void* client_data)
@@ -518,12 +515,12 @@ unsigned int CommandLineArguments::GetLastArgument()
 //----------------------------------------------------------------------------
 void CommandLineArguments::GenerateHelp()
 {
-  kwsys_ios::ostringstream str;
+  std::ostringstream str;
   
   // Collapse all arguments into the map of vectors of all arguments that do
   // the same thing.
   CommandLineArguments::Internal::CallbacksMap::iterator it;
-  typedef kwsys_stl::map<CommandLineArguments::Internal::String, 
+  typedef std::map<CommandLineArguments::Internal::String,
      CommandLineArguments::Internal::SetOfStrings > MapArgs;
   MapArgs mp;
   MapArgs::iterator mpit, smpit;
@@ -604,7 +601,7 @@ void CommandLineArguments::GenerateHelp()
     CommandLineArguments::Internal::SetOfStrings::iterator sit;
     for ( sit = mpit->second.begin(); sit != mpit->second.end(); sit++ )
       {
-      str << kwsys_ios::endl;
+      str << std::endl;
       char argument[100];
       sprintf(argument, "%s", sit->c_str());
       switch ( this->Internals->Callbacks[*sit].ArgumentType )
@@ -658,8 +655,8 @@ void CommandLineArguments::GenerateHelp()
           skip = cc;
           }
         }
-      str.write(ptr, static_cast<kwsys_ios::streamsize>(skip));
-      str << kwsys_ios::endl;
+      str.write(ptr, static_cast<std::streamsize>(skip));
+      str << std::endl;
       ptr += skip;
       len -= skip;
       cnt ++;
@@ -680,7 +677,7 @@ void CommandLineArguments::GenerateHelp()
 
 //----------------------------------------------------------------------------
 void CommandLineArguments::PopulateVariable(
-  bool* variable, const kwsys_stl::string& value)
+  bool* variable, const std::string& value)
 {
   if ( value == "1" || value == "ON" || value == "on" || value == "On" ||
     value == "TRUE" || value == "true" || value == "True" ||
@@ -696,7 +693,7 @@ void CommandLineArguments::PopulateVariable(
 
 //----------------------------------------------------------------------------
 void CommandLineArguments::PopulateVariable(
-  int* variable, const kwsys_stl::string& value)
+  int* variable, const std::string& value)
 {
   char* res = 0;
   *variable = static_cast<int>(strtol(value.c_str(), &res, 10));
@@ -708,7 +705,7 @@ void CommandLineArguments::PopulateVariable(
 
 //----------------------------------------------------------------------------
 void CommandLineArguments::PopulateVariable(
-  double* variable, const kwsys_stl::string& value)
+  double* variable, const std::string& value)
 {
   char* res = 0;
   *variable = strtod(value.c_str(), &res);
@@ -720,7 +717,7 @@ void CommandLineArguments::PopulateVariable(
 
 //----------------------------------------------------------------------------
 void CommandLineArguments::PopulateVariable(
-  char** variable, const kwsys_stl::string& value)
+  char** variable, const std::string& value)
 {
   if ( *variable )
     {
@@ -733,14 +730,14 @@ void CommandLineArguments::PopulateVariable(
 
 //----------------------------------------------------------------------------
 void CommandLineArguments::PopulateVariable(
-  kwsys_stl::string* variable, const kwsys_stl::string& value)
+  std::string* variable, const std::string& value)
 {
   *variable = value;
 }
 
 //----------------------------------------------------------------------------
 void CommandLineArguments::PopulateVariable(
-  kwsys_stl::vector<bool>* variable, const kwsys_stl::string& value)
+  std::vector<bool>* variable, const std::string& value)
 {
   bool val = false;
   if ( value == "1" || value == "ON" || value == "on" || value == "On" ||
@@ -754,7 +751,7 @@ void CommandLineArguments::PopulateVariable(
 
 //----------------------------------------------------------------------------
 void CommandLineArguments::PopulateVariable(
-  kwsys_stl::vector<int>* variable, const kwsys_stl::string& value)
+  std::vector<int>* variable, const std::string& value)
 {
   char* res = 0;
   variable->push_back(static_cast<int>(strtol(value.c_str(), &res, 10)));
@@ -766,7 +763,7 @@ void CommandLineArguments::PopulateVariable(
 
 //----------------------------------------------------------------------------
 void CommandLineArguments::PopulateVariable(
-  kwsys_stl::vector<double>* variable, const kwsys_stl::string& value)
+  std::vector<double>* variable, const std::string& value)
 {
   char* res = 0;
   variable->push_back(strtod(value.c_str(), &res));
@@ -778,7 +775,7 @@ void CommandLineArguments::PopulateVariable(
 
 //----------------------------------------------------------------------------
 void CommandLineArguments::PopulateVariable(
-  kwsys_stl::vector<char*>* variable, const kwsys_stl::string& value)
+  std::vector<char*>* variable, const std::string& value)
 {
   char* var = new char[ value.size() + 1 ];
   strcpy(var, value.c_str());
@@ -787,8 +784,8 @@ void CommandLineArguments::PopulateVariable(
 
 //----------------------------------------------------------------------------
 void CommandLineArguments::PopulateVariable(
-  kwsys_stl::vector<kwsys_stl::string>* variable,
-  const kwsys_stl::string& value)
+  std::vector<std::string>* variable,
+  const std::string& value)
 {
   variable->push_back(value);
 }
@@ -809,7 +806,7 @@ bool CommandLineArguments::PopulateVariable(CommandLineArgumentsCallbackStructur
   CommandLineArguments_DEBUG("Set argument: " << cs->Argument << " to " << value);
   if ( cs->Variable )
     {
-    kwsys_stl::string var = "1";
+    std::string var = "1";
     if ( value )
       {
       var = value;
@@ -826,28 +823,28 @@ bool CommandLineArguments::PopulateVariable(CommandLineArgumentsCallbackStructur
       this->PopulateVariable(static_cast<char**>(cs->Variable), var);
       break;
     case CommandLineArguments::STL_STRING_TYPE:
-      this->PopulateVariable(static_cast<kwsys_stl::string*>(cs->Variable), var);
+      this->PopulateVariable(static_cast<std::string*>(cs->Variable), var);
       break;
     case CommandLineArguments::BOOL_TYPE:
       this->PopulateVariable(static_cast<bool*>(cs->Variable), var);
       break;
     case CommandLineArguments::VECTOR_BOOL_TYPE:
-      this->PopulateVariable(static_cast<kwsys_stl::vector<bool>*>(cs->Variable), var);
+      this->PopulateVariable(static_cast<std::vector<bool>*>(cs->Variable), var);
       break;
     case CommandLineArguments::VECTOR_INT_TYPE:
-      this->PopulateVariable(static_cast<kwsys_stl::vector<int>*>(cs->Variable), var);
+      this->PopulateVariable(static_cast<std::vector<int>*>(cs->Variable), var);
       break;
     case CommandLineArguments::VECTOR_DOUBLE_TYPE:
-      this->PopulateVariable(static_cast<kwsys_stl::vector<double>*>(cs->Variable), var);
+      this->PopulateVariable(static_cast<std::vector<double>*>(cs->Variable), var);
       break;
     case CommandLineArguments::VECTOR_STRING_TYPE:
-      this->PopulateVariable(static_cast<kwsys_stl::vector<char*>*>(cs->Variable), var);
+      this->PopulateVariable(static_cast<std::vector<char*>*>(cs->Variable), var);
       break;
     case CommandLineArguments::VECTOR_STL_STRING_TYPE:
-      this->PopulateVariable(static_cast<kwsys_stl::vector<kwsys_stl::string>*>(cs->Variable), var);
+      this->PopulateVariable(static_cast<std::vector<std::string>*>(cs->Variable), var);
       break;
     default:
-      kwsys_ios::cerr << "Got unknown variable type: \"" << cs->VariableType << "\"" << kwsys_ios::endl;
+      std::cerr << "Got unknown variable type: \"" << cs->VariableType << "\"" << std::endl;
       this->Internals->LastArgument --;
       return 0;
       }

Source/kwsys/CommandLineArguments.hxx.in

@@ -15,13 +15,8 @@
 #include <@KWSYS_NAMESPACE@/Configure.h>
 #include <@KWSYS_NAMESPACE@/Configure.hxx>
 
-#include <@KWSYS_NAMESPACE@/stl/string>
-#include <@KWSYS_NAMESPACE@/stl/vector>
-
-/* Define this macro temporarily to keep the code readable.  */
-#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-# define kwsys_stl @KWSYS_NAMESPACE@_stl
-#endif
+#include <string>
+#include <vector>
 
 namespace @KWSYS_NAMESPACE@
 {
@@ -64,7 +59,7 @@ struct CommandLineArgumentsCallbackStructure;
  *                 "This is help string for --something");
  * if ( !arg.Parse() )
  *   {
- *   kwsys_ios::cerr << "Problem parsing arguments" << kwsys_ios::endl;
+ *   std::cerr << "Problem parsing arguments" << std::endl;
  *   res = 1;
  *   }
  * 
@@ -155,7 +150,7 @@ public:
   void AddArgument(const char* argument, ArgumentTypeEnum type, 
     char** variable, const char* help);
   void AddArgument(const char* argument, ArgumentTypeEnum type,
-    kwsys_stl::string* variable, const char* help);
+    std::string* variable, const char* help);
 
   /**
    * Add handler for argument which is going to set the variable to the
@@ -163,15 +158,15 @@ public:
    * appropriate type. This will handle the multi argument values.
    */
   void AddArgument(const char* argument, ArgumentTypeEnum type,
-    kwsys_stl::vector<bool>* variable, const char* help);
+    std::vector<bool>* variable, const char* help);
   void AddArgument(const char* argument, ArgumentTypeEnum type,
-    kwsys_stl::vector<int>* variable, const char* help);
+    std::vector<int>* variable, const char* help);
   void AddArgument(const char* argument, ArgumentTypeEnum type, 
-    kwsys_stl::vector<double>* variable, const char* help);
+    std::vector<double>* variable, const char* help);
   void AddArgument(const char* argument, ArgumentTypeEnum type, 
-    kwsys_stl::vector<char*>* variable, const char* help);
+    std::vector<char*>* variable, const char* help);
   void AddArgument(const char* argument, ArgumentTypeEnum type,
-    kwsys_stl::vector<kwsys_stl::string>* variable, const char* help);
+    std::vector<std::string>* variable, const char* help);
 
   /**
    * Add handler for boolean argument. The argument does not take any option
@@ -187,7 +182,7 @@ public:
   void AddBooleanArgument(const char* argument,
     char** variable, const char* help);
   void AddBooleanArgument(const char* argument,
-    kwsys_stl::string* variable, const char* help);
+    std::string* variable, const char* help);
 
   /**
    * Set the callbacks for error handling.
@@ -243,28 +238,28 @@ protected:
   void AddArgument(const char* argument, ArgumentTypeEnum type,
     VariableTypeEnum vtype, void* variable, const char* help);
 
-  bool GetMatchedArguments(kwsys_stl::vector<kwsys_stl::string>* matches,
-    const kwsys_stl::string& arg);
+  bool GetMatchedArguments(std::vector<std::string>* matches,
+    const std::string& arg);
 
   //! Populate individual variables
   bool PopulateVariable(CommandLineArgumentsCallbackStructure* cs,
     const char* value);
 
   //! Populate individual variables of type ...
-  void PopulateVariable(bool* variable, const kwsys_stl::string& value);
-  void PopulateVariable(int* variable, const kwsys_stl::string& value);
-  void PopulateVariable(double* variable, const kwsys_stl::string& value);
-  void PopulateVariable(char** variable, const kwsys_stl::string& value);
-  void PopulateVariable(kwsys_stl::string* variable, const kwsys_stl::string& value);
-  void PopulateVariable(kwsys_stl::vector<bool>* variable, const kwsys_stl::string& value);
-  void PopulateVariable(kwsys_stl::vector<int>* variable, const kwsys_stl::string& value);
-  void PopulateVariable(kwsys_stl::vector<double>* variable, const kwsys_stl::string& value);
-  void PopulateVariable(kwsys_stl::vector<char*>* variable, const kwsys_stl::string& value);
-  void PopulateVariable(kwsys_stl::vector<kwsys_stl::string>* variable, const kwsys_stl::string& value);
+  void PopulateVariable(bool* variable, const std::string& value);
+  void PopulateVariable(int* variable, const std::string& value);
+  void PopulateVariable(double* variable, const std::string& value);
+  void PopulateVariable(char** variable, const std::string& value);
+  void PopulateVariable(std::string* variable, const std::string& value);
+  void PopulateVariable(std::vector<bool>* variable, const std::string& value);
+  void PopulateVariable(std::vector<int>* variable, const std::string& value);
+  void PopulateVariable(std::vector<double>* variable, const std::string& value);
+  void PopulateVariable(std::vector<char*>* variable, const std::string& value);
+  void PopulateVariable(std::vector<std::string>* variable, const std::string& value);
 
   typedef CommandLineArgumentsInternal Internal;
   Internal* Internals;
-  kwsys_stl::string Help;
+  std::string Help;
 
   unsigned int LineLength;
 
@@ -273,11 +268,6 @@ protected:
 
 } // namespace @KWSYS_NAMESPACE@
 
-/* Undefine temporary macro.  */
-#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-# undef kwsys_stl
-#endif
-
 #endif
 
 

Source/kwsys/Configure.hxx.in

@@ -15,125 +15,9 @@
 /* Include C configuration.  */
 #include <@KWSYS_NAMESPACE@/Configure.h>
 
-/* Whether ANSI C++ stream headers are to be used.  */
-#define @KWSYS_NAMESPACE@_IOS_USE_ANSI @KWSYS_IOS_USE_ANSI@
-
-/* Whether ANSI C++ streams are in std namespace.  */
-#define @KWSYS_NAMESPACE@_IOS_HAVE_STD @KWSYS_IOS_HAVE_STD@
-
-/* Whether ANSI C++ <sstream> header is to be used.  */
-#define @KWSYS_NAMESPACE@_IOS_USE_SSTREAM @KWSYS_IOS_USE_SSTREAM@
-
-/* Whether old C++ <strstream.h> header is to be used.  */
-#define @KWSYS_NAMESPACE@_IOS_USE_STRSTREAM_H @KWSYS_IOS_USE_STRSTREAM_H@
-
-/* Whether old C++ <strstrea.h> header is to be used.  */
-#define @KWSYS_NAMESPACE@_IOS_USE_STRSTREA_H @KWSYS_IOS_USE_STRSTREA_H@
-
-/* Whether C++ streams support the ios::binary openmode.  */
-#define @KWSYS_NAMESPACE@_IOS_HAVE_BINARY @KWSYS_IOS_HAVE_BINARY@
-
-/* Whether STL is in std namespace.  */
-#define @KWSYS_NAMESPACE@_STL_HAVE_STD @KWSYS_STL_HAVE_STD@
-
 /* Whether wstring is available.  */
 #define @KWSYS_NAMESPACE@_STL_HAS_WSTRING @KWSYS_STL_HAS_WSTRING@
 
-/* Whether the STL string has operator<< for ostream.  */
-#define @KWSYS_NAMESPACE@_STL_STRING_HAVE_OSTREAM @KWSYS_STL_STRING_HAVE_OSTREAM@
-
-/* Whether the STL string has operator>> for istream.  */
-#define @KWSYS_NAMESPACE@_STL_STRING_HAVE_ISTREAM @KWSYS_STL_STRING_HAVE_ISTREAM@
-
-/* Whether the STL string has operator!= for char*.  */
-#define @KWSYS_NAMESPACE@_STL_STRING_HAVE_NEQ_CHAR @KWSYS_STL_STRING_HAVE_NEQ_CHAR@
-
-/* Define the stl namespace macro.  */
-#if @KWSYS_NAMESPACE@_STL_HAVE_STD
-# define @KWSYS_NAMESPACE@_stl std
-#else
-# define @KWSYS_NAMESPACE@_stl
-#endif
-
-/* Define the ios namespace macro.  */
-#if @KWSYS_NAMESPACE@_IOS_HAVE_STD
-# define @KWSYS_NAMESPACE@_ios_namespace std
-#else
-# define @KWSYS_NAMESPACE@_ios_namespace
-#endif
-#if @KWSYS_NAMESPACE@_IOS_USE_SSTREAM
-# define @KWSYS_NAMESPACE@_ios @KWSYS_NAMESPACE@_ios_namespace
-#else
-# define @KWSYS_NAMESPACE@_ios @KWSYS_NAMESPACE@_ios
-#endif
-
-/* Define the ios::binary openmode macro.  */
-#if @KWSYS_NAMESPACE@_IOS_HAVE_BINARY
-# define @KWSYS_NAMESPACE@_ios_binary @KWSYS_NAMESPACE@_ios::ios::binary
-#else
-# define @KWSYS_NAMESPACE@_ios_binary 0
-#endif
-
-/* Whether the cstddef header is available.  */
-#define @KWSYS_NAMESPACE@_CXX_HAS_CSTDDEF @KWSYS_CXX_HAS_CSTDDEF@
-
-/* Whether the compiler supports null template arguments.  */
-#define @KWSYS_NAMESPACE@_CXX_HAS_NULL_TEMPLATE_ARGS @KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS@
-
-/* Define the null template arguments macro.  */
-#if @KWSYS_NAMESPACE@_CXX_HAS_NULL_TEMPLATE_ARGS
-# define @KWSYS_NAMESPACE@_CXX_NULL_TEMPLATE_ARGS <>
-#else
-# define @KWSYS_NAMESPACE@_CXX_NULL_TEMPLATE_ARGS
-#endif
-
-/* Whether the compiler supports member templates.  */
-#define @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES @KWSYS_CXX_HAS_MEMBER_TEMPLATES@
-
-/* Whether the compiler supports argument dependent lookup.  */
-#define @KWSYS_NAMESPACE@_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP @KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP@
-
-/* Whether the compiler supports standard full specialization syntax.  */
-#define @KWSYS_NAMESPACE@_CXX_HAS_FULL_SPECIALIZATION @KWSYS_CXX_HAS_FULL_SPECIALIZATION@
-
-/* Define the specialization definition macro.  */
-#if @KWSYS_NAMESPACE@_CXX_HAS_FULL_SPECIALIZATION
-# define @KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION template <>
-#else
-# define @KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION
-#endif
-
-/* Define typename keyword macro for use in declarations.  */
-#if defined(_MSC_VER) && _MSC_VER < 1300
-# define @KWSYS_NAMESPACE@_CXX_DECL_TYPENAME
-#else
-# define @KWSYS_NAMESPACE@_CXX_DECL_TYPENAME typename
-#endif
-
-/* Whether the stl has iterator_traits.  */
-#define @KWSYS_NAMESPACE@_STL_HAS_ITERATOR_TRAITS @KWSYS_STL_HAS_ITERATOR_TRAITS@
-
-/* Whether the stl has iterator_category.  */
-#define @KWSYS_NAMESPACE@_STL_HAS_ITERATOR_CATEGORY @KWSYS_STL_HAS_ITERATOR_CATEGORY@
-
-/* Whether the stl has __iterator_category.  */
-#define @KWSYS_NAMESPACE@_STL_HAS___ITERATOR_CATEGORY @KWSYS_STL_HAS___ITERATOR_CATEGORY@
-
-/* Whether the stl allocator is the standard template.  */
-#define @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_TEMPLATE @KWSYS_STL_HAS_ALLOCATOR_TEMPLATE@
-
-/* Whether the stl allocator is not a template.  */
-#define @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_NONTEMPLATE @KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE@
-
-/* Whether the stl allocator has rebind.  */
-#define @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_REBIND @KWSYS_STL_HAS_ALLOCATOR_REBIND@
-
-/* Whether the stl allocator has a size argument for max_size.  */
-#define @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT @KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT@
-
-/* Whether the stl containers support allocator objects.  */
-#define @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_OBJECTS @KWSYS_STL_HAS_ALLOCATOR_OBJECTS@
-
 /* Whether struct stat has the st_mtim member for high resolution times.  */
 #define @KWSYS_NAMESPACE@_STAT_HAS_ST_MTIM @KWSYS_STAT_HAS_ST_MTIM@
 
@@ -141,38 +25,10 @@
    access to the macros without a configured namespace.  */
 #if defined(KWSYS_NAMESPACE)
 # if !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-#  define kwsys_stl @KWSYS_NAMESPACE@_stl
-#  define kwsys_ios @KWSYS_NAMESPACE@_ios
 #  define kwsys     @KWSYS_NAMESPACE@
-#  define kwsys_ios_binary @KWSYS_NAMESPACE@_ios_binary
 # endif
 # define KWSYS_NAME_IS_KWSYS            @KWSYS_NAMESPACE@_NAME_IS_KWSYS
-# define KWSYS_STL_HAVE_STD             @KWSYS_NAMESPACE@_STL_HAVE_STD
-# define KWSYS_IOS_HAVE_STD             @KWSYS_NAMESPACE@_IOS_HAVE_STD
-# define KWSYS_IOS_USE_ANSI             @KWSYS_NAMESPACE@_IOS_USE_ANSI
-# define KWSYS_IOS_USE_SSTREAM          @KWSYS_NAMESPACE@_IOS_USE_SSTREAM
-# define KWSYS_IOS_USE_STRSTREAM_H      @KWSYS_NAMESPACE@_IOS_USE_STRSTREAM_H
-# define KWSYS_IOS_USE_STRSTREA_H       @KWSYS_NAMESPACE@_IOS_USE_STRSTREA_H
-# define KWSYS_IOS_HAVE_BINARY          @KWSYS_NAMESPACE@_IOS_HAVE_BINARY
 # define KWSYS_STAT_HAS_ST_MTIM         @KWSYS_NAMESPACE@_STAT_HAS_ST_MTIM
-# define KWSYS_CXX_HAS_CSTDDEF          @KWSYS_NAMESPACE@_CXX_HAS_CSTDDEF
-# define KWSYS_STL_STRING_HAVE_OSTREAM  @KWSYS_NAMESPACE@_STL_STRING_HAVE_OSTREAM
-# define KWSYS_STL_STRING_HAVE_ISTREAM  @KWSYS_NAMESPACE@_STL_STRING_HAVE_ISTREAM
-# define KWSYS_STL_STRING_HAVE_NEQ_CHAR @KWSYS_NAMESPACE@_STL_STRING_HAVE_NEQ_CHAR
-# define KWSYS_CXX_NULL_TEMPLATE_ARGS   @KWSYS_NAMESPACE@_CXX_NULL_TEMPLATE_ARGS
-# define KWSYS_CXX_HAS_MEMBER_TEMPLATES @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES
-# define KWSYS_CXX_HAS_FULL_SPECIALIZATION @KWSYS_NAMESPACE@_CXX_HAS_FULL_SPECIALIZATION
-# define KWSYS_CXX_DEFINE_SPECIALIZATION @KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION
-# define KWSYS_CXX_DECL_TYPENAME        @KWSYS_NAMESPACE@_CXX_DECL_TYPENAME
-# define KWSYS_STL_HAS_ALLOCATOR_REBIND @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_REBIND
-# define KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
-# define KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP @KWSYS_NAMESPACE@_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
-# define KWSYS_STL_HAS_ITERATOR_TRAITS @KWSYS_NAMESPACE@_STL_HAS_ITERATOR_TRAITS
-# define KWSYS_STL_HAS_ITERATOR_CATEGORY @KWSYS_NAMESPACE@_STL_HAS_ITERATOR_CATEGORY
-# define KWSYS_STL_HAS___ITERATOR_CATEGORY @KWSYS_NAMESPACE@_STL_HAS___ITERATOR_CATEGORY
-# define KWSYS_STL_HAS_ALLOCATOR_TEMPLATE @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_TEMPLATE
-# define KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_NONTEMPLATE
-# define KWSYS_STL_HAS_ALLOCATOR_OBJECTS @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_OBJECTS
 # define KWSYS_STL_HAS_WSTRING          @KWSYS_NAMESPACE@_STL_HAS_WSTRING
 #endif
 

Source/kwsys/Directory.cxx

@@ -16,20 +16,17 @@
 
 #include KWSYS_HEADER(Encoding.hxx)
 
-#include KWSYS_HEADER(stl/string)
-#include KWSYS_HEADER(stl/vector)
-
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
 # include "Directory.hxx.in"
 # include "Configure.hxx.in"
 # include "Encoding.hxx.in"
-# include "kwsys_stl.hxx.in"
-# include "kwsys_stl_string.hxx.in"
-# include "kwsys_stl_vector.hxx.in"
 #endif
 
+#include <string>
+#include <vector>
+
 namespace KWSYS_NAMESPACE
 {
 
@@ -38,10 +35,10 @@ class DirectoryInternals
 {
 public:
   // Array of Files
-  kwsys_stl::vector<kwsys_stl::string> Files;
+  std::vector<std::string> Files;
 
   // Path to Open'ed directory
-  kwsys_stl::string Path;
+  std::string Path;
 };
 
 //----------------------------------------------------------------------------
@@ -103,7 +100,7 @@ void Directory::Clear()
 namespace KWSYS_NAMESPACE
 {
 
-bool Directory::Load(const kwsys_stl::string& name)
+bool Directory::Load(const std::string& name)
 {
   this->Clear();
 #if _MSC_VER < 1300
@@ -153,7 +150,7 @@ bool Directory::Load(const kwsys_stl::string& name)
   return _findclose(srchHandle) != -1;
 }
 
-unsigned long Directory::GetNumberOfFilesInDirectory(const kwsys_stl::string& name)
+unsigned long Directory::GetNumberOfFilesInDirectory(const std::string& name)
 {
 #if _MSC_VER < 1300
   long srchHandle;
@@ -220,7 +217,7 @@ unsigned long Directory::GetNumberOfFilesInDirectory(const kwsys_stl::string& na
 namespace KWSYS_NAMESPACE
 {
 
-bool Directory::Load(const kwsys_stl::string& name)
+bool Directory::Load(const std::string& name)
 {
   this->Clear();
    
@@ -240,7 +237,7 @@ bool Directory::Load(const kwsys_stl::string& name)
   return 1;
 }
 
-unsigned long Directory::GetNumberOfFilesInDirectory(const kwsys_stl::string& name)
+unsigned long Directory::GetNumberOfFilesInDirectory(const std::string& name)
 {
   DIR* dir = opendir(name.c_str());
 

Source/kwsys/Directory.hxx.in

@@ -13,12 +13,7 @@
 #define @KWSYS_NAMESPACE@_Directory_hxx
 
 #include <@KWSYS_NAMESPACE@/Configure.h>
-#include <@KWSYS_NAMESPACE@/stl/string>
-
-/* Define these macros temporarily to keep the code readable.  */
-#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-# define kwsys_stl @KWSYS_NAMESPACE@_stl
-#endif
+#include <string>
 
 namespace @KWSYS_NAMESPACE@
 {
@@ -44,7 +39,7 @@ public:
    * in that directory. 0 is returned if the directory can not be
    * opened, 1 if it is opened.
    */
-  bool Load(const kwsys_stl::string&);
+  bool Load(const std::string&);
 
   /**
    * Return the number of files in the current directory.
@@ -55,7 +50,7 @@ public:
    * Return the number of files in the specified directory.
    * A higher performance static method.
    */
-  static unsigned long GetNumberOfFilesInDirectory(const kwsys_stl::string&);
+  static unsigned long GetNumberOfFilesInDirectory(const std::string&);
 
   /**
    * Return the file at the given index, the indexing is 0 based
@@ -83,9 +78,4 @@ private:
 
 } // namespace @KWSYS_NAMESPACE@
 
-/* Undefine temporary macros.  */
-#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-# undef kwsys_stl
-#endif
-
 #endif

Source/kwsys/DynamicLoader.cxx

@@ -40,7 +40,7 @@ namespace KWSYS_NAMESPACE
 {
 
 //----------------------------------------------------------------------------
-DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const kwsys_stl::string& libname )
+DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const std::string& libname )
 {
   return shl_load(libname.c_str(), BIND_DEFERRED | DYNAMIC_PATH, 0L);
 }
@@ -57,7 +57,7 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
 
 //----------------------------------------------------------------------------
 DynamicLoader::SymbolPointer
-DynamicLoader::GetSymbolAddress(DynamicLoader::LibraryHandle lib, const kwsys_stl::string& sym)
+DynamicLoader::GetSymbolAddress(DynamicLoader::LibraryHandle lib, const std::string& sym)
 {
   void* addr;
   int status;
@@ -115,7 +115,7 @@ namespace KWSYS_NAMESPACE
 {
 
 //----------------------------------------------------------------------------
-DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const kwsys_stl::string& libname )
+DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const std::string& libname )
 {
   NSObjectFileImageReturnCode rc;
   NSObjectFileImage image = 0;
@@ -146,7 +146,7 @@ int DynamicLoader::CloseLibrary( DynamicLoader::LibraryHandle lib)
 
 //----------------------------------------------------------------------------
 DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
-  DynamicLoader::LibraryHandle lib, const kwsys_stl::string& sym)
+  DynamicLoader::LibraryHandle lib, const std::string& sym)
 {
   void *result=0;
   // Need to prepend symbols with '_' on Apple-gcc compilers
@@ -187,7 +187,7 @@ namespace KWSYS_NAMESPACE
 {
 
 //----------------------------------------------------------------------------
-DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const kwsys_stl::string& libname)
+DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const std::string& libname)
 {
   DynamicLoader::LibraryHandle lh;
   int length = MultiByteToWideChar(CP_UTF8, 0, libname.c_str(), -1, NULL, 0);
@@ -207,7 +207,7 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
 
 //----------------------------------------------------------------------------
 DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
-  DynamicLoader::LibraryHandle lib, const kwsys_stl::string& sym)
+  DynamicLoader::LibraryHandle lib, const std::string& sym)
 {
   // TODO: The calling convention affects the name of the symbol.  We
   // should have a tool to help get the symbol with the desired
@@ -302,7 +302,7 @@ namespace KWSYS_NAMESPACE
 static image_id last_dynamic_err = B_OK;
 
 //----------------------------------------------------------------------------
-DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const kwsys_stl::string& libname )
+DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const std::string& libname )
 {
   // image_id's are integers, errors are negative. Add one just in case we
   //  get a valid image_id of zero (is that even possible?).
@@ -340,7 +340,7 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
 
 //----------------------------------------------------------------------------
 DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
-  DynamicLoader::LibraryHandle lib, const kwsys_stl::string& sym)
+  DynamicLoader::LibraryHandle lib, const std::string& sym)
 {
   // Hack to cast pointer-to-data to pointer-to-function.
   union 
@@ -393,7 +393,7 @@ namespace KWSYS_NAMESPACE
 {
 
 //----------------------------------------------------------------------------
-DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const kwsys_stl::string& libname )
+DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const std::string& libname )
 {
   return 0;
 }
@@ -411,7 +411,7 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
 
 //----------------------------------------------------------------------------
 DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
-    DynamicLoader::LibraryHandle lib, const kwsys_stl::string& sym)
+    DynamicLoader::LibraryHandle lib, const std::string& sym)
 {
   return 0;
 }
@@ -437,7 +437,7 @@ namespace KWSYS_NAMESPACE
 {
 
 //----------------------------------------------------------------------------
-DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const kwsys_stl::string& libname )
+DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const std::string& libname )
 {
   char *name = (char *)calloc(1, libname.size() + 1);
   dld_init(program_invocation_name);
@@ -456,7 +456,7 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
 
 //----------------------------------------------------------------------------
 DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
-  DynamicLoader::LibraryHandle lib, const kwsys_stl::string& sym)
+  DynamicLoader::LibraryHandle lib, const std::string& sym)
 {
   // Hack to cast pointer-to-data to pointer-to-function.
   union
@@ -489,7 +489,7 @@ namespace KWSYS_NAMESPACE
 {
 
 //----------------------------------------------------------------------------
-DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const kwsys_stl::string& libname )
+DynamicLoader::LibraryHandle DynamicLoader::OpenLibrary(const std::string& libname )
 {
   return dlopen(libname.c_str(), RTLD_LAZY);
 }
@@ -508,7 +508,7 @@ int DynamicLoader::CloseLibrary(DynamicLoader::LibraryHandle lib)
 
 //----------------------------------------------------------------------------
 DynamicLoader::SymbolPointer DynamicLoader::GetSymbolAddress(
-  DynamicLoader::LibraryHandle lib, const kwsys_stl::string& sym)
+  DynamicLoader::LibraryHandle lib, const std::string& sym)
 {
   // Hack to cast pointer-to-data to pointer-to-function.
   union 

Source/kwsys/DynamicLoader.hxx.in

@@ -12,8 +12,8 @@
 #ifndef @KWSYS_NAMESPACE@_DynamicLoader_hxx
 #define @KWSYS_NAMESPACE@_DynamicLoader_hxx
 
-#include <@KWSYS_NAMESPACE@/Configure.h>
-#include <@KWSYS_NAMESPACE@/stl/string>
+#include <@KWSYS_NAMESPACE@/Configure.hxx>
+#include <string>
 
 #if defined(__hpux)
   #include <dl.h>
@@ -28,11 +28,6 @@
   #include <be/kernel/image.h>
 #endif
 
-/* Define these macros temporarily to keep the code readable.  */
-#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-# define kwsys_stl @KWSYS_NAMESPACE@_stl
-#endif
-
 namespace @KWSYS_NAMESPACE@
 {
 /** \class DynamicLoader
@@ -83,14 +78,14 @@ public:
   /** Load a dynamic library into the current process.
    * The returned LibraryHandle can be used to access the symbols in the
    * library. */
-  static LibraryHandle OpenLibrary(const kwsys_stl::string&);
+  static LibraryHandle OpenLibrary(const std::string&);
 
   /** Attempt to detach a dynamic library from the
    * process.  A value of true is returned if it is sucessful. */
   static int CloseLibrary(LibraryHandle);
 
   /** Find the address of the symbol in the given library. */
-  static SymbolPointer GetSymbolAddress(LibraryHandle, const kwsys_stl::string&);
+  static SymbolPointer GetSymbolAddress(LibraryHandle, const std::string&);
 
   /** Return the default module prefix for the current platform.  */
   static const char* LibPrefix() { return "@KWSYS_DynamicLoader_PREFIX@"; }
@@ -104,9 +99,4 @@ public:
 
 } // namespace @KWSYS_NAMESPACE@
 
-/* Undefine temporary macros.  */
-#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-# undef kwsys_stl
-#endif
-
 #endif

Source/kwsys/Encoding.hxx.in

@@ -13,13 +13,8 @@
 #define @KWSYS_NAMESPACE@_Encoding_hxx
 
 #include <@KWSYS_NAMESPACE@/Configure.hxx>
-#include <@KWSYS_NAMESPACE@/stl/string>
-#include <@KWSYS_NAMESPACE@/stl/vector>
-
-/* Define these macros temporarily to keep the code readable.  */
-#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-# define kwsys_stl @KWSYS_NAMESPACE@_stl
-#endif
+#include <string>
+#include <vector>
 
 namespace @KWSYS_NAMESPACE@
 {
@@ -65,23 +60,18 @@ public:
   // Convert a narrow string to a wide string.
   // On Windows, UTF-8 is assumed, and on other platforms,
   // the current locale is assumed.
-  static kwsys_stl::wstring ToWide(const kwsys_stl::string& str);
-  static kwsys_stl::wstring ToWide(const char* str);
+  static std::wstring ToWide(const std::string& str);
+  static std::wstring ToWide(const char* str);
 
   // Convert a wide string to a narrow string.
   // On Windows, UTF-8 is assumed, and on other platforms,
   // the current locale is assumed.
-  static kwsys_stl::string ToNarrow(const kwsys_stl::wstring& str);
-  static kwsys_stl::string ToNarrow(const wchar_t* str);
+  static std::string ToNarrow(const std::wstring& str);
+  static std::string ToNarrow(const wchar_t* str);
 
 #endif // @KWSYS_NAMESPACE@_STL_HAS_WSTRING
 
 }; // class Encoding
 } // namespace @KWSYS_NAMESPACE@
 
-/* Undefine temporary macros.  */
-#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-# undef kwsys_stl
-#endif
-
 #endif

Source/kwsys/EncodingCXX.cxx

@@ -19,7 +19,6 @@
 #include "kwsysPrivate.h"
 #include KWSYS_HEADER(Encoding.hxx)
 #include KWSYS_HEADER(Encoding.h)
-#include KWSYS_HEADER(stl/vector)
 
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
@@ -28,6 +27,7 @@
 # include "Encoding.h.in"
 #endif
 
+#include <vector>
 #include <stdlib.h>
 #include <string.h>
 
@@ -140,23 +140,23 @@ char const* const* Encoding::CommandLineArguments::argv() const
 
 #if KWSYS_STL_HAS_WSTRING
 
-kwsys_stl::wstring Encoding::ToWide(const kwsys_stl::string& str)
+std::wstring Encoding::ToWide(const std::string& str)
 {
   return ToWide(str.c_str());
 }
 
-kwsys_stl::string Encoding::ToNarrow(const kwsys_stl::wstring& str)
+std::string Encoding::ToNarrow(const std::wstring& str)
 {
   return ToNarrow(str.c_str());
 }
 
-kwsys_stl::wstring Encoding::ToWide(const char* cstr)
+std::wstring Encoding::ToWide(const char* cstr)
 {
-  kwsys_stl::wstring wstr;
+  std::wstring wstr;
   size_t length = kwsysEncoding_mbstowcs(0, cstr, 0) + 1;
   if(length > 0)
     {
-    kwsys_stl::vector<wchar_t> wchars(length);
+    std::vector<wchar_t> wchars(length);
     if(kwsysEncoding_mbstowcs(&wchars[0], cstr, length) > 0)
       {
       wstr = &wchars[0];
@@ -165,9 +165,9 @@ kwsys_stl::wstring Encoding::ToWide(const char* cstr)
   return wstr;
 }
 
-kwsys_stl::string Encoding::ToNarrow(const wchar_t* wcstr)
+std::string Encoding::ToNarrow(const wchar_t* wcstr)
 {
-  kwsys_stl::string str;
+  std::string str;
   size_t length = kwsysEncoding_wcstombs(0, wcstr, 0) + 1;
   if(length > 0)
     {

Source/kwsys/FStream.hxx.in

@@ -12,8 +12,8 @@
 #ifndef @KWSYS_NAMESPACE@_FStream_hxx
 #define @KWSYS_NAMESPACE@_FStream_hxx
 
-#include <@KWSYS_NAMESPACE@/ios/fstream>
 #include <@KWSYS_NAMESPACE@/Encoding.hxx>
+#include <fstream>
 
 namespace @KWSYS_NAMESPACE@
 {
@@ -167,8 +167,8 @@ class basic_ofstream : public std::basic_ostream<CharType,Traits>
 
 # undef @KWSYS_NAMESPACE@_FStream_NOEXCEPT
 #else
-  using @KWSYS_NAMESPACE@_ios_namespace::ofstream;
-  using @KWSYS_NAMESPACE@_ios_namespace::ifstream;
+  using std::ofstream;
+  using std::ifstream;
 #endif
 
   namespace FStream

Source/kwsys/Glob.cxx

@@ -17,9 +17,6 @@
 #include KWSYS_HEADER(RegularExpression.hxx)
 #include KWSYS_HEADER(SystemTools.hxx)
 #include KWSYS_HEADER(Directory.hxx)
-#include KWSYS_HEADER(stl/string)
-#include KWSYS_HEADER(stl/vector)
-#include KWSYS_HEADER(stl/algorithm)
 
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
@@ -29,12 +26,12 @@
 # include "Configure.hxx.in"
 # include "RegularExpression.hxx.in"
 # include "SystemTools.hxx.in"
-# include "kwsys_stl.hxx.in"
-# include "kwsys_stl_string.hxx.in"
-# include "kwsys_stl_vector.hxx.in"
-# include "kwsys_stl_algorithm.hxx.in"
 #endif
 
+#include <string>
+#include <vector>
+#include <algorithm>
+
 #include <ctype.h>
 #include <stdio.h>
 #include <string.h>
@@ -54,8 +51,8 @@ namespace KWSYS_NAMESPACE
 class GlobInternals
 {
 public:
-  kwsys_stl::vector<kwsys_stl::string> Files;
-  kwsys_stl::vector<kwsys::RegularExpression> Expressions;
+  std::vector<std::string> Files;
+  std::vector<kwsys::RegularExpression> Expressions;
 };
 
 //----------------------------------------------------------------------------
@@ -82,21 +79,21 @@ Glob::~Glob()
 }
 
 //----------------------------------------------------------------------------
-kwsys_stl::vector<kwsys_stl::string>& Glob::GetFiles()
+std::vector<std::string>& Glob::GetFiles()
 {
   return this->Internals->Files;
 }
 
 //----------------------------------------------------------------------------
-kwsys_stl::string Glob::PatternToRegex(const kwsys_stl::string& pattern,
+std::string Glob::PatternToRegex(const std::string& pattern,
                                        bool require_whole_string,
                                        bool preserve_case)
 {
   // Incrementally build the regular expression from the pattern.
-  kwsys_stl::string regex = require_whole_string? "^" : "";
-  kwsys_stl::string::const_iterator pattern_first = pattern.begin();
-  kwsys_stl::string::const_iterator pattern_last = pattern.end();
-  for(kwsys_stl::string::const_iterator i = pattern_first;
+  std::string regex = require_whole_string? "^" : "";
+  std::string::const_iterator pattern_first = pattern.begin();
+  std::string::const_iterator pattern_last = pattern.end();
+  for(std::string::const_iterator i = pattern_first;
       i != pattern_last; ++i)
     {
     int c = *i;
@@ -120,8 +117,8 @@ kwsys_stl::string Glob::PatternToRegex(const kwsys_stl::string& pattern,
       {
       // Parse out the bracket expression.  It begins just after the
       // opening character.
-      kwsys_stl::string::const_iterator bracket_first = i+1;
-      kwsys_stl::string::const_iterator bracket_last = bracket_first;
+      std::string::const_iterator bracket_first = i+1;
+      std::string::const_iterator bracket_last = bracket_first;
 
       // The first character may be complementation '!' or '^'.
       if(bracket_last != pattern_last &&
@@ -153,7 +150,7 @@ kwsys_stl::string Glob::PatternToRegex(const kwsys_stl::string& pattern,
       else
         {
         // Convert the bracket string to its regex equivalent.
-        kwsys_stl::string::const_iterator k = bracket_first;
+        std::string::const_iterator k = bracket_first;
 
         // Open the regex block.
         regex += "[";
@@ -221,8 +218,8 @@ kwsys_stl::string Glob::PatternToRegex(const kwsys_stl::string& pattern,
 }
 
 //----------------------------------------------------------------------------
-bool Glob::RecurseDirectory(kwsys_stl::string::size_type start,
-  const kwsys_stl::string& dir, GlobMessages* messages)
+bool Glob::RecurseDirectory(std::string::size_type start,
+  const std::string& dir, GlobMessages* messages)
 {
   kwsys::Directory d;
   if ( !d.Load(dir) )
@@ -230,8 +227,8 @@ bool Glob::RecurseDirectory(kwsys_stl::string::size_type start,
     return true;
     }
   unsigned long cc;
-  kwsys_stl::string realname;
-  kwsys_stl::string fname;
+  std::string realname;
+  std::string fname;
   for ( cc = 0; cc < d.GetNumberOfFiles(); cc ++ )
     {
     fname = d.GetFile(cc);
@@ -262,8 +259,8 @@ bool Glob::RecurseDirectory(kwsys_stl::string::size_type start,
       if (isSymLink)
         {
         ++this->FollowedSymlinkCount;
-        kwsys_stl::string realPathErrorMessage;
-        kwsys_stl::string canonicalPath(SystemTools::GetRealPath(dir,
+        std::string realPathErrorMessage;
+        std::string canonicalPath(SystemTools::GetRealPath(dir,
             &realPathErrorMessage));
 
         if(!realPathErrorMessage.empty())
@@ -277,7 +274,7 @@ bool Glob::RecurseDirectory(kwsys_stl::string::size_type start,
           return false;
           }
 
-        if(kwsys_stl::find(this->VisitedSymlinks.begin(),
+        if(std::find(this->VisitedSymlinks.begin(),
             this->VisitedSymlinks.end(),
             canonicalPath) == this->VisitedSymlinks.end())
           {
@@ -299,9 +296,9 @@ bool Glob::RecurseDirectory(kwsys_stl::string::size_type start,
         // else we have already visited this symlink - prevent cyclic recursion
         else if(messages)
           {
-          kwsys_stl::string message;
-          for(kwsys_stl::vector<kwsys_stl::string>::const_iterator
-                pathIt = kwsys_stl::find(this->VisitedSymlinks.begin(),
+          std::string message;
+          for(std::vector<std::string>::const_iterator
+                pathIt = std::find(this->VisitedSymlinks.begin(),
                                          this->VisitedSymlinks.end(),
                                          canonicalPath);
               pathIt != this->VisitedSymlinks.end(); ++pathIt)
@@ -338,10 +335,10 @@ bool Glob::RecurseDirectory(kwsys_stl::string::size_type start,
 }
 
 //----------------------------------------------------------------------------
-void Glob::ProcessDirectory(kwsys_stl::string::size_type start,
-  const kwsys_stl::string& dir, GlobMessages* messages)
+void Glob::ProcessDirectory(std::string::size_type start,
+  const std::string& dir, GlobMessages* messages)
 {
-  //kwsys_ios::cout << "ProcessDirectory: " << dir << kwsys_ios::endl;
+  //std::cout << "ProcessDirectory: " << dir << std::endl;
   bool last = ( start == this->Internals->Expressions.size()-1 );
   if ( last && this->Recurse )
     {
@@ -360,8 +357,8 @@ void Glob::ProcessDirectory(kwsys_stl::string::size_type start,
     return;
     }
   unsigned long cc;
-  kwsys_stl::string realname;
-  kwsys_stl::string fname;
+  std::string realname;
+  std::string fname;
   for ( cc = 0; cc < d.GetNumberOfFiles(); cc ++ )
     {
     fname = d.GetFile(cc);
@@ -384,10 +381,10 @@ void Glob::ProcessDirectory(kwsys_stl::string::size_type start,
     fname = kwsys::SystemTools::LowerCase(fname);
 #endif
 
-    //kwsys_ios::cout << "Look at file: " << fname << kwsys_ios::endl;
-    //kwsys_ios::cout << "Match: "
-    // << this->Internals->TextExpressions[start].c_str() << kwsys_ios::endl;
-    //kwsys_ios::cout << "Real name: " << realname << kwsys_ios::endl;
+    //std::cout << "Look at file: " << fname << std::endl;
+    //std::cout << "Match: "
+    // << this->Internals->TextExpressions[start].c_str() << std::endl;
+    //std::cout << "Real name: " << realname << std::endl;
 
     if( (!last && !kwsys::SystemTools::FileIsDirectory(realname))
       || (!this->ListDirs && last &&
@@ -411,11 +408,11 @@ void Glob::ProcessDirectory(kwsys_stl::string::size_type start,
 }
 
 //----------------------------------------------------------------------------
-bool Glob::FindFiles(const kwsys_stl::string& inexpr, GlobMessages* messages)
+bool Glob::FindFiles(const std::string& inexpr, GlobMessages* messages)
 {
-  kwsys_stl::string cexpr;
-  kwsys_stl::string::size_type cc;
-  kwsys_stl::string expr = inexpr;
+  std::string cexpr;
+  std::string::size_type cc;
+  std::string expr = inexpr;
 
   this->Internals->Expressions.clear();
   this->Internals->Files.clear();
@@ -425,10 +422,10 @@ bool Glob::FindFiles(const kwsys_stl::string& inexpr, GlobMessages* messages)
     expr = kwsys::SystemTools::GetCurrentWorkingDirectory();
     expr += "/" + inexpr;
     }
-  kwsys_stl::string fexpr = expr;
+  std::string fexpr = expr;
 
-  kwsys_stl::string::size_type skip = 0;
-  kwsys_stl::string::size_type last_slash = 0;
+  std::string::size_type skip = 0;
+  std::string::size_type last_slash = 0;
   for ( cc = 0; cc < expr.size(); cc ++ )
     {
     if ( cc > 0 && expr[cc] == '/' && expr[cc-1] != '\\' )
@@ -444,8 +441,8 @@ bool Glob::FindFiles(const kwsys_stl::string& inexpr, GlobMessages* messages)
     }
   if ( last_slash > 0 )
     {
-    //kwsys_ios::cout << "I can skip: " << fexpr.substr(0, last_slash)
-    // << kwsys_ios::endl;
+    //std::cout << "I can skip: " << fexpr.substr(0, last_slash)
+    // << std::endl;
     skip = last_slash;
     }
   if ( skip == 0 )
@@ -517,7 +514,7 @@ bool Glob::FindFiles(const kwsys_stl::string& inexpr, GlobMessages* messages)
 }
 
 //----------------------------------------------------------------------------
-void Glob::AddExpression(const kwsys_stl::string& expr)
+void Glob::AddExpression(const std::string& expr)
 {
   this->Internals->Expressions.push_back(
     kwsys::RegularExpression(
@@ -546,7 +543,7 @@ const char* Glob::GetRelative()
 }
 
 //----------------------------------------------------------------------------
-void Glob::AddFile(kwsys_stl::vector<kwsys_stl::string>& files, const kwsys_stl::string& file)
+void Glob::AddFile(std::vector<std::string>& files, const std::string& file)
 {
   if ( !this->Relative.empty() )
     {

Source/kwsys/Glob.hxx.in

@@ -15,13 +15,8 @@
 #include <@KWSYS_NAMESPACE@/Configure.h>
 #include <@KWSYS_NAMESPACE@/Configure.hxx>
 
-#include <@KWSYS_NAMESPACE@/stl/string>
-#include <@KWSYS_NAMESPACE@/stl/vector>
-
-/* Define this macro temporarily to keep the code readable.  */
-#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-# define kwsys_stl @KWSYS_NAMESPACE@_stl
-#endif
+#include <string>
+#include <vector>
 
 namespace @KWSYS_NAMESPACE@
 {
@@ -49,9 +44,9 @@ public:
   struct Message
   {
     MessageType type;
-    kwsys_stl::string content;
+    std::string content;
 
-    Message(MessageType t, const kwsys_stl::string& c) :
+    Message(MessageType t, const std::string& c) :
       type(t),
       content(c)
     {}
@@ -67,18 +62,18 @@ public:
       }
   };
 
-  typedef kwsys_stl::vector<Message> GlobMessages;
-  typedef kwsys_stl::vector<Message>::iterator GlobMessagesIterator;
+  typedef std::vector<Message> GlobMessages;
+  typedef std::vector<Message>::iterator GlobMessagesIterator;
 public:
   Glob();
   ~Glob();
 
   //! Find all files that match the pattern.
-  bool FindFiles(const kwsys_stl::string& inexpr,
+  bool FindFiles(const std::string& inexpr,
     GlobMessages* messages = 0);
 
   //! Return the list of files that matched.
-  kwsys_stl::vector<kwsys_stl::string>& GetFiles();
+  std::vector<std::string>& GetFiles();
 
   //! Set recurse to true to match subdirectories.
   void RecurseOn() { this->SetRecurse(true); }
@@ -107,7 +102,7 @@ public:
       string.  This is on by default because patterns always match
       whole strings, but may be disabled to support concatenating
       expressions more easily (regex1|regex2|etc).  */
-  static kwsys_stl::string PatternToRegex(const kwsys_stl::string& pattern,
+  static std::string PatternToRegex(const std::string& pattern,
                                           bool require_whole_string = true,
                                           bool preserve_case = false);
 
@@ -122,28 +117,28 @@ public:
 
 protected:
   //! Process directory
-  void ProcessDirectory(kwsys_stl::string::size_type start,
-    const kwsys_stl::string& dir,
+  void ProcessDirectory(std::string::size_type start,
+    const std::string& dir,
     GlobMessages* messages);
 
   //! Process last directory, but only when recurse flags is on. That is
   // effectively like saying: /path/to/file/**/file
-  bool RecurseDirectory(kwsys_stl::string::size_type start,
-    const kwsys_stl::string& dir,
+  bool RecurseDirectory(std::string::size_type start,
+    const std::string& dir,
     GlobMessages* messages);
 
   //! Add regular expression
-  void AddExpression(const kwsys_stl::string& expr);
+  void AddExpression(const std::string& expr);
 
   //! Add a file to the list
-  void AddFile(kwsys_stl::vector<kwsys_stl::string>& files, const kwsys_stl::string& file);
+  void AddFile(std::vector<std::string>& files, const std::string& file);
 
   GlobInternals* Internals;
   bool Recurse;
-  kwsys_stl::string Relative;
+  std::string Relative;
   bool RecurseThroughSymlinks;
   unsigned int FollowedSymlinkCount;
-  kwsys_stl::vector<kwsys_stl::string> VisitedSymlinks;
+  std::vector<std::string> VisitedSymlinks;
   bool ListDirs;
   bool RecurseListDirs;
 
@@ -154,9 +149,4 @@ private:
 
 } // namespace @KWSYS_NAMESPACE@
 
-/* Undefine temporary macro.  */
-#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-# undef kwsys_stl
-#endif
-
 #endif

Source/kwsys/IOStream.cxx

@@ -12,25 +12,14 @@
 #include "kwsysPrivate.h"
 #include KWSYS_HEADER(Configure.hxx)
 
-// Configure the implementation for the current streams library.
-#if !KWSYS_IOS_USE_ANSI
-# define ios_base ios
-# if defined(__HP_aCC)
-#  define protected public
-#  include <iostream.h> // Hack access to some private stream methods.
-#  undef protected
-# endif
-#endif
-
 // Include the streams library.
-#include KWSYS_HEADER(ios/iostream)
+#include <iostream>
 #include KWSYS_HEADER(IOStream.hxx)
 
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
 # include "Configure.hxx.in"
-# include "kwsys_ios_iostream.hxx.in"
 # include "IOStream.hxx.in"
 #endif
 
@@ -50,7 +39,7 @@ namespace KWSYS_NAMESPACE
 {
 
 // Scan an input stream for an integer value.
-static int IOStreamScanStream(kwsys_ios::istream& is, char* buffer)
+static int IOStreamScanStream(std::istream& is, char* buffer)
 {
   // Prepare to write to buffer.
   char* out = buffer;
@@ -64,10 +53,10 @@ static int IOStreamScanStream(kwsys_ios::istream& is, char* buffer)
   // detect it from the input.  A leading 0x means hex, and a leading
   // 0 alone means octal.
   int base = 0;
-  int flags = is.flags() & kwsys_ios::ios_base::basefield;
-  if(flags == kwsys_ios::ios_base::oct) { base = 8; }
-  else if(flags == kwsys_ios::ios_base::dec) { base = 10; }
-  else if(flags == kwsys_ios::ios_base::hex) { base = 16; }
+  int flags = is.flags() & std::ios_base::basefield;
+  if(flags == std::ios_base::oct) { base = 8; }
+  else if(flags == std::ios_base::dec) { base = 10; }
+  else if(flags == std::ios_base::hex) { base = 16; }
   bool foundDigit = false;
   bool foundNonZero = false;
   if(is.peek() == '0')
@@ -134,24 +123,17 @@ static int IOStreamScanStream(kwsys_ios::istream& is, char* buffer)
 
 // Read an integer value from an input stream.
 template <class T>
-kwsys_ios::istream&
-IOStreamScanTemplate(kwsys_ios::istream& is, T& value, char type)
+std::istream&
+IOStreamScanTemplate(std::istream& is, T& value, char type)
 {
-  int state = kwsys_ios::ios_base::goodbit;
+  int state = std::ios_base::goodbit;
 
   // Skip leading whitespace.
-# if KWSYS_IOS_USE_ANSI
-  kwsys_ios::istream::sentry okay(is);
-# else
-  is.eatwhite();
-  kwsys_ios::istream& okay = is;
-# endif
+  std::istream::sentry okay(is);
 
   if(okay)
     {
-#   if KWSYS_IOS_USE_ANSI
     try {
-#   endif
     // Copy the string to a buffer and construct the format string.
     char buffer[KWSYS_IOS_INT64_MAX_DIG];
 #   if defined(_MSC_VER)
@@ -174,52 +156,40 @@ IOStreamScanTemplate(kwsys_ios::istream& is, T& value, char type)
     int success = (sscanf(buffer, format, &result) == 1)?1:0;
 
     // Set flags for resulting state.
-    if(is.peek() == EOF) { state |= kwsys_ios::ios_base::eofbit; }
-    if(!success) { state |= kwsys_ios::ios_base::failbit; }
+    if(is.peek() == EOF) { state |= std::ios_base::eofbit; }
+    if(!success) { state |= std::ios_base::failbit; }
     else { value = result; }
-#   if KWSYS_IOS_USE_ANSI
-    } catch(...) { state |= kwsys_ios::ios_base::badbit; }
-#   endif
+    } catch(...) { state |= std::ios_base::badbit; }
     }
 
-# if KWSYS_IOS_USE_ANSI
-  is.setstate(kwsys_ios::ios_base::iostate(state));
-# else
-  is.clear(state);
-# endif
+  is.setstate(std::ios_base::iostate(state));
   return is;
 }
 
 // Print an integer value to an output stream.
 template <class T>
-kwsys_ios::ostream&
-IOStreamPrintTemplate(kwsys_ios::ostream& os, T value, char type)
+std::ostream&
+IOStreamPrintTemplate(std::ostream& os, T value, char type)
 {
-# if KWSYS_IOS_USE_ANSI
-  kwsys_ios::ostream::sentry okay(os);
-# else
-  kwsys_ios::ostream& okay = os;
-# endif
+  std::ostream::sentry okay(os);
   if(okay)
     {
-#   if KWSYS_IOS_USE_ANSI
     try {
-#   endif
     // Construct the format string.
     char format[8];
     char* f = format;
     *f++ = '%';
-    if(os.flags() & kwsys_ios::ios_base::showpos) { *f++ = '+'; }
-    if(os.flags() & kwsys_ios::ios_base::showbase) { *f++ = '#'; }
+    if(os.flags() & std::ios_base::showpos) { *f++ = '+'; }
+    if(os.flags() & std::ios_base::showbase) { *f++ = '#'; }
 #   if defined(_MSC_VER)
     *f++ = 'I'; *f++ = '6'; *f++ = '4';
 #   else
     *f++ = 'l'; *f++ = 'l';
 #   endif
-    long bflags = os.flags() & kwsys_ios::ios_base::basefield;
-    if(bflags == kwsys_ios::ios_base::oct) { *f++ = 'o'; }
-    else if(bflags != kwsys_ios::ios_base::hex) { *f++ = type; }
-    else if(os.flags() & kwsys_ios::ios_base::uppercase) { *f++ = 'X'; }
+    long bflags = os.flags() & std::ios_base::basefield;
+    if(bflags == std::ios_base::oct) { *f++ = 'o'; }
+    else if(bflags != std::ios_base::hex) { *f++ = type; }
+    else if(os.flags() & std::ios_base::uppercase) { *f++ = 'X'; }
     else { *f++ = 'x'; }
     *f = '\0';
 
@@ -228,22 +198,20 @@ IOStreamPrintTemplate(kwsys_ios::ostream& os, T value, char type)
     char buffer[2*KWSYS_IOS_INT64_MAX_DIG];
     sprintf(buffer, format, value);
     os << buffer;
-#   if KWSYS_IOS_USE_ANSI
-    } catch(...) { os.clear(os.rdstate() | kwsys_ios::ios_base::badbit); }
-#   endif
+    } catch(...) { os.clear(os.rdstate() | std::ios_base::badbit); }
     }
   return os;
 }
 
 # if !KWSYS_IOS_HAS_ISTREAM_LONG_LONG
 // Implement input stream operator for IOStreamSLL.
-kwsys_ios::istream& IOStreamScan(kwsys_ios::istream& is, IOStreamSLL& value)
+std::istream& IOStreamScan(std::istream& is, IOStreamSLL& value)
 {
   return IOStreamScanTemplate(is, value, 'd');
 }
 
 // Implement input stream operator for IOStreamULL.
-kwsys_ios::istream& IOStreamScan(kwsys_ios::istream& is, IOStreamULL& value)
+std::istream& IOStreamScan(std::istream& is, IOStreamULL& value)
 {
   return IOStreamScanTemplate(is, value, 'u');
 }
@@ -251,13 +219,13 @@ kwsys_ios::istream& IOStreamScan(kwsys_ios::istream& is, IOStreamULL& value)
 
 # if !KWSYS_IOS_HAS_OSTREAM_LONG_LONG
 // Implement output stream operator for IOStreamSLL.
-kwsys_ios::ostream& IOStreamPrint(kwsys_ios::ostream& os, IOStreamSLL value)
+std::ostream& IOStreamPrint(std::ostream& os, IOStreamSLL value)
 {
   return IOStreamPrintTemplate(os, value, 'd');
 }
 
 // Implement output stream operator for IOStreamULL.
-kwsys_ios::ostream& IOStreamPrint(kwsys_ios::ostream& os, IOStreamULL value)
+std::ostream& IOStreamPrint(std::ostream& os, IOStreamULL value)
 {
   return IOStreamPrintTemplate(os, value, 'u');
 }

Source/kwsys/IOStream.hxx.in

@@ -12,12 +12,11 @@
 #ifndef @KWSYS_NAMESPACE@_IOStream_hxx
 #define @KWSYS_NAMESPACE@_IOStream_hxx
 
-#include <@KWSYS_NAMESPACE@/ios/iosfwd>
+#include <iosfwd>
 
 /* Define these macros temporarily to keep the code readable.  */
 #if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
 # define kwsysEXPORT @KWSYS_NAMESPACE@_EXPORT
-# define kwsys_ios @KWSYS_NAMESPACE@_ios
 #endif
 
 /* Whether istream supports long long.  */
@@ -56,10 +55,8 @@
 /* Input stream operator implementation functions.  */
 namespace @KWSYS_NAMESPACE@
 {
-kwsysEXPORT kwsys_ios::istream& IOStreamScan(kwsys_ios::istream&,
-                                             IOStreamSLL&);
-kwsysEXPORT kwsys_ios::istream& IOStreamScan(kwsys_ios::istream&,
-                                             IOStreamULL&);
+kwsysEXPORT std::istream& IOStreamScan(std::istream&, IOStreamSLL&);
+kwsysEXPORT std::istream& IOStreamScan(std::istream&, IOStreamULL&);
 }
 
 /* Provide input stream operator for long long.  */
@@ -67,8 +64,8 @@ kwsysEXPORT kwsys_ios::istream& IOStreamScan(kwsys_ios::istream&,
       !defined(KWSYS_IOS_ISTREAM_LONG_LONG_DEFINED)
 #   define KWSYS_IOS_ISTREAM_LONG_LONG_DEFINED
 #   define @KWSYS_NAMESPACE@_IOS_ISTREAM_LONG_LONG_DEFINED
-inline kwsys_ios::istream&
-operator>>(kwsys_ios::istream& is, @KWSYS_NAMESPACE@::IOStreamSLL& value)
+inline std::istream&
+operator>>(std::istream& is, @KWSYS_NAMESPACE@::IOStreamSLL& value)
 {
   return @KWSYS_NAMESPACE@::IOStreamScan(is, value);
 }
@@ -79,8 +76,8 @@ operator>>(kwsys_ios::istream& is, @KWSYS_NAMESPACE@::IOStreamSLL& value)
       !defined(KWSYS_IOS_ISTREAM_UNSIGNED_LONG_LONG_DEFINED)
 #   define KWSYS_IOS_ISTREAM_UNSIGNED_LONG_LONG_DEFINED
 #   define @KWSYS_NAMESPACE@_IOS_ISTREAM_UNSIGNED_LONG_LONG_DEFINED
-inline kwsys_ios::istream&
-operator>>(kwsys_ios::istream& is, @KWSYS_NAMESPACE@::IOStreamULL& value)
+inline std::istream&
+operator>>(std::istream& is, @KWSYS_NAMESPACE@::IOStreamULL& value)
 {
   return @KWSYS_NAMESPACE@::IOStreamScan(is, value);
 }
@@ -92,10 +89,8 @@ operator>>(kwsys_ios::istream& is, @KWSYS_NAMESPACE@::IOStreamULL& value)
 /* Output stream operator implementation functions.  */
 namespace @KWSYS_NAMESPACE@
 {
-kwsysEXPORT kwsys_ios::ostream& IOStreamPrint(kwsys_ios::ostream&,
-                                              IOStreamSLL);
-kwsysEXPORT kwsys_ios::ostream& IOStreamPrint(kwsys_ios::ostream&,
-                                              IOStreamULL);
+kwsysEXPORT std::ostream& IOStreamPrint(std::ostream&, IOStreamSLL);
+kwsysEXPORT std::ostream& IOStreamPrint(std::ostream&, IOStreamULL);
 }
 
 /* Provide output stream operator for long long.  */
@@ -103,8 +98,8 @@ kwsysEXPORT kwsys_ios::ostream& IOStreamPrint(kwsys_ios::ostream&,
       !defined(KWSYS_IOS_OSTREAM_LONG_LONG_DEFINED)
 #   define KWSYS_IOS_OSTREAM_LONG_LONG_DEFINED
 #   define @KWSYS_NAMESPACE@_IOS_OSTREAM_LONG_LONG_DEFINED
-inline kwsys_ios::ostream&
-operator<<(kwsys_ios::ostream& os, @KWSYS_NAMESPACE@::IOStreamSLL value)
+inline std::ostream&
+operator<<(std::ostream& os, @KWSYS_NAMESPACE@::IOStreamSLL value)
 {
   return @KWSYS_NAMESPACE@::IOStreamPrint(os, value);
 }
@@ -115,8 +110,8 @@ operator<<(kwsys_ios::ostream& os, @KWSYS_NAMESPACE@::IOStreamSLL value)
       !defined(KWSYS_IOS_OSTREAM_UNSIGNED_LONG_LONG_DEFINED)
 #   define KWSYS_IOS_OSTREAM_UNSIGNED_LONG_LONG_DEFINED
 #   define @KWSYS_NAMESPACE@_IOS_OSTREAM_UNSIGNED_LONG_LONG_DEFINED
-inline kwsys_ios::ostream&
-operator<<(kwsys_ios::ostream& os, @KWSYS_NAMESPACE@::IOStreamULL value)
+inline std::ostream&
+operator<<(std::ostream& os, @KWSYS_NAMESPACE@::IOStreamULL value)
 {
   return @KWSYS_NAMESPACE@::IOStreamPrint(os, value);
 }
@@ -127,7 +122,6 @@ operator<<(kwsys_ios::ostream& os, @KWSYS_NAMESPACE@::IOStreamULL value)
 /* Undefine temporary macros.  */
 #if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
 # undef kwsysEXPORT
-# undef kwsys_ios
 #endif
 
 /* If building a C++ file in kwsys itself, give the source file

Source/kwsys/RegularExpression.hxx.in

@@ -33,12 +33,7 @@
 #include <@KWSYS_NAMESPACE@/Configure.h>
 #include <@KWSYS_NAMESPACE@/Configure.hxx>
 
-#include <@KWSYS_NAMESPACE@/stl/string>
-
-/* Define this macro temporarily to keep the code readable.  */
-#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-# define kwsys_stl @KWSYS_NAMESPACE@_stl
-#endif
+#include <string>
 
 /* Disable useless Borland warnings.  KWSys tries not to force things
    on its includers, but there is no choice here.  */
@@ -207,7 +202,7 @@ public:
   /**
    * Instantiate RegularExpression with compiled string.
    */
-  inline RegularExpression (kwsys_stl::string const&);
+  inline RegularExpression (std::string const&);
 
   /**
    * Destructor.
@@ -224,7 +219,7 @@ public:
    * Compile a regular expression into internal code
    * for later pattern matching.
    */
-  inline bool compile (kwsys_stl::string const&);
+  inline bool compile (std::string const&);
 
   /**
    * Matches the regular expression to the given string.
@@ -236,17 +231,17 @@ public:
    * Matches the regular expression to the given std string.
    * Returns true if found, and sets start and end indexes accordingly.
    */
-  inline bool find (kwsys_stl::string const&);
+  inline bool find (std::string const&);
 
   /**
    * Index to start of first find.
    */
-  inline kwsys_stl::string::size_type start() const;
+  inline std::string::size_type start() const;
 
   /**
    * Index to end of first find.
    */
-  inline kwsys_stl::string::size_type end() const;
+  inline std::string::size_type end() const;
 
   /**
    * Copy the given regular expression.
@@ -285,9 +280,9 @@ public:
    * Destructor.
    */
   // awf added
-  kwsys_stl::string::size_type start(int n) const;
-  kwsys_stl::string::size_type end(int n) const;
-  kwsys_stl::string match(int n) const;
+  std::string::size_type start(int n) const;
+  std::string::size_type end(int n) const;
+  std::string match(int n) const;
   
   enum { NSUBEXP = 10 };
 private: 
@@ -296,7 +291,7 @@ private:
   char  regstart;                       // Internal use only
   char  reganch;                        // Internal use only
   const char* regmust;                  // Internal use only
-  kwsys_stl::string::size_type regmlen;                // Internal use only
+  std::string::size_type regmlen;                // Internal use only
   char* program;   
   int   progsize;
   const char* searchstring;
@@ -327,7 +322,7 @@ inline RegularExpression::RegularExpression (const char* s)
  * Creates a regular expression from string s, and
  * compiles s.
  */
-inline RegularExpression::RegularExpression (const kwsys_stl::string& s)
+inline RegularExpression::RegularExpression (const std::string& s)
 {
   this->program = 0;
   this->compile(s);
@@ -347,7 +342,7 @@ inline RegularExpression::~RegularExpression ()
  * Compile a regular expression into internal code
  * for later pattern matching.
  */
-inline bool RegularExpression::compile (kwsys_stl::string const& s)
+inline bool RegularExpression::compile (std::string const& s)
 {
   return this->compile(s.c_str());
 }
@@ -356,7 +351,7 @@ inline bool RegularExpression::compile (kwsys_stl::string const& s)
  * Matches the regular expression to the given std string.
  * Returns true if found, and sets start and end indexes accordingly.
  */
-inline bool RegularExpression::find (kwsys_stl::string const& s)
+inline bool RegularExpression::find (std::string const& s)
 {
   return this->find(s.c_str());
 }
@@ -364,9 +359,9 @@ inline bool RegularExpression::find (kwsys_stl::string const& s)
 /**
  * Set the start position for the regular expression.
  */
-inline kwsys_stl::string::size_type RegularExpression::start () const 
+inline std::string::size_type RegularExpression::start () const
 {
-  return static_cast<kwsys_stl::string::size_type>(
+  return static_cast<std::string::size_type>(
     this->startp[0] - searchstring);
 }
 
@@ -374,9 +369,9 @@ inline kwsys_stl::string::size_type RegularExpression::start () const
 /**
  * Returns the start/end index of the last item found.
  */
-inline kwsys_stl::string::size_type RegularExpression::end () const 
+inline std::string::size_type RegularExpression::end () const
 {
-  return static_cast<kwsys_stl::string::size_type>(
+  return static_cast<std::string::size_type>(
     this->endp[0] - searchstring);
 }
 
@@ -410,9 +405,9 @@ inline void RegularExpression::set_invalid ()
 /**
  * Return start index of nth submatch. start(0) is the start of the full match.
  */
-inline kwsys_stl::string::size_type RegularExpression::start(int n) const
+inline std::string::size_type RegularExpression::start(int n) const
 {
-  return static_cast<kwsys_stl::string::size_type>(
+  return static_cast<std::string::size_type>(
     this->startp[n] - searchstring);
 }
 
@@ -420,34 +415,29 @@ inline kwsys_stl::string::size_type RegularExpression::start(int n) const
 /**
  * Return end index of nth submatch. end(0) is the end of the full match.
  */
-inline kwsys_stl::string::size_type RegularExpression::end(int n) const
+inline std::string::size_type RegularExpression::end(int n) const
 {
-  return static_cast<kwsys_stl::string::size_type>(
+  return static_cast<std::string::size_type>(
     this->endp[n] - searchstring);
 }
 
 /**
  * Return nth submatch as a string.
  */
-inline kwsys_stl::string RegularExpression::match(int n) const
+inline std::string RegularExpression::match(int n) const
 {
   if (this->startp[n]==0)
     {
-    return kwsys_stl::string("");
+    return std::string("");
     }
   else
     {
-    return kwsys_stl::string(this->startp[n],
-                             static_cast<kwsys_stl::string::size_type>(
+    return std::string(this->startp[n],
+                             static_cast<std::string::size_type>(
                                this->endp[n] - this->startp[n]));
     }
 }
 
 } // namespace @KWSYS_NAMESPACE@
 
-/* Undefine temporary macro.  */
-#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-# undef kwsys_stl
-#endif
-
 #endif

Source/kwsys/String.hxx.in

@@ -12,7 +12,7 @@
 #ifndef @KWSYS_NAMESPACE@_String_hxx
 #define @KWSYS_NAMESPACE@_String_hxx
 
-#include <@KWSYS_NAMESPACE@/stl/string>
+#include <string>
 
 namespace @KWSYS_NAMESPACE@
 {
@@ -25,10 +25,10 @@ namespace @KWSYS_NAMESPACE@
  * simply a subclass of this type with the same interface so that the
  * name is shorter in debugging symbols and error messages.
  */
-class String: public @KWSYS_NAMESPACE@_stl::string
+class String: public std::string
 {
   /** The original string type.  */
-  typedef @KWSYS_NAMESPACE@_stl::string stl_string;
+  typedef std::string stl_string;
 
 public:
 
@@ -55,8 +55,8 @@ public:
 #if defined(__WATCOMC__)
 inline bool operator<(String const& l, String const& r)
   {
-  return (static_cast<@KWSYS_NAMESPACE@_stl::string const&>(l) <
-          static_cast<@KWSYS_NAMESPACE@_stl::string const&>(r));
+  return (static_cast<std::string const&>(l) <
+          static_cast<std::string const&>(r));
   }
 #endif
 

Source/kwsys/SystemInformation.cxx

@@ -35,14 +35,8 @@
 // http://msdn.microsoft.com/en-us/library/ms683219(VS.85).aspx
 
 #include "kwsysPrivate.h"
-#include KWSYS_HEADER(stl/string)
-#include KWSYS_HEADER(stl/vector)
-#include KWSYS_HEADER(ios/iosfwd)
 #include KWSYS_HEADER(SystemInformation.hxx)
 #include KWSYS_HEADER(Process.h)
-#include KWSYS_HEADER(ios/iostream)
-#include KWSYS_HEADER(ios/sstream)
-#include KWSYS_HEADER(ios/fstream)
 
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
@@ -50,14 +44,14 @@
 # include "SystemInformation.hxx.in"
 # include "Process.h.in"
 # include "Configure.hxx.in"
-# include "kwsys_stl.hxx.in"
-# include "kwsys_stl_vector.in"
-# include "kwsys_stl_iosfwd.in"
-# include "kwsys_ios_sstream.h.in"
-# include "kwsys_ios_iostream.h.in"
-# include "kwsys_ios_fstream.h.in"
 #endif
 
+#include <iostream>
+#include <sstream>
+#include <fstream>
+#include <string>
+#include <vector>
+
 #if defined(_WIN32)
 # include <windows.h>
 # if defined(_MSC_VER) && _MSC_VER >= 1800
@@ -325,11 +319,11 @@ public:
 
   const char * GetVendorString();
   const char * GetVendorID();
-  kwsys_stl::string GetTypeID();
-  kwsys_stl::string GetFamilyID();
-  kwsys_stl::string GetModelID();
-  kwsys_stl::string GetModelName();
-  kwsys_stl::string GetSteppingCode();
+  std::string GetTypeID();
+  std::string GetFamilyID();
+  std::string GetModelID();
+  std::string GetModelName();
+  std::string GetSteppingCode();
   const char * GetExtendedProcessorName();
   const char * GetProcessorSerialNumber();
   int GetProcessorCacheSize();
@@ -341,7 +335,7 @@ public:
 
   const char * GetOSName();
   const char * GetHostname();
-  int GetFullyQualifiedDomainName(kwsys_stl::string &fqdn);
+  int GetFullyQualifiedDomainName(std::string &fqdn);
   const char * GetOSRelease();
   const char * GetOSVersion();
   const char * GetOSPlatform();
@@ -379,7 +373,7 @@ public:
 
   // get current stack
   static
-  kwsys_stl::string GetProgramStack(int firstFrame, int wholePath);
+  std::string GetProgramStack(int firstFrame, int wholePath);
 
   /** Run the different checks */
   void RunCPUCheck();
@@ -395,10 +389,10 @@ public:
     int Revision;
     int ExtendedFamily;
     int ExtendedModel;
-    kwsys_stl::string ProcessorName;
-    kwsys_stl::string Vendor;
-    kwsys_stl::string SerialNumber;
-    kwsys_stl::string ModelName;
+    std::string ProcessorName;
+    std::string Vendor;
+    std::string SerialNumber;
+    std::string ModelName;
     } ID;
 
   typedef struct tagCPUPowerManagement
@@ -480,7 +474,7 @@ protected:
 
   // For Linux and Cygwin, /proc/cpuinfo formats are slightly different
   bool RetreiveInformationFromCpuInfoFile();
-  kwsys_stl::string ExtractValueFromCpuInfoFile(kwsys_stl::string buffer,
+  std::string ExtractValueFromCpuInfoFile(std::string buffer,
                                           const char* word, size_t init=0);
 
   bool QueryLinuxMemory();
@@ -489,20 +483,20 @@ protected:
   static void Delay (unsigned int);
   static void DelayOverhead (unsigned int);
 
-  void FindManufacturer(const kwsys_stl::string &family = "");
+  void FindManufacturer(const std::string &family = "");
 
   // For Mac
   bool ParseSysCtl();
-  int CallSwVers(const char *arg, kwsys_stl::string &ver);
-  void TrimNewline(kwsys_stl::string&);
-  kwsys_stl::string ExtractValueFromSysCtl(const char* word);
-  kwsys_stl::string SysCtlBuffer;
+  int CallSwVers(const char *arg, std::string &ver);
+  void TrimNewline(std::string&);
+  std::string ExtractValueFromSysCtl(const char* word);
+  std::string SysCtlBuffer;
 
   // For Solaris
   bool QuerySolarisMemory();
   bool QuerySolarisProcessor();
-  kwsys_stl::string ParseValueFromKStat(const char* arguments);
-  kwsys_stl::string RunProcess(kwsys_stl::vector<const char*> args);
+  std::string ParseValueFromKStat(const char* arguments);
+  std::string RunProcess(std::vector<const char*> args);
 
   //For Haiku OS
   bool QueryHaikuInfo();
@@ -540,11 +534,11 @@ protected:
 
   // Operating System information
   bool QueryOSInformation();
-  kwsys_stl::string OSName;
-  kwsys_stl::string Hostname;
-  kwsys_stl::string OSRelease;
-  kwsys_stl::string OSVersion;
-  kwsys_stl::string OSPlatform;
+  std::string OSName;
+  std::string Hostname;
+  std::string OSRelease;
+  std::string OSVersion;
+  std::string OSPlatform;
 };
 
 
@@ -568,27 +562,27 @@ const char * SystemInformation::GetVendorID()
   return this->Implementation->GetVendorID();
 }
 
-kwsys_stl::string SystemInformation::GetTypeID()
+std::string SystemInformation::GetTypeID()
 {
   return this->Implementation->GetTypeID();
 }
 
-kwsys_stl::string SystemInformation::GetFamilyID()
+std::string SystemInformation::GetFamilyID()
 {
   return this->Implementation->GetFamilyID();
 }
 
-kwsys_stl::string SystemInformation::GetModelID()
+std::string SystemInformation::GetModelID()
 {
   return this->Implementation->GetModelID();
 }
 
-kwsys_stl::string SystemInformation::GetModelName()
+std::string SystemInformation::GetModelName()
 {
   return this->Implementation->GetModelName();
 }
 
-kwsys_stl::string SystemInformation::GetSteppingCode()
+std::string SystemInformation::GetSteppingCode()
 {
   return this->Implementation->GetSteppingCode();
 }
@@ -633,9 +627,9 @@ bool SystemInformation::DoesCPUSupportFeature(long int i)
   return this->Implementation->DoesCPUSupportFeature(i);
 }
 
-kwsys_stl::string SystemInformation::GetCPUDescription()
+std::string SystemInformation::GetCPUDescription()
 {
-  kwsys_ios::ostringstream oss;
+  std::ostringstream oss;
   oss
     << this->GetNumberOfPhysicalCPU()
     << " core ";
@@ -654,9 +648,9 @@ kwsys_stl::string SystemInformation::GetCPUDescription()
     }
 
   // remove extra spaces
-  kwsys_stl::string tmp=oss.str();
+  std::string tmp=oss.str();
   size_t pos;
-  while( (pos=tmp.find("  "))!=kwsys_stl::string::npos)
+  while( (pos=tmp.find("  "))!=std::string::npos)
     {
     tmp.replace(pos,2," ");
     }
@@ -674,9 +668,9 @@ const char * SystemInformation::GetHostname()
   return this->Implementation->GetHostname();
 }
 
-kwsys_stl::string SystemInformation::GetFullyQualifiedDomainName()
+std::string SystemInformation::GetFullyQualifiedDomainName()
 {
-  kwsys_stl::string fqdn;
+  std::string fqdn;
   this->Implementation->GetFullyQualifiedDomainName(fqdn);
   return fqdn;
 }
@@ -723,9 +717,9 @@ int SystemInformation::GetOSIsApple()
 #endif
 }
 
-kwsys_stl::string SystemInformation::GetOSDescription()
+std::string SystemInformation::GetOSDescription()
 {
-  kwsys_ios::ostringstream oss;
+  std::ostringstream oss;
   oss
     << this->GetOSName()
     << " "
@@ -777,11 +771,11 @@ size_t SystemInformation::GetAvailablePhysicalMemory()
   return this->Implementation->GetAvailablePhysicalMemory();
 }
 
-kwsys_stl::string SystemInformation::GetMemoryDescription(
+std::string SystemInformation::GetMemoryDescription(
       const char *hostLimitEnvVarName,
       const char *procLimitEnvVarName)
 {
-  kwsys_ios::ostringstream oss;
+  std::ostringstream oss;
   oss
     << "Host Total: "
     << iostreamLongLong(this->GetHostMemoryTotal())
@@ -842,7 +836,7 @@ void SystemInformation::SetStackTraceOnError(int enable)
   SystemInformationImplementation::SetStackTraceOnError(enable);
 }
 
-kwsys_stl::string SystemInformation::GetProgramStack(int firstFrame, int wholePath)
+std::string SystemInformation::GetProgramStack(int firstFrame, int wholePath)
 {
   return SystemInformationImplementation::GetProgramStack(firstFrame, wholePath);
 }
@@ -926,7 +920,7 @@ namespace {
 #if defined(__linux) || defined(__APPLE__)
 int LoadLines(
       FILE *file,
-      kwsys_stl::vector<kwsys_stl::string> &lines)
+      std::vector<std::string> &lines)
 {
   // Load each line in the given file into a the vector.
   int nRead=0;
@@ -963,7 +957,7 @@ int LoadLines(
 // *****************************************************************************
 int LoadLines(
       const char *fileName,
-      kwsys_stl::vector<kwsys_stl::string> &lines)
+      std::vector<std::string> &lines)
 {
   FILE *file=fopen(fileName,"r");
   if (file==0)
@@ -979,18 +973,18 @@ int LoadLines(
 // ****************************************************************************
 template<typename T>
 int NameValue(
-      kwsys_stl::vector<kwsys_stl::string> &lines,
-      kwsys_stl::string name, T &value)
+      std::vector<std::string> &lines,
+      std::string name, T &value)
 {
   size_t nLines=lines.size();
   for (size_t i=0; i<nLines; ++i)
     {
     size_t at=lines[i].find(name);
-    if (at==kwsys_stl::string::npos)
+    if (at==std::string::npos)
       {
       continue;
       }
-    kwsys_ios::istringstream is(lines[i].substr(at+name.size()));
+    std::istringstream is(lines[i].substr(at+name.size()));
     is >> value;
     return 0;
     }
@@ -1006,7 +1000,7 @@ int GetFieldsFromFile(
       const char **fieldNames,
       T *values)
 {
-  kwsys_stl::vector<kwsys_stl::string> fields;
+  std::vector<std::string> fields;
   if (!LoadLines(fileName,fields))
     {
     return -1;
@@ -1056,7 +1050,7 @@ int GetFieldsFromCommand(
     {
     return -1;
     }
-  kwsys_stl::vector<kwsys_stl::string> fields;
+  std::vector<std::string> fields;
   int nl=LoadLines(file,fields);
   pclose(file);
   if (nl==0)
@@ -1085,10 +1079,10 @@ void StacktraceSignalHandler(
       void * /*sigContext*/)
 {
 #if defined(__linux) || defined(__APPLE__)
-  kwsys_ios::ostringstream oss;
+  std::ostringstream oss;
   oss
-     << kwsys_ios::endl
-     << "=========================================================" << kwsys_ios::endl
+     << std::endl
+     << "=========================================================" << std::endl
      << "Process id " << getpid() << " ";
   switch (sigNo)
     {
@@ -1281,11 +1275,11 @@ void StacktraceSignalHandler(
       break;
     }
   oss
-    << kwsys_ios::endl
-    << "Program Stack:" << kwsys_ios::endl
+    << std::endl
+    << "Program Stack:" << std::endl
     << SystemInformationImplementation::GetProgramStack(2,0)
-    << "=========================================================" << kwsys_ios::endl;
-  kwsys_ios::cerr << oss.str() << kwsys_ios::endl;
+    << "=========================================================" << std::endl;
+  std::cerr << oss.str() << std::endl;
 
   // restore the previously registered handlers
   // and abort
@@ -1330,7 +1324,7 @@ public:
   void SetBinary(const char *binary)
     { this->Binary=safes(binary); }
 
-  kwsys_stl::string GetBinary() const;
+  std::string GetBinary() const;
 
   // Description:
   // Set the name of the function that the symbol is found in.
@@ -1338,7 +1332,7 @@ public:
   void SetFunction(const char *function)
     { this->Function=this->Demangle(function); }
 
-  kwsys_stl::string GetFunction() const
+  std::string GetFunction() const
     { return this->Function; }
 
   // Description:
@@ -1347,7 +1341,7 @@ public:
   void SetSourceFile(const char *sourcefile)
     { this->SourceFile=safes(sourcefile); }
 
-  kwsys_stl::string GetSourceFile() const
+  std::string GetSourceFile() const
     { return this->GetFileName(this->SourceFile); }
 
   // Description:
@@ -1365,31 +1359,31 @@ private:
   void *GetRealAddress() const
     { return (void*)((char*)this->Address-(char*)this->BinaryBaseAddress); }
 
-  kwsys_stl::string GetFileName(const kwsys_stl::string &path) const;
-  kwsys_stl::string Demangle(const char *symbol) const;
+  std::string GetFileName(const std::string &path) const;
+  std::string Demangle(const char *symbol) const;
 
 private:
-  kwsys_stl::string Binary;
+  std::string Binary;
   void *BinaryBaseAddress;
   void *Address;
-  kwsys_stl::string SourceFile;
-  kwsys_stl::string Function;
+  std::string SourceFile;
+  std::string Function;
   long LineNumber;
   int ReportPath;
 };
 
 // --------------------------------------------------------------------------
-kwsys_ios::ostream &operator<<(
-      kwsys_ios::ostream &os,
+std::ostream &operator<<(
+      std::ostream &os,
       const SymbolProperties &sp)
 {
 #if defined(KWSYS_SYSTEMINFORMATION_HAS_SYMBOL_LOOKUP)
   os
-    << kwsys_ios::hex << sp.GetAddress() << " : "
+    << std::hex << sp.GetAddress() << " : "
     << sp.GetFunction()
     << " [(" << sp.GetBinary() << ") "
     << sp.GetSourceFile() << ":"
-    << kwsys_ios::dec << sp.GetLineNumber() << "]";
+    << std::dec << sp.GetLineNumber() << "]";
 #elif defined(KWSYS_SYSTEMINFORMATION_HAS_BACKTRACE)
   void *addr = sp.GetAddress();
   char **syminfo = backtrace_symbols(&addr,1);
@@ -1422,28 +1416,28 @@ SymbolProperties::SymbolProperties()
 }
 
 // --------------------------------------------------------------------------
-kwsys_stl::string SymbolProperties::GetFileName(const kwsys_stl::string &path) const
+std::string SymbolProperties::GetFileName(const std::string &path) const
 {
-  kwsys_stl::string file(path);
+  std::string file(path);
   if (!this->ReportPath)
     {
     size_t at = file.rfind("/");
-    if (at!=kwsys_stl::string::npos)
+    if (at!=std::string::npos)
       {
-      file = file.substr(at+1,kwsys_stl::string::npos);
+      file = file.substr(at+1,std::string::npos);
       }
     }
   return file;
 }
 
 // --------------------------------------------------------------------------
-kwsys_stl::string SymbolProperties::GetBinary() const
+std::string SymbolProperties::GetBinary() const
 {
 // only linux has proc fs
 #if defined(__linux__)
   if (this->Binary=="/proc/self/exe")
     {
-    kwsys_stl::string binary;
+    std::string binary;
     char buf[1024]={'\0'};
     ssize_t ll=0;
     if ((ll=readlink("/proc/self/exe",buf,1024))>0)
@@ -1462,9 +1456,9 @@ kwsys_stl::string SymbolProperties::GetBinary() const
 }
 
 // --------------------------------------------------------------------------
-kwsys_stl::string SymbolProperties::Demangle(const char *symbol) const
+std::string SymbolProperties::Demangle(const char *symbol) const
 {
-  kwsys_stl::string result = safes(symbol);
+  std::string result = safes(symbol);
 #if defined(KWSYS_SYSTEMINFORMATION_HAS_CPP_DEMANGLE)
   int status = 0;
   size_t bufferLen = 1024;
@@ -1729,7 +1723,7 @@ const char* SystemInformationImplementation::GetHostname()
 
 /** Get the FQDN */
 int SystemInformationImplementation::GetFullyQualifiedDomainName(
-      kwsys_stl::string &fqdn)
+      std::string &fqdn)
 {
   // in the event of absolute failure return localhost.
   fqdn="localhost";
@@ -1820,8 +1814,8 @@ int SystemInformationImplementation::GetFullyQualifiedDomainName(
         continue;
         }
 
-      kwsys_stl::string candidate=host;
-      if ((candidate.find(base)!=kwsys_stl::string::npos) && baseSize<candidate.size())
+      std::string candidate=host;
+      if ((candidate.find(base)!=std::string::npos) && baseSize<candidate.size())
         {
         // success, stop now.
         ierr=0;
@@ -1897,39 +1891,39 @@ const char * SystemInformationImplementation::GetVendorID()
 }
 
 /** Return the type ID of the CPU */
-kwsys_stl::string SystemInformationImplementation::GetTypeID()
+std::string SystemInformationImplementation::GetTypeID()
 {
-  kwsys_ios::ostringstream str;
+  std::ostringstream str;
   str << this->ChipID.Type;
   return str.str();
 }
 
 /** Return the family of the CPU present */
-kwsys_stl::string SystemInformationImplementation::GetFamilyID()
+std::string SystemInformationImplementation::GetFamilyID()
 {
-  kwsys_ios::ostringstream str;
+  std::ostringstream str;
   str << this->ChipID.Family;
   return str.str();
 }
 
 // Return the model of CPU present */
-kwsys_stl::string SystemInformationImplementation::GetModelID()
+std::string SystemInformationImplementation::GetModelID()
 {
-  kwsys_ios::ostringstream str;
+  std::ostringstream str;
   str << this->ChipID.Model;
   return str.str();
 }
 
 // Return the model name of CPU present */
-kwsys_stl::string SystemInformationImplementation::GetModelName()
+std::string SystemInformationImplementation::GetModelName()
 {
   return this->ChipID.ModelName;
 }
 
 /** Return the stepping code of the CPU present. */
-kwsys_stl::string SystemInformationImplementation::GetSteppingCode()
+std::string SystemInformationImplementation::GetSteppingCode()
 {
-  kwsys_ios::ostringstream str;
+  std::ostringstream str;
   str << this->ChipID.Revision;
   return str.str();
 }
@@ -2180,7 +2174,7 @@ bool SystemInformationImplementation::RetrieveCPUFeatures()
 
 
 /** Find the manufacturer given the vendor id */
-void SystemInformationImplementation::FindManufacturer(const kwsys_stl::string& family)
+void SystemInformationImplementation::FindManufacturer(const std::string& family)
 {
   if (this->ChipID.Vendor == "GenuineIntel")       this->ChipManufacturer = Intel;        // Intel Corp.
   else if (this->ChipID.Vendor == "UMC UMC UMC ")  this->ChipManufacturer = UMC;          // United Microelectronics Corp.
@@ -2799,11 +2793,11 @@ bool SystemInformationImplementation::RetrieveCPUPowerManagement()
 
 #if USE_CPUID
 // Used only in USE_CPUID implementation below.
-static void SystemInformationStripLeadingSpace(kwsys_stl::string& str)
+static void SystemInformationStripLeadingSpace(std::string& str)
 {
   // Because some manufacturers have leading white space - we have to post-process the name.
-  kwsys_stl::string::size_type pos = str.find_first_not_of(" ");
-  if(pos != kwsys_stl::string::npos)
+  std::string::size_type pos = str.find_first_not_of(" ");
+  if(pos != std::string::npos)
     {
     str = str.substr(pos);
     }
@@ -3148,7 +3142,7 @@ bool SystemInformationImplementation::RetrieveClassicalCPUIdentity()
 
 
 /** Extract a value from the CPUInfo file */
-kwsys_stl::string SystemInformationImplementation::ExtractValueFromCpuInfoFile(kwsys_stl::string buffer,const char* word,size_t init)
+std::string SystemInformationImplementation::ExtractValueFromCpuInfoFile(std::string buffer,const char* word,size_t init)
 {
   size_t pos = buffer.find(word,init);
   if(pos != buffer.npos)
@@ -3180,12 +3174,12 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile()
 {
   this->NumberOfLogicalCPU = 0;
   this->NumberOfPhysicalCPU = 0;
-  kwsys_stl::string buffer;
+  std::string buffer;
 
   FILE *fd = fopen("/proc/cpuinfo", "r" );
   if ( !fd )
     {
-    kwsys_ios::cout << "Problem opening /proc/cpuinfo" << kwsys_ios::endl;
+    std::cout << "Problem opening /proc/cpuinfo" << std::endl;
     return false;
     }
 
@@ -3209,7 +3203,7 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile()
 #ifdef __linux
   // Find the largest physical id.
   int maxId = -1;
-  kwsys_stl::string idc =
+  std::string idc =
                        this->ExtractValueFromCpuInfoFile(buffer,"physical id");
   while(this->CurrentPositionInFile != buffer.npos)
     {
@@ -3224,7 +3218,7 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile()
   // Physical ids returned by Linux don't distinguish cores.
   // We want to record the total number of cores in this->NumberOfPhysicalCPU
   // (checking only the first proc)
-  kwsys_stl::string cores =
+  std::string cores =
                         this->ExtractValueFromCpuInfoFile(buffer,"cpu cores");
   int numberOfCoresPerCPU=atoi(cores.c_str());
   if (maxId > 0)
@@ -3242,7 +3236,7 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile()
 #else // __CYGWIN__
   // does not have "physical id" entries, neither "cpu cores"
   // this has to be fixed for hyper-threading.
-  kwsys_stl::string cpucount =
+  std::string cpucount =
     this->ExtractValueFromCpuInfoFile(buffer,"cpu count");
   this->NumberOfPhysicalCPU=
     this->NumberOfLogicalCPU = atoi(cpucount.c_str());
@@ -3258,7 +3252,7 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile()
       this->NumberOfLogicalCPU/this->NumberOfPhysicalCPU;
 
   // CPU speed (checking only the first processor)
-  kwsys_stl::string CPUSpeed = this->ExtractValueFromCpuInfoFile(buffer,"cpu MHz");
+  std::string CPUSpeed = this->ExtractValueFromCpuInfoFile(buffer,"cpu MHz");
   if(!CPUSpeed.empty())
     {
     this->CPUSpeedInMHz = static_cast<float>(atof(CPUSpeed.c_str()));
@@ -3274,7 +3268,7 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile()
 #endif
 
   // Chip family
-  kwsys_stl::string familyStr =
+  std::string familyStr =
     this->ExtractValueFromCpuInfoFile(buffer,"cpu family");
   if(familyStr.empty())
     {
@@ -3304,7 +3298,7 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile()
     {
     // Some platforms (e.g. PA-RISC) tell us their CPU name here.
     // Note: x86 does not.
-    kwsys_stl::string cpuname = this->ExtractValueFromCpuInfoFile(buffer,"cpu");
+    std::string cpuname = this->ExtractValueFromCpuInfoFile(buffer,"cpu");
     if(!cpuname.empty())
       {
       this->ChipID.ProcessorName = cpuname;
@@ -3312,7 +3306,7 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile()
     }
 
   // Chip revision
-  kwsys_stl::string cpurev = this->ExtractValueFromCpuInfoFile(buffer,"stepping");
+  std::string cpurev = this->ExtractValueFromCpuInfoFile(buffer,"stepping");
   if(cpurev.empty())
     {
     cpurev = this->ExtractValueFromCpuInfoFile(buffer,"CPU revision");
@@ -3325,7 +3319,7 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile()
   // L1 Cache size
   // Different architectures may show different names for the caches.
   // Sum up everything we find.
-  kwsys_stl::vector<const char*> cachename;
+  std::vector<const char*> cachename;
   cachename.clear();
 
   cachename.push_back("cache size"); // e.g. x86
@@ -3335,7 +3329,7 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile()
   this->Features.L1CacheSize = 0;
   for (size_t index = 0; index < cachename.size(); index ++)
     {
-    kwsys_stl::string cacheSize = this->ExtractValueFromCpuInfoFile(buffer,cachename[index]);
+    std::string cacheSize = this->ExtractValueFromCpuInfoFile(buffer,cachename[index]);
     if (!cacheSize.empty())
       {
       pos = cacheSize.find(" KB");
@@ -3348,48 +3342,48 @@ bool SystemInformationImplementation::RetreiveInformationFromCpuInfoFile()
     }
 
   // processor feature flags (probably x86 specific)
-  kwsys_stl::string cpuflags = this->ExtractValueFromCpuInfoFile(buffer,"flags");
+  std::string cpuflags = this->ExtractValueFromCpuInfoFile(buffer,"flags");
   if(!cpurev.empty())
     {
     // now we can match every flags as space + flag + space
     cpuflags = " " + cpuflags + " ";
-    if ((cpuflags.find(" fpu ")!=kwsys_stl::string::npos))
+    if ((cpuflags.find(" fpu ")!=std::string::npos))
       {
       this->Features.HasFPU = true;
       }
-    if ((cpuflags.find(" tsc ")!=kwsys_stl::string::npos))
+    if ((cpuflags.find(" tsc ")!=std::string::npos))
       {
       this->Features.HasTSC = true;
       }
-    if ((cpuflags.find(" mmx ")!=kwsys_stl::string::npos))
+    if ((cpuflags.find(" mmx ")!=std::string::npos))
       {
       this->Features.HasMMX = true;
       }
-    if ((cpuflags.find(" sse ")!=kwsys_stl::string::npos))
+    if ((cpuflags.find(" sse ")!=std::string::npos))
       {
       this->Features.HasSSE = true;
       }
-    if ((cpuflags.find(" sse2 ")!=kwsys_stl::string::npos))
+    if ((cpuflags.find(" sse2 ")!=std::string::npos))
       {
       this->Features.HasSSE2 = true;
       }
-    if ((cpuflags.find(" apic ")!=kwsys_stl::string::npos))
+    if ((cpuflags.find(" apic ")!=std::string::npos))
       {
       this->Features.HasAPIC = true;
       }
-    if ((cpuflags.find(" cmov ")!=kwsys_stl::string::npos))
+    if ((cpuflags.find(" cmov ")!=std::string::npos))
       {
       this->Features.HasCMOV = true;
       }
-    if ((cpuflags.find(" mtrr ")!=kwsys_stl::string::npos))
+    if ((cpuflags.find(" mtrr ")!=std::string::npos))
       {
       this->Features.HasMTRR = true;
       }
-    if ((cpuflags.find(" acpi ")!=kwsys_stl::string::npos))
+    if ((cpuflags.find(" acpi ")!=std::string::npos))
       {
       this->Features.HasACPI = true;
       }
-    if ((cpuflags.find(" 3dnow ")!=kwsys_stl::string::npos))
+    if ((cpuflags.find(" 3dnow ")!=std::string::npos))
       {
       this->Features.ExtendedFeatures.Has3DNow = true;
       }
@@ -3645,7 +3639,7 @@ SystemInformationImplementation::GetProcMemoryUsed()
 #elif defined(__APPLE__)
   SystemInformation::LongLong memUsed=0;
   pid_t pid=getpid();
-  kwsys_ios::ostringstream oss;
+  std::ostringstream oss;
   oss << "ps -o rss= -p " << pid;
   FILE *file=popen(oss.str().c_str(),"r");
   if (file==0)
@@ -3670,7 +3664,7 @@ SystemInformationImplementation::GetProcMemoryUsed()
     {
     return -2;
     }
-  kwsys_ios::istringstream iss(oss.str());
+  std::istringstream iss(oss.str());
   iss >> memUsed;
   return memUsed;
 #else
@@ -3729,11 +3723,11 @@ SystemInformationImplementation::GetProcessId()
 return current program stack in a string
 demangle cxx symbols if possible.
 */
-kwsys_stl::string SystemInformationImplementation::GetProgramStack(
+std::string SystemInformationImplementation::GetProgramStack(
       int firstFrame,
       int wholePath)
 {
-  kwsys_stl::string programStack = ""
+  std::string programStack = ""
 #if !defined(KWSYS_SYSTEMINFORMATION_HAS_BACKTRACE)
     "WARNING: The stack could not be examined "
     "because backtrace is not supported.\n"
@@ -3752,7 +3746,7 @@ kwsys_stl::string SystemInformationImplementation::GetProgramStack(
 #endif
     ;
 
-  kwsys_ios::ostringstream oss;
+  std::ostringstream oss;
 #if defined(KWSYS_SYSTEMINFORMATION_HAS_BACKTRACE)
   void *stackSymbols[256];
   int nFrames=backtrace(stackSymbols,256);
@@ -3761,7 +3755,7 @@ kwsys_stl::string SystemInformationImplementation::GetProgramStack(
     SymbolProperties symProps;
     symProps.SetReportPath(wholePath);
     symProps.Initialize(stackSymbols[i]);
-    oss << symProps << kwsys_ios::endl;
+    oss << symProps << std::endl;
     }
 #else
   (void)firstFrame;
@@ -3892,7 +3886,7 @@ bool SystemInformationImplementation::QueryLinuxMemory()
   int errorFlag = uname(&unameInfo);
   if( errorFlag!=0 )
     {
-    kwsys_ios::cout << "Problem calling uname(): " << strerror(errno) << kwsys_ios::endl;
+    std::cout << "Problem calling uname(): " << strerror(errno) << std::endl;
     return false;
     }
 
@@ -3916,7 +3910,7 @@ bool SystemInformationImplementation::QueryLinuxMemory()
   FILE *fd = fopen("/proc/meminfo", "r" );
   if ( !fd )
     {
-    kwsys_ios::cout << "Problem opening /proc/meminfo" << kwsys_ios::endl;
+    std::cout << "Problem opening /proc/meminfo" << std::endl;
     return false;
     }
 
@@ -3954,7 +3948,7 @@ bool SystemInformationImplementation::QueryLinuxMemory()
       }
     else
       {
-      kwsys_ios::cout << "Problem parsing /proc/meminfo" << kwsys_ios::endl;
+      std::cout << "Problem parsing /proc/meminfo" << std::endl;
       fclose(fd);
       return false;
       }
@@ -3987,7 +3981,7 @@ bool SystemInformationImplementation::QueryLinuxMemory()
       }
     else
       {
-      kwsys_ios::cout << "Problem parsing /proc/meminfo" << kwsys_ios::endl;
+      std::cout << "Problem parsing /proc/meminfo" << std::endl;
       fclose(fd);
       return false;
       }
@@ -4464,8 +4458,8 @@ bool SystemInformationImplementation::ParseSysCtl()
     ::memset(retBuf, 0, 128);
     len = 32;
     err = sysctlbyname("hw.machine", &retBuf, &len, NULL, 0);
-    kwsys_stl::string machineBuf(retBuf);
-    if (machineBuf.find_first_of("Power") != kwsys_stl::string::npos)
+    std::string machineBuf(retBuf);
+    if (machineBuf.find_first_of("Power") != std::string::npos)
       {
       this->ChipID.Vendor = "IBM";
       len = sizeof(this->ChipID.Family);
@@ -4527,41 +4521,41 @@ bool SystemInformationImplementation::ParseSysCtl()
       {
       // now we can match every flags as space + flag + space
       buf[len + 1] = ' ';
-      kwsys_stl::string cpuflags(buf, len + 2);
+      std::string cpuflags(buf, len + 2);
 
-      if ((cpuflags.find(" FPU ")!=kwsys_stl::string::npos))
+      if ((cpuflags.find(" FPU ")!=std::string::npos))
         {
         this->Features.HasFPU = true;
         }
-      if ((cpuflags.find(" TSC ")!=kwsys_stl::string::npos))
+      if ((cpuflags.find(" TSC ")!=std::string::npos))
         {
         this->Features.HasTSC = true;
         }
-      if ((cpuflags.find(" MMX ")!=kwsys_stl::string::npos))
+      if ((cpuflags.find(" MMX ")!=std::string::npos))
         {
         this->Features.HasMMX = true;
         }
-      if ((cpuflags.find(" SSE ")!=kwsys_stl::string::npos))
+      if ((cpuflags.find(" SSE ")!=std::string::npos))
         {
         this->Features.HasSSE = true;
         }
-      if ((cpuflags.find(" SSE2 ")!=kwsys_stl::string::npos))
+      if ((cpuflags.find(" SSE2 ")!=std::string::npos))
         {
         this->Features.HasSSE2 = true;
         }
-      if ((cpuflags.find(" APIC ")!=kwsys_stl::string::npos))
+      if ((cpuflags.find(" APIC ")!=std::string::npos))
         {
         this->Features.HasAPIC = true;
         }
-      if ((cpuflags.find(" CMOV ")!=kwsys_stl::string::npos))
+      if ((cpuflags.find(" CMOV ")!=std::string::npos))
         {
         this->Features.HasCMOV = true;
         }
-      if ((cpuflags.find(" MTRR ")!=kwsys_stl::string::npos))
+      if ((cpuflags.find(" MTRR ")!=std::string::npos))
         {
         this->Features.HasMTRR = true;
         }
-      if ((cpuflags.find(" ACPI ")!=kwsys_stl::string::npos))
+      if ((cpuflags.find(" ACPI ")!=std::string::npos))
         {
         this->Features.HasACPI = true;
         }
@@ -4595,7 +4589,7 @@ bool SystemInformationImplementation::ParseSysCtl()
 
 
 /** Extract a value from sysctl command */
-kwsys_stl::string SystemInformationImplementation::ExtractValueFromSysCtl(const char* word)
+std::string SystemInformationImplementation::ExtractValueFromSysCtl(const char* word)
 {
   size_t pos = this->SysCtlBuffer.find(word);
   if(pos != this->SysCtlBuffer.npos)
@@ -4612,9 +4606,9 @@ kwsys_stl::string SystemInformationImplementation::ExtractValueFromSysCtl(const
 
 
 /** Run a given process */
-kwsys_stl::string SystemInformationImplementation::RunProcess(kwsys_stl::vector<const char*> args)
+std::string SystemInformationImplementation::RunProcess(std::vector<const char*> args)
 {
-  kwsys_stl::string buffer = "";
+  std::string buffer = "";
 
   // Run the application
   kwsysProcess* gp = kwsysProcess_New();
@@ -4644,12 +4638,12 @@ kwsys_stl::string SystemInformationImplementation::RunProcess(kwsys_stl::vector<
       } break;
     case kwsysProcess_State_Error:
       {
-      kwsys_ios::cerr << "Error: Could not run " << args[0] << ":\n";
-      kwsys_ios::cerr << kwsysProcess_GetErrorString(gp) << "\n";
+      std::cerr << "Error: Could not run " << args[0] << ":\n";
+      std::cerr << kwsysProcess_GetErrorString(gp) << "\n";
       } break;
     case kwsysProcess_State_Exception:
       {
-      kwsys_ios::cerr << "Error: " << args[0]
+      std::cerr << "Error: " << args[0]
                 << " terminated with an exception: "
                 << kwsysProcess_GetExceptionString(gp) << "\n";
       } break;
@@ -4659,27 +4653,27 @@ kwsys_stl::string SystemInformationImplementation::RunProcess(kwsys_stl::vector<
     case kwsysProcess_State_Killed:
       {
       // Should not get here.
-      kwsys_ios::cerr << "Unexpected ending state after running " << args[0]
-                << kwsys_ios::endl;
+      std::cerr << "Unexpected ending state after running " << args[0]
+                << std::endl;
       } break;
     }
   kwsysProcess_Delete(gp);
   if(result)
     {
-    kwsys_ios::cerr << "Error " << args[0] << " returned :" << result << "\n";
+    std::cerr << "Error " << args[0] << " returned :" << result << "\n";
     }
   return buffer;
 }
 
 
-kwsys_stl::string SystemInformationImplementation::ParseValueFromKStat(const char* arguments)
+std::string SystemInformationImplementation::ParseValueFromKStat(const char* arguments)
 {
-  kwsys_stl::vector<const char*> args;
+  std::vector<const char*> args;
   args.clear();
   args.push_back("kstat");
   args.push_back("-p");
 
-  kwsys_stl::string command = arguments;
+  std::string command = arguments;
   size_t start = command.npos;
   size_t pos = command.find(' ',0);
   while(pos!=command.npos)
@@ -4701,7 +4695,7 @@ kwsys_stl::string SystemInformationImplementation::ParseValueFromKStat(const cha
 
     if(!inQuotes)
       {
-      kwsys_stl::string arg = command.substr(start+1,pos-start-1);
+      std::string arg = command.substr(start+1,pos-start-1);
 
       // Remove the quotes if any
       size_t quotes = arg.find('"');
@@ -4715,14 +4709,14 @@ kwsys_stl::string SystemInformationImplementation::ParseValueFromKStat(const cha
       }
     pos = command.find(' ',pos+1);
     }
-  kwsys_stl::string lastArg = command.substr(start+1,command.size()-start-1);
+  std::string lastArg = command.substr(start+1,command.size()-start-1);
   args.push_back(lastArg.c_str());
 
   args.push_back(0);
 
-  kwsys_stl::string buffer = this->RunProcess(args);
+  std::string buffer = this->RunProcess(args);
 
-  kwsys_stl::string value = "";
+  std::string value = "";
   for(size_t i=buffer.size()-1;i>0;i--)
     {
     if(buffer[i] == ' ' || buffer[i] == '\t')
@@ -4731,7 +4725,7 @@ kwsys_stl::string SystemInformationImplementation::ParseValueFromKStat(const cha
       }
     if(buffer[i] != '\n' && buffer[i] != '\r')
       {
-      kwsys_stl::string val = value;
+      std::string val = value;
       value = buffer[i];
       value += val;
       }
@@ -4885,8 +4879,8 @@ bool SystemInformationImplementation::QueryHaikuInfo()
 bool SystemInformationImplementation::QueryQNXMemory()
 {
 #if defined(__QNX__)
-  kwsys_stl::string buffer;
-  kwsys_stl::vector<const char*> args;
+  std::string buffer;
+  std::vector<const char*> args;
   args.clear();
 
   args.push_back("showmem");
@@ -4943,8 +4937,8 @@ bool SystemInformationImplementation::QueryQNXProcessor()
 #if defined(__QNX__)
   // the output on my QNX 6.4.1 looks like this:
   // Processor1: 686 Pentium II Stepping 3 2175MHz FPU
-  kwsys_stl::string buffer;
-  kwsys_stl::vector<const char*> args;
+  std::string buffer;
+  std::vector<const char*> args;
   args.clear();
 
   args.push_back("pidin");
@@ -5440,10 +5434,10 @@ bool SystemInformationImplementation::QueryOSInformation()
 
 int SystemInformationImplementation::CallSwVers(
       const char *arg,
-      kwsys_stl::string &ver)
+      std::string &ver)
 {
 #ifdef __APPLE__
-  kwsys_stl::vector<const char*> args;
+  std::vector<const char*> args;
   args.push_back("sw_vers");
   args.push_back(arg);
   args.push_back(0);
@@ -5457,18 +5451,18 @@ int SystemInformationImplementation::CallSwVers(
   return 0;
 }
 
-void SystemInformationImplementation::TrimNewline(kwsys_stl::string& output)
+void SystemInformationImplementation::TrimNewline(std::string& output)
 {
   // remove \r
-  kwsys_stl::string::size_type pos=0;
-  while((pos = output.find("\r", pos)) != kwsys_stl::string::npos)
+  std::string::size_type pos=0;
+  while((pos = output.find("\r", pos)) != std::string::npos)
     {
     output.erase(pos);
     }
 
   // remove \n
   pos = 0;
-  while((pos = output.find("\n", pos)) != kwsys_stl::string::npos)
+  while((pos = output.find("\n", pos)) != std::string::npos)
     {
     output.erase(pos);
     }

Source/kwsys/SystemInformation.hxx.in

@@ -12,14 +12,9 @@
 #ifndef @KWSYS_NAMESPACE@_SystemInformation_h
 #define @KWSYS_NAMESPACE@_SystemInformation_h
 
-
-/* Define these macros temporarily to keep the code readable.  */
-#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-# define kwsys_stl @KWSYS_NAMESPACE@_stl
-# define kwsys_ios @KWSYS_NAMESPACE@_ios
-#endif
-#include <@KWSYS_NAMESPACE@/stl/string>
+#include <@KWSYS_NAMESPACE@/Configure.hxx>
 #include <stddef.h> /* size_t */
+#include <string>
 
 namespace @KWSYS_NAMESPACE@
 {
@@ -45,11 +40,11 @@ public:
 
   const char * GetVendorString();
   const char * GetVendorID();
-  kwsys_stl::string GetTypeID();
-  kwsys_stl::string GetFamilyID();
-  kwsys_stl::string GetModelID();
-  kwsys_stl::string GetModelName();
-  kwsys_stl::string GetSteppingCode();
+  std::string GetTypeID();
+  std::string GetFamilyID();
+  std::string GetModelID();
+  std::string GetModelName();
+  std::string GetSteppingCode();
   const char * GetExtendedProcessorName();
   const char * GetProcessorSerialNumber();
   int GetProcessorCacheSize();
@@ -61,10 +56,10 @@ public:
 
   // returns an informative general description of the cpu
   // on this system.
-  kwsys_stl::string GetCPUDescription();
+  std::string GetCPUDescription();
 
   const char * GetHostname();
-  kwsys_stl::string GetFullyQualifiedDomainName();
+  std::string GetFullyQualifiedDomainName();
 
   const char * GetOSName();
   const char * GetOSRelease();
@@ -77,7 +72,7 @@ public:
 
   // returns an informative general description of the os
   // on this system.
-  kwsys_stl::string GetOSDescription();
+  std::string GetOSDescription();
 
   bool Is64Bits();
 
@@ -98,7 +93,7 @@ public:
   // returns an informative general description if the installed and
   // available ram on this system. See the  GetHostMmeoryTotal, and
   // Get{Host,Proc}MemoryAvailable methods for more information.
-  kwsys_stl::string GetMemoryDescription(
+  std::string GetMemoryDescription(
         const char *hostLimitEnvVarName=NULL,
         const char *procLimitEnvVarName=NULL);
 
@@ -144,7 +139,7 @@ public:
   // order to produce an informative stack trace the application
   // should be dynamically linked and compiled with debug symbols.
   static
-  kwsys_stl::string GetProgramStack(int firstFrame, int wholePath);
+  std::string GetProgramStack(int firstFrame, int wholePath);
 
   /** Run the different checks */
   void RunCPUCheck();
@@ -154,10 +149,4 @@ public:
 
 } // namespace @KWSYS_NAMESPACE@
 
-/* Undefine temporary macros.  */
-#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-# undef kwsys_stl
-# undef kwsys_ios
-#endif
-
 #endif

Source/kwsys/SystemTools.hxx.in

@@ -12,12 +12,13 @@
 #ifndef @KWSYS_NAMESPACE@_SystemTools_hxx
 #define @KWSYS_NAMESPACE@_SystemTools_hxx
 
-#include <@KWSYS_NAMESPACE@/ios/iosfwd>
-#include <@KWSYS_NAMESPACE@/stl/string>
-#include <@KWSYS_NAMESPACE@/stl/vector>
-#include <@KWSYS_NAMESPACE@/stl/map>
+#include <@KWSYS_NAMESPACE@/Configure.hxx>
+
+#include <iosfwd>
+#include <string>
+#include <vector>
+#include <map>
 
-#include <@KWSYS_NAMESPACE@/Configure.h>
 #include <@KWSYS_NAMESPACE@/String.hxx>
 
 #include <sys/types.h>
@@ -29,7 +30,7 @@
 #include <stdarg.h>
 // Required for FILE*
 #include <stdio.h>
-#if @KWSYS_NAMESPACE@_STL_HAVE_STD && !defined(va_list)
+#if !defined(va_list)
 // Some compilers move va_list into the std namespace and there is no way to
 // tell that this has been done. Playing with things being included before or
 // after stdarg.h does not solve things because we do not have control over
@@ -47,12 +48,6 @@ namespace @KWSYS_NAMESPACE@
 }
 #endif // va_list
 
-/* Define these macros temporarily to keep the code readable.  */
-#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-# define kwsys_stl @KWSYS_NAMESPACE@_stl
-# define kwsys_ios @KWSYS_NAMESPACE@_ios
-#endif
-
 namespace @KWSYS_NAMESPACE@
 {
 
@@ -112,9 +107,9 @@ public:
    * then an underscore is prepended.  Note that this can produce
    * identifiers that the standard reserves (_[A-Z].* and __.*).
    */
-  static kwsys_stl::string MakeCidentifier(const kwsys_stl::string& s);
+  static std::string MakeCidentifier(const std::string& s);
 
-  static kwsys_stl::string MakeCindentifier(const kwsys_stl::string& s)
+  static std::string MakeCindentifier(const std::string& s)
   {
     return MakeCidentifier(s);
   }
@@ -122,40 +117,40 @@ public:
   /**
    * Replace replace all occurences of the string in the source string.
    */
-  static void ReplaceString(kwsys_stl::string& source,
+  static void ReplaceString(std::string& source,
                             const char* replace,
                             const char* with);
-  static void ReplaceString(kwsys_stl::string& source,
-                            const kwsys_stl::string& replace,
-                            const kwsys_stl::string& with);
+  static void ReplaceString(std::string& source,
+                            const std::string& replace,
+                            const std::string& with);
 
   /**
    * Return a capitalized string (i.e the first letter is uppercased,
    * all other are lowercased).
    */
-  static kwsys_stl::string Capitalized(const kwsys_stl::string&);
+  static std::string Capitalized(const std::string&);
 
   /**
    * Return a 'capitalized words' string (i.e the first letter of each word
    * is uppercased all other are left untouched though).
    */
-  static kwsys_stl::string CapitalizedWords(const kwsys_stl::string&);
+  static std::string CapitalizedWords(const std::string&);
 
   /**
    * Return a 'uncapitalized words' string (i.e the first letter of each word
    * is lowercased all other are left untouched though).
    */
-  static kwsys_stl::string UnCapitalizedWords(const kwsys_stl::string&);
+  static std::string UnCapitalizedWords(const std::string&);
 
   /**
    * Return a lower case string
    */
-  static kwsys_stl::string LowerCase(const kwsys_stl::string&);
+  static std::string LowerCase(const std::string&);
 
   /**
    * Return a lower case string
    */
-  static kwsys_stl::string UpperCase(const kwsys_stl::string&);
+  static std::string UpperCase(const std::string&);
 
   /**
    * Count char in string
@@ -184,9 +179,9 @@ public:
    * Returns true if str1 starts (respectively ends) with str2
    */
   static bool StringStartsWith(const char* str1, const char* str2);
-  static bool StringStartsWith(const kwsys_stl::string& str1, const char* str2);
+  static bool StringStartsWith(const std::string& str1, const char* str2);
   static bool StringEndsWith(const char* str1, const char* str2);
-  static bool StringEndsWith(const kwsys_stl::string& str1, const char* str2);
+  static bool StringEndsWith(const std::string& str1, const char* str2);
 
   /**
    * Returns a pointer to the last occurence of str2 in str1
@@ -204,14 +199,14 @@ public:
    * Return the string cropped to a given length by removing chars in the
    * center of the string and replacing them with an ellipsis (...)
    */
-  static kwsys_stl::string CropString(const kwsys_stl::string&,size_t max_len);
+  static std::string CropString(const std::string&,size_t max_len);
 
   /** split a path by separator into an array of strings, default is /.
       If isPath is true then the string is treated like a path and if
       s starts with a / then the first element of the returned array will
       be /, so /foo/bar will be [/, foo, bar]
   */
-  static kwsys_stl::vector<String> SplitString(const kwsys_stl::string& s, char separator = '/',
+  static std::vector<String> SplitString(const std::string& s, char separator = '/',
                                                bool isPath = false);
   /**
    * Perform a case-independent string comparison
@@ -229,16 +224,16 @@ public:
    * Split a string on its newlines into multiple lines
    * Return false only if the last line stored had no newline
    */
-  static bool Split(const kwsys_stl::string& s, kwsys_stl::vector<kwsys_stl::string>& l);
-  static bool Split(const kwsys_stl::string& s, kwsys_stl::vector<kwsys_stl::string>& l, char separator);
+  static bool Split(const std::string& s, std::vector<std::string>& l);
+  static bool Split(const std::string& s, std::vector<std::string>& l, char separator);
 
   /**
    * Return string with space added between capitalized words
    * (i.e. EatMyShorts becomes Eat My Shorts )
    * (note that IEatShorts becomes IEat Shorts)
    */
-  static kwsys_stl::string AddSpaceBetweenCapitalizedWords(
-    const kwsys_stl::string&);
+  static std::string AddSpaceBetweenCapitalizedWords(
+    const std::string&);
 
   /**
    * Append two or more strings and produce new one.
@@ -265,7 +260,7 @@ public:
   /**
    * Escape specific characters in 'str'.
    */
-  static kwsys_stl::string EscapeChars(
+  static std::string EscapeChars(
     const char *str, const char *chars_to_escape, char escape_char = '\\');
 
   /** -----------------------------------------------------------------
@@ -276,7 +271,7 @@ public:
   /**
    * Replace Windows file system slashes with Unix-style slashes.
    */
-  static void ConvertToUnixSlashes(kwsys_stl::string& path);
+  static void ConvertToUnixSlashes(std::string& path);
 
 #ifdef _WIN32
   /**
@@ -286,20 +281,20 @@ public:
    * will be prefixed with \\?\UNC\. All output will also be converted to
    * absolute paths with Windows-style backslashes.
    **/
-  static kwsys_stl::wstring ConvertToWindowsExtendedPath(const kwsys_stl::string&);
+  static std::wstring ConvertToWindowsExtendedPath(const std::string&);
 #endif
 
   /**
    * For windows this calls ConvertToWindowsOutputPath and for unix
    * it calls ConvertToUnixOutputPath
    */
-  static kwsys_stl::string ConvertToOutputPath(const kwsys_stl::string&);
+  static std::string ConvertToOutputPath(const std::string&);
 
   /**
    * Convert the path to a string that can be used in a unix makefile.
    * double slashes are removed, and spaces are escaped.
    */
-  static kwsys_stl::string ConvertToUnixOutputPath(const kwsys_stl::string&);
+  static std::string ConvertToUnixOutputPath(const std::string&);
 
   /**
    * Convert the path to string that can be used in a windows project or
@@ -307,7 +302,7 @@ public:
    * the string, the slashes are converted to windows style backslashes, and
    * if there are spaces in the string it is double quoted.
    */
-  static kwsys_stl::string ConvertToWindowsOutputPath(const kwsys_stl::string&);
+  static std::string ConvertToWindowsOutputPath(const std::string&);
 
   /**
    * Return true if a file exists in the current directory.
@@ -318,9 +313,9 @@ public:
    * for read access is only done on POSIX systems.)
    */
   static bool FileExists(const char* filename, bool isFile);
-  static bool FileExists(const kwsys_stl::string& filename, bool isFile);
+  static bool FileExists(const std::string& filename, bool isFile);
   static bool FileExists(const char* filename);
-  static bool FileExists(const kwsys_stl::string& filename);
+  static bool FileExists(const std::string& filename);
 
   /**
    * Test if a file exists and can be accessed with the requested
@@ -334,7 +329,7 @@ public:
    */
   static bool TestFileAccess(const char* filename,
                              TestFilePermissions permissions);
-  static bool TestFileAccess(const kwsys_stl::string& filename,
+  static bool TestFileAccess(const std::string& filename,
                              TestFilePermissions permissions);
 
   /**
@@ -349,12 +344,12 @@ public:
   /**
    * Return file length
    */
-  static unsigned long FileLength(const kwsys_stl::string& filename);
+  static unsigned long FileLength(const std::string& filename);
 
   /**
      Change the modification time or create a file
   */
-  static bool Touch(const kwsys_stl::string& filename, bool create);
+  static bool Touch(const std::string& filename, bool create);
 
   /**
    *  Compare file modification times.
@@ -362,8 +357,8 @@ public:
    *  When true is returned, result has -1, 0, +1 for
    *  f1 older, same, or newer than f2.
    */
-  static bool FileTimeCompare(const kwsys_stl::string& f1,
-                              const kwsys_stl::string& f2,
+  static bool FileTimeCompare(const std::string& f1,
+                              const std::string& f2,
                               int* result);
 
   /**
@@ -378,17 +373,17 @@ public:
    *  does not exist path is returned unchanged.  This does nothing
    *  on unix but return path.
    */
-  static kwsys_stl::string GetActualCaseForPath(const kwsys_stl::string& path);
+  static std::string GetActualCaseForPath(const std::string& path);
 
   /**
    * Given the path to a program executable, get the directory part of
    * the path with the file stripped off.  If there is no directory
    * part, the empty string is returned.
    */
-  static kwsys_stl::string GetProgramPath(const kwsys_stl::string&);
-  static bool SplitProgramPath(const kwsys_stl::string& in_name,
-                               kwsys_stl::string& dir,
-                               kwsys_stl::string& file,
+  static std::string GetProgramPath(const std::string&);
+  static bool SplitProgramPath(const std::string& in_name,
+                               std::string& dir,
+                               std::string& file,
                                bool errorReport = true);
 
   /**
@@ -404,8 +399,8 @@ public:
    *  installPrefix is a possibly null pointer to the install directory.
    */
   static bool FindProgramPath(const char* argv0,
-                              kwsys_stl::string& pathOut,
-                              kwsys_stl::string& errorMsg,
+                              std::string& pathOut,
+                              std::string& errorMsg,
                               const char* exeName = 0,
                               const char* buildDir = 0,
                               const char* installPrefix = 0);
@@ -416,11 +411,11 @@ public:
    * (which defaults to the current working directory).  The full path
    * is returned.
    */
-  static kwsys_stl::string CollapseFullPath(const kwsys_stl::string& in_relative);
-  static kwsys_stl::string CollapseFullPath(const kwsys_stl::string& in_relative,
+  static std::string CollapseFullPath(const std::string& in_relative);
+  static std::string CollapseFullPath(const std::string& in_relative,
                                             const char* in_base);
-  static kwsys_stl::string CollapseFullPath(const kwsys_stl::string& in_relative,
-                                            const kwsys_stl::string& in_base);
+  static std::string CollapseFullPath(const std::string& in_relative,
+                                            const std::string& in_base);
 
   /**
    * Get the real path for a given path, removing all symlinks.  In
@@ -429,8 +424,8 @@ public:
    * NULL.  Otherwise empty string is returned and errorMessage
    * contains error description.
    */
-  static kwsys_stl::string GetRealPath(const kwsys_stl::string& path,
-                                       kwsys_stl::string* errorMessage = 0);
+  static std::string GetRealPath(const std::string& path,
+                                       std::string* errorMessage = 0);
 
   /**
    * Split a path name into its root component and the rest of the
@@ -448,7 +443,7 @@ public:
    * given.
    */
   static const char* SplitPathRootComponent(const std::string& p,
-                                            kwsys_stl::string* root=0);
+                                            std::string* root=0);
 
   /**
    * Split a path name into its basic components.  The first component
@@ -461,76 +456,76 @@ public:
    * platform supports them.
    */
   static void SplitPath(const std::string& p,
-                        kwsys_stl::vector<kwsys_stl::string>& components,
+                        std::vector<std::string>& components,
                         bool expand_home_dir = true);
 
   /**
    * Join components of a path name into a single string.  See
    * SplitPath for the format of the components.
    */
-  static kwsys_stl::string JoinPath(
-    const kwsys_stl::vector<kwsys_stl::string>& components);
-  static kwsys_stl::string JoinPath(
-    kwsys_stl::vector<kwsys_stl::string>::const_iterator first,
-    kwsys_stl::vector<kwsys_stl::string>::const_iterator last);
+  static std::string JoinPath(
+    const std::vector<std::string>& components);
+  static std::string JoinPath(
+    std::vector<std::string>::const_iterator first,
+    std::vector<std::string>::const_iterator last);
 
   /**
    * Compare a path or components of a path.
    */
-  static bool ComparePath(const kwsys_stl::string& c1, const kwsys_stl::string& c2);
+  static bool ComparePath(const std::string& c1, const std::string& c2);
 
 
   /**
    * Return path of a full filename (no trailing slashes)
    */
-  static kwsys_stl::string GetFilenamePath(const kwsys_stl::string&);
+  static std::string GetFilenamePath(const std::string&);
 
   /**
    * Return file name of a full filename (i.e. file name without path)
    */
-  static kwsys_stl::string GetFilenameName(const kwsys_stl::string&);
+  static std::string GetFilenameName(const std::string&);
 
   /**
    * Split a program from its arguments and handle spaces in the paths
    */
   static void SplitProgramFromArgs(
-    const kwsys_stl::string& path,
-    kwsys_stl::string& program, kwsys_stl::string& args);
+    const std::string& path,
+    std::string& program, std::string& args);
 
   /**
    * Return longest file extension of a full filename (dot included)
    */
-  static kwsys_stl::string GetFilenameExtension(const kwsys_stl::string&);
+  static std::string GetFilenameExtension(const std::string&);
 
   /**
    * Return shortest file extension of a full filename (dot included)
    */
-  static kwsys_stl::string GetFilenameLastExtension(
-    const kwsys_stl::string& filename);
+  static std::string GetFilenameLastExtension(
+    const std::string& filename);
 
   /**
    * Return file name without extension of a full filename
    */
-  static kwsys_stl::string GetFilenameWithoutExtension(
-    const kwsys_stl::string&);
+  static std::string GetFilenameWithoutExtension(
+    const std::string&);
 
   /**
    * Return file name without its last (shortest) extension
    */
-  static kwsys_stl::string GetFilenameWithoutLastExtension(
-    const kwsys_stl::string&);
+  static std::string GetFilenameWithoutLastExtension(
+    const std::string&);
 
   /**
    * Return whether the path represents a full path (not relative)
    */
-  static bool FileIsFullPath(const kwsys_stl::string&);
+  static bool FileIsFullPath(const std::string&);
   static bool FileIsFullPath(const char*);
 
   /**
    * For windows return the short path for the given path,
    * Unix just a pass through
    */
-  static bool GetShortPath(const kwsys_stl::string& path, kwsys_stl::string& result);
+  static bool GetShortPath(const std::string& path, std::string& result);
 
   /**
    * Read line from file. Make sure to get everything. Due to a buggy stream
@@ -539,20 +534,20 @@ public:
    * end-of-file was reached. If the has_newline argument is specified, it will
    * be true when the line read had a newline character.
    */
-  static bool GetLineFromStream(kwsys_ios::istream& istr,
-                                kwsys_stl::string& line,
+  static bool GetLineFromStream(std::istream& istr,
+                                std::string& line,
                                 bool* has_newline=0,
                                 long sizeLimit=-1);
 
   /**
    * Get the parent directory of the directory or file
    */
-  static kwsys_stl::string GetParentDirectory(const kwsys_stl::string& fileOrDir);
+  static std::string GetParentDirectory(const std::string& fileOrDir);
 
   /**
    * Check if the given file or directory is in subdirectory of dir
    */
-  static bool IsSubDirectory(const kwsys_stl::string& fileOrDir, const kwsys_stl::string& dir);
+  static bool IsSubDirectory(const std::string& fileOrDir, const std::string& dir);
 
   /** -----------------------------------------------------------------
    *               File Manipulation Routines
@@ -562,7 +557,7 @@ public:
   /**
    * Open a file considering unicode.
    */
-  static FILE* Fopen(const kwsys_stl::string& file, const char* mode);
+  static FILE* Fopen(const std::string& file, const char* mode);
 
   /**
    * Make a new directory if it is not there.  This function
@@ -570,36 +565,36 @@ public:
    * prior to calling this function.
    */
   static bool MakeDirectory(const char* path);
-  static bool MakeDirectory(const kwsys_stl::string& path);
+  static bool MakeDirectory(const std::string& path);
 
   /**
    * Copy the source file to the destination file only
    * if the two files differ.
    */
-  static bool CopyFileIfDifferent(const kwsys_stl::string& source,
-                                  const kwsys_stl::string& destination);
+  static bool CopyFileIfDifferent(const std::string& source,
+                                  const std::string& destination);
 
   /**
    * Compare the contents of two files.  Return true if different
    */
-  static bool FilesDiffer(const kwsys_stl::string& source, const kwsys_stl::string& destination);
+  static bool FilesDiffer(const std::string& source, const std::string& destination);
 
   /**
    * Return true if the two files are the same file
    */
-  static bool SameFile(const kwsys_stl::string& file1, const kwsys_stl::string& file2);
+  static bool SameFile(const std::string& file1, const std::string& file2);
 
   /**
    * Copy a file.
    */
-  static bool CopyFileAlways(const kwsys_stl::string& source, const kwsys_stl::string& destination);
+  static bool CopyFileAlways(const std::string& source, const std::string& destination);
 
   /**
    * Copy a file.  If the "always" argument is true the file is always
    * copied.  If it is false, the file is copied only if it is new or
    * has changed.
    */
-  static bool CopyAFile(const kwsys_stl::string& source, const kwsys_stl::string& destination,
+  static bool CopyAFile(const std::string& source, const std::string& destination,
                         bool always = true);
 
   /**
@@ -608,18 +603,18 @@ public:
    * always copied.  If it is false, only files that have changed or
    * are new are copied.
    */
-  static bool CopyADirectory(const kwsys_stl::string& source, const kwsys_stl::string& destination,
+  static bool CopyADirectory(const std::string& source, const std::string& destination,
                              bool always = true);
 
   /**
    * Remove a file
    */
-  static bool RemoveFile(const kwsys_stl::string& source);
+  static bool RemoveFile(const std::string& source);
 
   /**
    * Remove a directory
    */
-  static bool RemoveADirectory(const kwsys_stl::string& source);
+  static bool RemoveADirectory(const std::string& source);
 
   /**
    * Get the maximum full file path length
@@ -629,56 +624,56 @@ public:
   /**
    * Find a file in the system PATH, with optional extra paths
    */
-  static kwsys_stl::string FindFile(
-    const kwsys_stl::string& name,
-    const kwsys_stl::vector<kwsys_stl::string>& path =
-    kwsys_stl::vector<kwsys_stl::string>(),
+  static std::string FindFile(
+    const std::string& name,
+    const std::vector<std::string>& path =
+    std::vector<std::string>(),
     bool no_system_path = false);
 
   /**
    * Find a directory in the system PATH, with optional extra paths
    */
-  static kwsys_stl::string FindDirectory(
-    const kwsys_stl::string& name,
-    const kwsys_stl::vector<kwsys_stl::string>& path =
-    kwsys_stl::vector<kwsys_stl::string>(),
+  static std::string FindDirectory(
+    const std::string& name,
+    const std::vector<std::string>& path =
+    std::vector<std::string>(),
     bool no_system_path = false);
 
   /**
    * Find an executable in the system PATH, with optional extra paths
    */
-  static kwsys_stl::string FindProgram(
+  static std::string FindProgram(
     const char* name,
-    const kwsys_stl::vector<kwsys_stl::string>& path =
-    kwsys_stl::vector<kwsys_stl::string>(),
+    const std::vector<std::string>& path =
+    std::vector<std::string>(),
     bool no_system_path = false);
-  static kwsys_stl::string FindProgram(
-    const kwsys_stl::string& name,
-    const kwsys_stl::vector<kwsys_stl::string>& path =
-    kwsys_stl::vector<kwsys_stl::string>(),
+  static std::string FindProgram(
+    const std::string& name,
+    const std::vector<std::string>& path =
+    std::vector<std::string>(),
     bool no_system_path = false);
-  static kwsys_stl::string FindProgram(
-    const kwsys_stl::vector<kwsys_stl::string>& names,
-    const kwsys_stl::vector<kwsys_stl::string>& path =
-    kwsys_stl::vector<kwsys_stl::string>(),
+  static std::string FindProgram(
+    const std::vector<std::string>& names,
+    const std::vector<std::string>& path =
+    std::vector<std::string>(),
     bool no_system_path = false);
 
   /**
    * Find a library in the system PATH, with optional extra paths
    */
-  static kwsys_stl::string FindLibrary(
-    const kwsys_stl::string& name,
-    const kwsys_stl::vector<kwsys_stl::string>& path);
+  static std::string FindLibrary(
+    const std::string& name,
+    const std::vector<std::string>& path);
 
   /**
    * Return true if the file is a directory
    */
-  static bool FileIsDirectory(const kwsys_stl::string& name);
+  static bool FileIsDirectory(const std::string& name);
 
   /**
    * Return true if the file is a symlink
    */
-  static bool FileIsSymlink(const kwsys_stl::string& name);
+  static bool FileIsSymlink(const std::string& name);
 
   /**
    * Return true if the file has a given signature (first set of bytes)
@@ -710,13 +705,13 @@ public:
    * Create a symbolic link if the platform supports it.  Returns whether
    * creation succeded.
    */
-  static bool CreateSymlink(const kwsys_stl::string& origName, const kwsys_stl::string& newName);
+  static bool CreateSymlink(const std::string& origName, const std::string& newName);
 
   /**
    * Read the contents of a symbolic link.  Returns whether reading
    * succeded.
    */
-  static bool ReadSymlink(const kwsys_stl::string& newName, kwsys_stl::string& origName);
+  static bool ReadSymlink(const std::string& newName, std::string& origName);
 
   /**
    * Try to locate the file 'filename' in the directory 'dir'.
@@ -735,7 +730,7 @@ public:
    */
   static bool LocateFileInDir(const char *filename,
                               const char *dir,
-                              kwsys_stl::string& filename_found,
+                              std::string& filename_found,
                               int try_filename_dirs = 0);
 
   /** compute the relative path from local to remote.  local must
@@ -746,17 +741,17 @@ public:
       /a/b/c/d to /a/b/c1/d1 -> ../../c1/d1
       from /usr/src to /usr/src/test/blah/foo.cpp -> test/blah/foo.cpp
   */
-  static kwsys_stl::string RelativePath(const kwsys_stl::string& local, const kwsys_stl::string& remote);
+  static std::string RelativePath(const std::string& local, const std::string& remote);
 
   /**
    * Return file's modified time
    */
-  static long int ModifiedTime(const kwsys_stl::string& filename);
+  static long int ModifiedTime(const std::string& filename);
 
   /**
    * Return file's creation time (Win32: works only for NTFS, not FAT)
    */
-  static long int CreationTime(const kwsys_stl::string& filename);
+  static long int CreationTime(const std::string& filename);
 
   /**
    * Visual C++ does not define mode_t (note that Borland does, however).
@@ -774,11 +769,9 @@ public:
    * if a honor_umask parameter is set to true.
    */
   static bool GetPermissions(const char* file, mode_t& mode);
-  static bool GetPermissions(const kwsys_stl::string& file, mode_t& mode);
-  static bool SetPermissions(
-    const char* file, mode_t mode, bool honor_umask = false);
-  static bool SetPermissions(
-    const kwsys_stl::string& file, mode_t mode, bool honor_umask = false);
+  static bool GetPermissions(const std::string& file, mode_t& mode);
+  static bool SetPermissions(const char* file, mode_t mode, bool honor_umask = false);
+  static bool SetPermissions(const std::string& file, mode_t mode, bool honor_umask = false);
 
   /** -----------------------------------------------------------------
    *               Time Manipulation Routines
@@ -791,7 +784,7 @@ public:
   /**
    * Get current date/time
    */
-  static kwsys_stl::string GetCurrentDateTime(const char* format);
+  static std::string GetCurrentDateTime(const char* format);
 
   /** -----------------------------------------------------------------
    *               Registry Manipulation Routines
@@ -808,26 +801,26 @@ public:
   /**
    * Get a list of subkeys.
    */
-  static bool GetRegistrySubKeys(const kwsys_stl::string& key,
-                                 kwsys_stl::vector<kwsys_stl::string>& subkeys,
+  static bool GetRegistrySubKeys(const std::string& key,
+                                 std::vector<std::string>& subkeys,
                                  KeyWOW64 view = KeyWOW64_Default);
 
   /**
    * Read a registry value
    */
-  static bool ReadRegistryValue(const kwsys_stl::string& key, kwsys_stl::string &value,
+  static bool ReadRegistryValue(const std::string& key, std::string &value,
                                 KeyWOW64 view = KeyWOW64_Default);
 
   /**
    * Write a registry value
    */
-  static bool WriteRegistryValue(const kwsys_stl::string& key, const kwsys_stl::string& value,
+  static bool WriteRegistryValue(const std::string& key, const std::string& value,
                                  KeyWOW64 view = KeyWOW64_Default);
 
   /**
    * Delete a registry value
    */
-  static bool DeleteRegistryValue(const kwsys_stl::string& key,
+  static bool DeleteRegistryValue(const std::string& key,
                                   KeyWOW64 view = KeyWOW64_Default);
 
   /** -----------------------------------------------------------------
@@ -840,39 +833,39 @@ public:
    *  string vector passed in.  If env is set then the value
    *  of env will be used instead of PATH.
    */
-  static void GetPath(kwsys_stl::vector<kwsys_stl::string>& path,
+  static void GetPath(std::vector<std::string>& path,
                       const char* env=0);
 
   /**
    * Read an environment variable
    */
   static const char* GetEnv(const char* key);
-  static const char* GetEnv(const kwsys_stl::string& key);
-  static bool GetEnv(const char* key, kwsys_stl::string& result);
-  static bool GetEnv(const kwsys_stl::string& key, kwsys_stl::string& result);
+  static const char* GetEnv(const std::string& key);
+  static bool GetEnv(const char* key, std::string& result);
+  static bool GetEnv(const std::string& key, std::string& result);
 
   /** Put a string into the environment
       of the form var=value */
-  static bool PutEnv(const kwsys_stl::string& env);
+  static bool PutEnv(const std::string& env);
 
   /** Remove a string from the environment.
       Input is of the form "var" or "var=value" (value is ignored). */
-  static bool UnPutEnv(const kwsys_stl::string& env);
+  static bool UnPutEnv(const std::string& env);
 
   /**
    * Get current working directory CWD
    */
-  static kwsys_stl::string GetCurrentWorkingDirectory(bool collapse =true);
+  static std::string GetCurrentWorkingDirectory(bool collapse =true);
 
   /**
    * Change directory to the directory specified
    */
-  static int ChangeDirectory(const kwsys_stl::string& dir);
+  static int ChangeDirectory(const std::string& dir);
 
   /**
    * Get the result of strerror(errno)
    */
-  static kwsys_stl::string GetLastSystemError();
+  static std::string GetLastSystemError();
 
   /**
    * When building DEBUG with MSVC, this enables a hook that prevents
@@ -891,18 +884,18 @@ public:
   /**
    * Add an entry in the path translation table.
    */
-  static void AddTranslationPath(const kwsys_stl::string& dir, const kwsys_stl::string& refdir);
+  static void AddTranslationPath(const std::string& dir, const std::string& refdir);
 
   /**
    * If dir is different after CollapseFullPath is called,
    * Then insert it into the path translation table
    */
-  static void AddKeepPath(const kwsys_stl::string& dir);
+  static void AddKeepPath(const std::string& dir);
 
   /**
    * Update path by going through the Path Translation table;
    */
-  static void CheckTranslationPath(kwsys_stl::string & path);
+  static void CheckTranslationPath(std::string & path);
 
   /**
    * Delay the execution for a specified amount of time specified
@@ -914,7 +907,7 @@ public:
    * Get the operating system name and version
    * This is implemented for Win32 only for the moment
    */
-  static kwsys_stl::string GetOperatingSystemNameAndVersion();
+  static std::string GetOperatingSystemNameAndVersion();
 
   /** -----------------------------------------------------------------
    *               URL Manipulation Routines
@@ -927,9 +920,9 @@ public:
    * and fill protocol as appropriate.
    * Return false if the URL does not have the required form, true otherwise.
    */
-   static bool ParseURLProtocol( const kwsys_stl::string& URL,
-                                 kwsys_stl::string& protocol,
-                                 kwsys_stl::string& dataglom );
+   static bool ParseURLProtocol( const std::string& URL,
+                                 std::string& protocol,
+                                 std::string& dataglom );
 
   /**
    * Parse a string (a URL without protocol prefix) with the form:
@@ -938,13 +931,13 @@ public:
    * when values are found.
    * Return true if the string matches the format; false otherwise.
    */
-  static bool ParseURL( const kwsys_stl::string& URL,
-                        kwsys_stl::string& protocol,
-                        kwsys_stl::string& username,
-                        kwsys_stl::string& password,
-                        kwsys_stl::string& hostname,
-                        kwsys_stl::string& dataport,
-                        kwsys_stl::string& datapath );
+  static bool ParseURL( const std::string& URL,
+                        std::string& protocol,
+                        std::string& username,
+                        std::string& password,
+                        std::string& hostname,
+                        std::string& dataport,
+                        std::string& datapath );
 
 private:
   /**
@@ -968,10 +961,10 @@ private:
   /**
    * Actual implementation of ReplaceString.
    */
-  static void ReplaceString(kwsys_stl::string& source,
+  static void ReplaceString(std::string& source,
                             const char* replace,
                             size_t replaceSize,
-                            const kwsys_stl::string& with);
+                            const std::string& with);
 
   /**
    * Actual implementation of FileIsFullPath.
@@ -982,10 +975,10 @@ private:
    * Find a filename (file or directory) in the system PATH, with
    * optional extra paths.
    */
-  static kwsys_stl::string FindName(
-    const kwsys_stl::string& name,
-    const kwsys_stl::vector<kwsys_stl::string>& path =
-    kwsys_stl::vector<kwsys_stl::string>(),
+  static std::string FindName(
+    const std::string& name,
+    const std::vector<std::string>& path =
+    std::vector<std::string>(),
     bool no_system_path = false);
 
 
@@ -1005,10 +998,4 @@ private:
 
 } // namespace @KWSYS_NAMESPACE@
 
-/* Undefine temporary macros.  */
-#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-# undef kwsys_stl
-# undef kwsys_ios
-#endif
-
 #endif

Source/kwsys/hash_fun.hxx.in

@@ -38,8 +38,8 @@
 #define @KWSYS_NAMESPACE@_hash_fun_hxx
 
 #include <@KWSYS_NAMESPACE@/Configure.hxx>
-#include <@KWSYS_NAMESPACE@/cstddef>        // size_t
-#include <@KWSYS_NAMESPACE@/stl/string>     // string
+#include <stddef.h>        // size_t
+#include <string>
 
 namespace @KWSYS_NAMESPACE@
 {
@@ -55,90 +55,90 @@ inline size_t _stl_hash_string(const char* __s)
   return size_t(__h);
 }
 
-@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION
+template <>
 struct hash<char*> {
   size_t operator()(const char* __s) const { return _stl_hash_string(__s); }
 };
 
-@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION
+template <>
 struct hash<const char*> {
   size_t operator()(const char* __s) const { return _stl_hash_string(__s); }
 };
 
-@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION
-  struct hash<@KWSYS_NAMESPACE@_stl::string> {
-  size_t operator()(const @KWSYS_NAMESPACE@_stl::string & __s) const { return _stl_hash_string(__s.c_str()); }
+template <>
+  struct hash<std::string> {
+  size_t operator()(const std::string & __s) const { return _stl_hash_string(__s.c_str()); }
 };
 
 #if !defined(__BORLANDC__)
-@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION
-  struct hash<const @KWSYS_NAMESPACE@_stl::string> {
-  size_t operator()(const @KWSYS_NAMESPACE@_stl::string & __s) const { return _stl_hash_string(__s.c_str()); }
+template <>
+  struct hash<const std::string> {
+  size_t operator()(const std::string & __s) const { return _stl_hash_string(__s.c_str()); }
 };
 #endif
 
-@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION
+template <>
 struct hash<char> {
   size_t operator()(char __x) const { return __x; }
 };
 
-@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION
+template <>
 struct hash<unsigned char> {
   size_t operator()(unsigned char __x) const { return __x; }
 };
 
-@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION
+template <>
 struct hash<signed char> {
   size_t operator()(unsigned char __x) const { return __x; }
 };
 
-@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION
+template <>
 struct hash<short> {
   size_t operator()(short __x) const { return __x; }
 };
 
-@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION
+template <>
 struct hash<unsigned short> {
   size_t operator()(unsigned short __x) const { return __x; }
 };
 
-@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION
+template <>
 struct hash<int> {
   size_t operator()(int __x) const { return __x; }
 };
 
-@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION
+template <>
 struct hash<unsigned int> {
   size_t operator()(unsigned int __x) const { return __x; }
 };
 
-@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION
+template <>
 struct hash<long> {
   size_t operator()(long __x) const { return __x; }
 };
 
-@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION
+template <>
 struct hash<unsigned long> {
   size_t operator()(unsigned long __x) const { return __x; }
 };
 
 // use long long or __int64
 #if @KWSYS_USE_LONG_LONG@
-@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION
+template <>
 struct hash<long long> {
   size_t operator()(long long __x) const { return __x; }
 };
 
-@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION
+template <>
 struct hash<unsigned long long> {
   size_t operator()(unsigned long long __x) const { return __x; }
 };
 #elif @KWSYS_USE___INT64@
-@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION
+template <>
 struct hash<__int64> {
   size_t operator()(__int64 __x) const { return __x; }
 };
-@KWSYS_NAMESPACE@_CXX_DEFINE_SPECIALIZATION
+template <>
 struct hash<unsigned __int64> {
   size_t operator()(unsigned __int64 __x) const { return __x; }
 };

Source/kwsys/hash_map.hxx.in

@@ -39,7 +39,7 @@
 
 #include <@KWSYS_NAMESPACE@/hashtable.hxx>
 #include <@KWSYS_NAMESPACE@/hash_fun.hxx>
-#include <@KWSYS_NAMESPACE@/stl/functional> // equal_to
+#include <functional> // equal_to
 
 #if defined(_MSC_VER)
 # pragma warning (push)
@@ -58,9 +58,9 @@ namespace @KWSYS_NAMESPACE@
 // select1st is an extension: it is not part of the standard.
 template <class T1, class T2>
 struct hash_select1st:
-    public @KWSYS_NAMESPACE@_stl::unary_function<@KWSYS_NAMESPACE@_stl::pair<T1, T2>, T1>
+    public std::unary_function<std::pair<T1, T2>, T1>
 {
-  const T1& operator()(const @KWSYS_NAMESPACE@_stl::pair<T1, T2>& __x) const
+  const T1& operator()(const std::pair<T1, T2>& __x) const
     { return __x.first; }
 };
 
@@ -68,8 +68,8 @@ struct hash_select1st:
 
 template <class _Key, class _Tp,
           class _HashFcn  = hash<_Key>,
-          class _EqualKey = @KWSYS_NAMESPACE@_stl::equal_to<_Key>,
-          class _Alloc = @KWSYS_NAMESPACE@_HASH_DEFAULT_ALLOCATOR(char) >
+          class _EqualKey = std::equal_to<_Key>,
+          class _Alloc = std::allocator<char> >
 class hash_map;
 
 template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
@@ -81,7 +81,7 @@ template <class _Key, class _Tp, class _HashFcn, class _EqualKey,
 class hash_map
 {
 private:
-  typedef hashtable<@KWSYS_NAMESPACE@_stl::pair<const _Key,_Tp>,_Key,_HashFcn,
+  typedef hashtable<std::pair<const _Key,_Tp>,_Key,_HashFcn,
                     hash_select1st<const _Key,_Tp>,_EqualKey,_Alloc> _Ht;
   _Ht _M_ht;
 
@@ -119,7 +119,6 @@ public:
            const allocator_type& __a = allocator_type())
     : _M_ht(__n, __hf, __eql, __a) {}
 
-#if @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES
   template <class _InputIterator>
   hash_map(_InputIterator __f, _InputIterator __l)
     : _M_ht(100, hasher(), key_equal(), allocator_type())
@@ -140,48 +139,14 @@ public:
     : _M_ht(__n, __hf, __eql, __a)
     { _M_ht.insert_unique(__f, __l); }
 
-#else
-  hash_map(const value_type* __f, const value_type* __l)
-    : _M_ht(100, hasher(), key_equal(), allocator_type())
-    { _M_ht.insert_unique(__f, __l); }
-  hash_map(const value_type* __f, const value_type* __l, size_type __n)
-    : _M_ht(__n, hasher(), key_equal(), allocator_type())
-    { _M_ht.insert_unique(__f, __l); }
-  hash_map(const value_type* __f, const value_type* __l, size_type __n,
-           const hasher& __hf)
-    : _M_ht(__n, __hf, key_equal(), allocator_type())
-    { _M_ht.insert_unique(__f, __l); }
-  hash_map(const value_type* __f, const value_type* __l, size_type __n,
-           const hasher& __hf, const key_equal& __eql,
-           const allocator_type& __a = allocator_type())
-    : _M_ht(__n, __hf, __eql, __a)
-    { _M_ht.insert_unique(__f, __l); }
-
-  hash_map(const_iterator __f, const_iterator __l)
-    : _M_ht(100, hasher(), key_equal(), allocator_type())
-    { _M_ht.insert_unique(__f, __l); }
-  hash_map(const_iterator __f, const_iterator __l, size_type __n)
-    : _M_ht(__n, hasher(), key_equal(), allocator_type())
-    { _M_ht.insert_unique(__f, __l); }
-  hash_map(const_iterator __f, const_iterator __l, size_type __n,
-           const hasher& __hf)
-    : _M_ht(__n, __hf, key_equal(), allocator_type())
-    { _M_ht.insert_unique(__f, __l); }
-  hash_map(const_iterator __f, const_iterator __l, size_type __n,
-           const hasher& __hf, const key_equal& __eql,
-           const allocator_type& __a = allocator_type())
-    : _M_ht(__n, __hf, __eql, __a)
-    { _M_ht.insert_unique(__f, __l); }
-#endif
-
 public:
   size_type size() const { return _M_ht.size(); }
   size_type max_size() const { return _M_ht.max_size(); }
   bool empty() const { return _M_ht.empty(); }
   void swap(hash_map& __hs) { _M_ht.swap(__hs._M_ht); }
 
-  friend bool operator==@KWSYS_NAMESPACE@_CXX_NULL_TEMPLATE_ARGS(const hash_map&,
-                                                                 const hash_map&);
+  friend bool operator==<>(const hash_map&,
+                           const hash_map&);
 
   iterator begin() { return _M_ht.begin(); }
   iterator end() { return _M_ht.end(); }
@@ -189,20 +154,12 @@ public:
   const_iterator end() const { return _M_ht.end(); }
 
 public:
-  @KWSYS_NAMESPACE@_stl::pair<iterator,bool> insert(const value_type& __obj)
+  std::pair<iterator,bool> insert(const value_type& __obj)
     { return _M_ht.insert_unique(__obj); }
-#if @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES
   template <class _InputIterator>
   void insert(_InputIterator __f, _InputIterator __l)
     { _M_ht.insert_unique(__f,__l); }
-#else
-  void insert(const value_type* __f, const value_type* __l) {
-    _M_ht.insert_unique(__f,__l);
-  }
-  void insert(const_iterator __f, const_iterator __l)
-    { _M_ht.insert_unique(__f, __l); }
-#endif
-  @KWSYS_NAMESPACE@_stl::pair<iterator,bool> insert_noresize(const value_type& __obj)
+  std::pair<iterator,bool> insert_noresize(const value_type& __obj)
     { return _M_ht.insert_unique_noresize(__obj); }
 
   iterator find(const key_type& __key) { return _M_ht.find(__key); }
@@ -215,9 +172,9 @@ public:
 
   size_type count(const key_type& __key) const { return _M_ht.count(__key); }
 
-  @KWSYS_NAMESPACE@_stl::pair<iterator, iterator> equal_range(const key_type& __key)
+  std::pair<iterator, iterator> equal_range(const key_type& __key)
     { return _M_ht.equal_range(__key); }
-  @KWSYS_NAMESPACE@_stl::pair<const_iterator, const_iterator>
+  std::pair<const_iterator, const_iterator>
   equal_range(const key_type& __key) const
     { return _M_ht.equal_range(__key); }
 
@@ -260,8 +217,8 @@ swap(hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1,
 
 template <class _Key, class _Tp,
           class _HashFcn  = hash<_Key>,
-          class _EqualKey = @KWSYS_NAMESPACE@_stl::equal_to<_Key>,
-          class _Alloc = @KWSYS_NAMESPACE@_HASH_DEFAULT_ALLOCATOR(char) >
+          class _EqualKey = std::equal_to<_Key>,
+          class _Alloc = std::allocator<char> >
 class hash_multimap;
 
 template <class _Key, class _Tp, class _HF, class _EqKey, class _Alloc>
@@ -274,7 +231,7 @@ template <class _Key, class _Tp, class _HashFcn, class _EqualKey,
 class hash_multimap
 {
 private:
-  typedef hashtable<@KWSYS_NAMESPACE@_stl::pair<const _Key, _Tp>, _Key, _HashFcn,
+  typedef hashtable<std::pair<const _Key, _Tp>, _Key, _HashFcn,
                     hash_select1st<const _Key, _Tp>, _EqualKey, _Alloc>
           _Ht;
   _Ht _M_ht;
@@ -313,7 +270,6 @@ public:
                 const allocator_type& __a = allocator_type())
     : _M_ht(__n, __hf, __eql, __a) {}
 
-#if @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES
   template <class _InputIterator>
   hash_multimap(_InputIterator __f, _InputIterator __l)
     : _M_ht(100, hasher(), key_equal(), allocator_type())
@@ -334,48 +290,14 @@ public:
     : _M_ht(__n, __hf, __eql, __a)
     { _M_ht.insert_equal(__f, __l); }
 
-#else
-  hash_multimap(const value_type* __f, const value_type* __l)
-    : _M_ht(100, hasher(), key_equal(), allocator_type())
-    { _M_ht.insert_equal(__f, __l); }
-  hash_multimap(const value_type* __f, const value_type* __l, size_type __n)
-    : _M_ht(__n, hasher(), key_equal(), allocator_type())
-    { _M_ht.insert_equal(__f, __l); }
-  hash_multimap(const value_type* __f, const value_type* __l, size_type __n,
-                const hasher& __hf)
-    : _M_ht(__n, __hf, key_equal(), allocator_type())
-    { _M_ht.insert_equal(__f, __l); }
-  hash_multimap(const value_type* __f, const value_type* __l, size_type __n,
-                const hasher& __hf, const key_equal& __eql,
-                const allocator_type& __a = allocator_type())
-    : _M_ht(__n, __hf, __eql, __a)
-    { _M_ht.insert_equal(__f, __l); }
-
-  hash_multimap(const_iterator __f, const_iterator __l)
-    : _M_ht(100, hasher(), key_equal(), allocator_type())
-    { _M_ht.insert_equal(__f, __l); }
-  hash_multimap(const_iterator __f, const_iterator __l, size_type __n)
-    : _M_ht(__n, hasher(), key_equal(), allocator_type())
-    { _M_ht.insert_equal(__f, __l); }
-  hash_multimap(const_iterator __f, const_iterator __l, size_type __n,
-                const hasher& __hf)
-    : _M_ht(__n, __hf, key_equal(), allocator_type())
-    { _M_ht.insert_equal(__f, __l); }
-  hash_multimap(const_iterator __f, const_iterator __l, size_type __n,
-                const hasher& __hf, const key_equal& __eql,
-                const allocator_type& __a = allocator_type())
-    : _M_ht(__n, __hf, __eql, __a)
-    { _M_ht.insert_equal(__f, __l); }
-#endif
-
 public:
   size_type size() const { return _M_ht.size(); }
   size_type max_size() const { return _M_ht.max_size(); }
   bool empty() const { return _M_ht.empty(); }
   void swap(hash_multimap& __hs) { _M_ht.swap(__hs._M_ht); }
 
-  friend bool operator==@KWSYS_NAMESPACE@_CXX_NULL_TEMPLATE_ARGS(const hash_multimap&,
-                                                                 const hash_multimap&);
+  friend bool operator==<>(const hash_multimap&,
+                           const hash_multimap&);
 
   iterator begin() { return _M_ht.begin(); }
   iterator end() { return _M_ht.end(); }
@@ -385,17 +307,9 @@ public:
 public:
   iterator insert(const value_type& __obj)
     { return _M_ht.insert_equal(__obj); }
-#if @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES
   template <class _InputIterator>
   void insert(_InputIterator __f, _InputIterator __l)
     { _M_ht.insert_equal(__f,__l); }
-#else
-  void insert(const value_type* __f, const value_type* __l) {
-    _M_ht.insert_equal(__f,__l);
-  }
-  void insert(const_iterator __f, const_iterator __l)
-    { _M_ht.insert_equal(__f, __l); }
-#endif
   iterator insert_noresize(const value_type& __obj)
     { return _M_ht.insert_equal_noresize(__obj); }
 
@@ -405,9 +319,9 @@ public:
 
   size_type count(const key_type& __key) const { return _M_ht.count(__key); }
 
-  @KWSYS_NAMESPACE@_stl::pair<iterator, iterator> equal_range(const key_type& __key)
+  std::pair<iterator, iterator> equal_range(const key_type& __key)
     { return _M_ht.equal_range(__key); }
-  @KWSYS_NAMESPACE@_stl::pair<const_iterator, const_iterator>
+  std::pair<const_iterator, const_iterator>
   equal_range(const key_type& __key) const
     { return _M_ht.equal_range(__key); }
 

Source/kwsys/hash_set.hxx.in

@@ -39,7 +39,7 @@
 
 #include <@KWSYS_NAMESPACE@/hashtable.hxx>
 #include <@KWSYS_NAMESPACE@/hash_fun.hxx>
-#include <@KWSYS_NAMESPACE@/stl/functional> // equal_to
+#include <functional> // equal_to
 
 #if defined(_MSC_VER)
 # pragma warning (push)
@@ -57,7 +57,7 @@ namespace @KWSYS_NAMESPACE@
 
 // identity is an extension: it is not part of the standard.
 template <class _Tp>
-struct _Identity : public @KWSYS_NAMESPACE@_stl::unary_function<_Tp,_Tp>
+struct _Identity : public std::unary_function<_Tp,_Tp>
 {
   const _Tp& operator()(const _Tp& __x) const { return __x; }
 };
@@ -66,8 +66,8 @@ struct _Identity : public @KWSYS_NAMESPACE@_stl::unary_function<_Tp,_Tp>
 
 template <class _Value,
           class _HashFcn  = hash<_Value>,
-          class _EqualKey = @KWSYS_NAMESPACE@_stl::equal_to<_Value>,
-          class _Alloc = @KWSYS_NAMESPACE@_HASH_DEFAULT_ALLOCATOR(char) >
+          class _EqualKey = std::equal_to<_Value>,
+          class _Alloc = std::allocator<char> >
 class hash_set;
 
 template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
@@ -116,7 +116,6 @@ public:
            const allocator_type& __a = allocator_type())
     : _M_ht(__n, __hf, __eql, __a) {}
 
-#if @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES
   template <class _InputIterator>
   hash_set(_InputIterator __f, _InputIterator __l)
     : _M_ht(100, hasher(), key_equal(), allocator_type())
@@ -136,40 +135,6 @@ public:
            const allocator_type& __a = allocator_type())
     : _M_ht(__n, __hf, __eql, __a)
     { _M_ht.insert_unique(__f, __l); }
-#else
-
-  hash_set(const value_type* __f, const value_type* __l)
-    : _M_ht(100, hasher(), key_equal(), allocator_type())
-    { _M_ht.insert_unique(__f, __l); }
-  hash_set(const value_type* __f, const value_type* __l, size_type __n)
-    : _M_ht(__n, hasher(), key_equal(), allocator_type())
-    { _M_ht.insert_unique(__f, __l); }
-  hash_set(const value_type* __f, const value_type* __l, size_type __n,
-           const hasher& __hf)
-    : _M_ht(__n, __hf, key_equal(), allocator_type())
-    { _M_ht.insert_unique(__f, __l); }
-  hash_set(const value_type* __f, const value_type* __l, size_type __n,
-           const hasher& __hf, const key_equal& __eql,
-           const allocator_type& __a = allocator_type())
-    : _M_ht(__n, __hf, __eql, __a)
-    { _M_ht.insert_unique(__f, __l); }
-
-  hash_set(const_iterator __f, const_iterator __l)
-    : _M_ht(100, hasher(), key_equal(), allocator_type())
-    { _M_ht.insert_unique(__f, __l); }
-  hash_set(const_iterator __f, const_iterator __l, size_type __n)
-    : _M_ht(__n, hasher(), key_equal(), allocator_type())
-    { _M_ht.insert_unique(__f, __l); }
-  hash_set(const_iterator __f, const_iterator __l, size_type __n,
-           const hasher& __hf)
-    : _M_ht(__n, __hf, key_equal(), allocator_type())
-    { _M_ht.insert_unique(__f, __l); }
-  hash_set(const_iterator __f, const_iterator __l, size_type __n,
-           const hasher& __hf, const key_equal& __eql,
-           const allocator_type& __a = allocator_type())
-    : _M_ht(__n, __hf, __eql, __a)
-    { _M_ht.insert_unique(__f, __l); }
-#endif
 
 public:
   size_type size() const { return _M_ht.size(); }
@@ -177,43 +142,35 @@ public:
   bool empty() const { return _M_ht.empty(); }
   void swap(hash_set& __hs) { _M_ht.swap(__hs._M_ht); }
 
-  friend bool operator==@KWSYS_NAMESPACE@_CXX_NULL_TEMPLATE_ARGS(const hash_set&,
-                                                                 const hash_set&);
+  friend bool operator==<>(const hash_set&,
+                           const hash_set&);
 
   iterator begin() const { return _M_ht.begin(); }
   iterator end() const { return _M_ht.end(); }
 
 public:
-  @KWSYS_NAMESPACE@_stl::pair<iterator, bool> insert(const value_type& __obj)
+  std::pair<iterator, bool> insert(const value_type& __obj)
     {
       typedef typename _Ht::iterator _Ht_iterator;
-      @KWSYS_NAMESPACE@_stl::pair<_Ht_iterator, bool> __p = _M_ht.insert_unique(__obj);
-      return @KWSYS_NAMESPACE@_stl::pair<iterator,bool>(__p.first, __p.second);
+      std::pair<_Ht_iterator, bool> __p = _M_ht.insert_unique(__obj);
+      return std::pair<iterator,bool>(__p.first, __p.second);
     }
-#if @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES
   template <class _InputIterator>
   void insert(_InputIterator __f, _InputIterator __l)
     { _M_ht.insert_unique(__f,__l); }
-#else
-  void insert(const value_type* __f, const value_type* __l) {
-    _M_ht.insert_unique(__f,__l);
-  }
-  void insert(const_iterator __f, const_iterator __l)
-    {_M_ht.insert_unique(__f, __l); }
-#endif
-  @KWSYS_NAMESPACE@_stl::pair<iterator, bool> insert_noresize(const value_type& __obj)
+  std::pair<iterator, bool> insert_noresize(const value_type& __obj)
   {
     typedef typename _Ht::iterator _Ht_iterator;
-    @KWSYS_NAMESPACE@_stl::pair<_Ht_iterator, bool> __p =
+    std::pair<_Ht_iterator, bool> __p =
       _M_ht.insert_unique_noresize(__obj);
-    return @KWSYS_NAMESPACE@_stl::pair<iterator, bool>(__p.first, __p.second);
+    return std::pair<iterator, bool>(__p.first, __p.second);
   }
 
   iterator find(const key_type& __key) const { return _M_ht.find(__key); }
 
   size_type count(const key_type& __key) const { return _M_ht.count(__key); }
 
-  @KWSYS_NAMESPACE@_stl::pair<iterator, iterator> equal_range(const key_type& __key) const
+  std::pair<iterator, iterator> equal_range(const key_type& __key) const
     { return _M_ht.equal_range(__key); }
 
   size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
@@ -254,8 +211,8 @@ swap(hash_set<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1,
 
 template <class _Value,
           class _HashFcn = hash<_Value>,
-          class _EqualKey = @KWSYS_NAMESPACE@_stl::equal_to<_Value>,
-          class _Alloc = @KWSYS_NAMESPACE@_HASH_DEFAULT_ALLOCATOR(char) >
+          class _EqualKey = std::equal_to<_Value>,
+          class _Alloc = std::allocator<char> >
 class hash_multiset;
 
 template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
@@ -305,7 +262,6 @@ public:
                 const allocator_type& __a = allocator_type())
     : _M_ht(__n, __hf, __eql, __a) {}
 
-#if @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES
   template <class _InputIterator>
   hash_multiset(_InputIterator __f, _InputIterator __l)
     : _M_ht(100, hasher(), key_equal(), allocator_type())
@@ -325,40 +281,6 @@ public:
                 const allocator_type& __a = allocator_type())
     : _M_ht(__n, __hf, __eql, __a)
     { _M_ht.insert_equal(__f, __l); }
-#else
-
-  hash_multiset(const value_type* __f, const value_type* __l)
-    : _M_ht(100, hasher(), key_equal(), allocator_type())
-    { _M_ht.insert_equal(__f, __l); }
-  hash_multiset(const value_type* __f, const value_type* __l, size_type __n)
-    : _M_ht(__n, hasher(), key_equal(), allocator_type())
-    { _M_ht.insert_equal(__f, __l); }
-  hash_multiset(const value_type* __f, const value_type* __l, size_type __n,
-                const hasher& __hf)
-    : _M_ht(__n, __hf, key_equal(), allocator_type())
-    { _M_ht.insert_equal(__f, __l); }
-  hash_multiset(const value_type* __f, const value_type* __l, size_type __n,
-                const hasher& __hf, const key_equal& __eql,
-                const allocator_type& __a = allocator_type())
-    : _M_ht(__n, __hf, __eql, __a)
-    { _M_ht.insert_equal(__f, __l); }
-
-  hash_multiset(const_iterator __f, const_iterator __l)
-    : _M_ht(100, hasher(), key_equal(), allocator_type())
-    { _M_ht.insert_equal(__f, __l); }
-  hash_multiset(const_iterator __f, const_iterator __l, size_type __n)
-    : _M_ht(__n, hasher(), key_equal(), allocator_type())
-    { _M_ht.insert_equal(__f, __l); }
-  hash_multiset(const_iterator __f, const_iterator __l, size_type __n,
-                const hasher& __hf)
-    : _M_ht(__n, __hf, key_equal(), allocator_type())
-    { _M_ht.insert_equal(__f, __l); }
-  hash_multiset(const_iterator __f, const_iterator __l, size_type __n,
-                const hasher& __hf, const key_equal& __eql,
-                const allocator_type& __a = allocator_type())
-    : _M_ht(__n, __hf, __eql, __a)
-    { _M_ht.insert_equal(__f, __l); }
-#endif
 
 public:
   size_type size() const { return _M_ht.size(); }
@@ -366,8 +288,8 @@ public:
   bool empty() const { return _M_ht.empty(); }
   void swap(hash_multiset& hs) { _M_ht.swap(hs._M_ht); }
 
-  friend bool operator==@KWSYS_NAMESPACE@_CXX_NULL_TEMPLATE_ARGS(const hash_multiset&,
-                                                                 const hash_multiset&);
+  friend bool operator==<>(const hash_multiset&,
+                           const hash_multiset&);
 
   iterator begin() const { return _M_ht.begin(); }
   iterator end() const { return _M_ht.end(); }
@@ -375,17 +297,9 @@ public:
 public:
   iterator insert(const value_type& __obj)
     { return _M_ht.insert_equal(__obj); }
-#if @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES
   template <class _InputIterator>
   void insert(_InputIterator __f, _InputIterator __l)
     { _M_ht.insert_equal(__f,__l); }
-#else
-  void insert(const value_type* __f, const value_type* __l) {
-    _M_ht.insert_equal(__f,__l);
-  }
-  void insert(const_iterator __f, const_iterator __l)
-    { _M_ht.insert_equal(__f, __l); }
-#endif
   iterator insert_noresize(const value_type& __obj)
     { return _M_ht.insert_equal_noresize(__obj); }
 
@@ -393,7 +307,7 @@ public:
 
   size_type count(const key_type& __key) const { return _M_ht.count(__key); }
 
-  @KWSYS_NAMESPACE@_stl::pair<iterator, iterator> equal_range(const key_type& __key) const
+  std::pair<iterator, iterator> equal_range(const key_type& __key) const
     { return _M_ht.equal_range(__key); }
 
   size_type erase(const key_type& __key) {return _M_ht.erase(__key); }

Source/kwsys/hashtable.hxx.in

@@ -44,13 +44,13 @@
 
 #include <@KWSYS_NAMESPACE@/Configure.hxx>
 
-#include <@KWSYS_NAMESPACE@/cstddef>        // size_t
-#include <@KWSYS_NAMESPACE@/stl/algorithm>  // lower_bound
-#include <@KWSYS_NAMESPACE@/stl/functional> // unary_function
-#include <@KWSYS_NAMESPACE@/stl/iterator>   // iterator_traits
-#include <@KWSYS_NAMESPACE@/stl/memory>     // allocator
-#include <@KWSYS_NAMESPACE@/stl/utility>    // pair
-#include <@KWSYS_NAMESPACE@/stl/vector>     // vector
+#include <stddef.h>   // size_t
+#include <algorithm>  // lower_bound
+#include <functional> // unary_function
+#include <iterator>   // iterator_traits
+#include <memory>     // allocator
+#include <utility>    // pair
+#include <vector>     // vector
 
 #if defined(_MSC_VER)
 # pragma warning (push)
@@ -73,238 +73,9 @@
 # endif
 #endif
 
-#if @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_TEMPLATE
-# define @KWSYS_NAMESPACE@_HASH_DEFAULT_ALLOCATOR(T) @KWSYS_NAMESPACE@_stl::allocator< T >
-#elif @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_NONTEMPLATE
-# define @KWSYS_NAMESPACE@_HASH_DEFAULT_ALLOCATOR(T) @KWSYS_NAMESPACE@_stl::allocator
-#else
-# define @KWSYS_NAMESPACE@_HASH_DEFAULT_ALLOCATOR(T) @KWSYS_NAMESPACE@_stl::alloc
-#endif
-
-#if @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_OBJECTS
-# define @KWSYS_NAMESPACE@_HASH_BUCKETS_INIT(__a) _M_buckets(__a)
-# define @KWSYS_NAMESPACE@_HASH_BUCKETS_GET_ALLOCATOR(__b) , __b.get_allocator()
-#else
-# define @KWSYS_NAMESPACE@_HASH_BUCKETS_INIT(__a) _M_buckets()
-# define @KWSYS_NAMESPACE@_HASH_BUCKETS_GET_ALLOCATOR(__b)
-#endif
-
 namespace @KWSYS_NAMESPACE@
 {
 
-//----------------------------------------------------------------------------
-// Define an allocator adaptor for platforms that do not provide an
-// allocator with the rebind member.
-#if !@KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_REBIND
-
-// Utility functions to convert item counts.
-inline size_t hash_sizeof(void*) { return sizeof(char); }
-inline size_t hash_sizeof(const void*) { return sizeof(char); }
-template <class TPtr> inline size_t hash_sizeof(TPtr p)
-{
-  static_cast<void>(p);
-  return sizeof(*p);
-}
-template <class POut, class PIn, class TSize>
-inline TSize hash_allocator_n(POut out, PIn in, TSize n)
-{
-  return n*(hash_sizeof(out)/hash_sizeof(in) +
-            (hash_sizeof(out)%hash_sizeof(in)>0));
-}
-
-// Define an allocation method to use the native allocator with
-// the proper signature.  The following signatures of the allocate
-// method are used on various STL implementations:
-//   pointer allocate(size_type, const void* hint)
-//   pointer allocate(size_type)
-//   static pointer allocate(size_type, const void* hint)
-//   static pointer allocate(size_type)
-// Where pointer might be a real type or void*.
-// This set of overloads decodes the signature for a particular STL.
-// The extra three int/long arguments will favor certain signatures
-// over others in the case that multiple are present to avoid
-// ambiguity errors.
-template <class TAlloc, class PIn, class TSize, class THint, class POut>
-inline void hash_allocate(TAlloc* a, PIn (TAlloc::*allocate)(TSize, THint),
-                          TSize n_out, const void* hint, POut& out,
-                          int, int, int)
-{
-  TSize n_in = hash_allocator_n(POut(), PIn(), n_out);
-  void* vout = (a->*allocate)(n_in, const_cast<THint>(hint));
-  out = static_cast<POut>(vout);
-}
-
-template <class TAlloc, class PIn, class TSize, class POut>
-inline void hash_allocate(TAlloc* a, PIn (TAlloc::*allocate)(TSize),
-                          TSize n_out, const void*, POut& out,
-                          int, int, long)
-{
-  TSize n_in = hash_allocator_n(POut(), PIn(), n_out);
-  void* vout = (a->*allocate)(n_in);
-  out = static_cast<POut>(vout);
-}
-
-template <class PIn, class TSize, class THint, class POut>
-inline void hash_allocate(void*, PIn (*allocate)(TSize, THint),
-                          TSize n_out, const void* hint, POut& out,
-                          int, long, long)
-{
-  TSize n_in = hash_allocator_n(POut(), PIn(), n_out);
-  void* vout = allocate(n_in, const_cast<THint>(hint));
-  out = static_cast<POut>(vout);
-}
-
-template <class PIn, class TSize, class POut>
-inline void hash_allocate(void*, PIn (*allocate)(TSize),
-                          TSize n_out, const void*, POut& out,
-                          long, long, long)
-{
-  TSize n_in = hash_allocator_n(POut(), PIn(), n_out);
-  void* vout = allocate(n_in);
-  out = static_cast<POut>(vout);
-}
-
-// Define a deallocation method to use the native allocator with
-// the proper signature.  The following signatures of the deallocate
-// method are used on various STL implementations:
-//   void deallocate(pointer, size_type)
-//   void deallocate(pointer)
-//   static void deallocate(pointer, size_type)
-//   static void deallocate(pointer)
-// Where pointer might be a real type or void*.
-// This set of overloads decodes the signature for a particular STL.
-// The extra three int/long arguments will favor certain signatures
-// over others in the case that multiple are present to avoid
-// ambiguity errors.
-template <class TAlloc, class PIn, class TSize, class PInReal, class POut>
-inline void hash_deallocate(TAlloc* a, void (TAlloc::*deallocate)(PIn, TSize),
-                            PInReal, POut p, TSize n_out, int, int, int)
-{
-  TSize n_in = hash_allocator_n(POut(), PInReal(), n_out);
-  void* vout = p;
-  (a->*deallocate)(static_cast<PIn>(vout), n_in);
-}
-
-template <class TAlloc, class PIn, class TSize, class PInReal, class POut>
-inline void hash_deallocate(TAlloc* a, void (TAlloc::*deallocate)(PIn),
-                            PInReal, POut p, TSize, int, int, long)
-{
-  void* vout = p;
-  (a->*deallocate)(static_cast<PIn>(vout));
-}
-
-template <class PIn, class TSize, class PInReal, class POut>
-inline void hash_deallocate(void*, void (*deallocate)(PIn, TSize),
-                            PInReal, POut p, TSize n_out, int, long, long)
-{
-  TSize n_in = hash_allocator_n(POut(), PInReal(), n_out);
-  void* vout = p;
-  deallocate(static_cast<PIn>(vout), n_in);
-}
-
-template <class PIn, class TSize, class PInReal, class POut>
-inline void hash_deallocate(void*, void (*deallocate)(PIn),
-                            PInReal, POut p, TSize, long, long, long)
-{
-  void* vout = p;
-  deallocate(static_cast<PIn>(vout));
-}
-
-// Use the same four overloads as hash_allocate to decode the type
-// really used for allocation.  This is passed as PInReal to the
-// deallocate functions so that hash_allocator_n has the proper size.
-template <class TAlloc, class PIn, class TSize, class THint>
-inline PIn hash_allocate_type(PIn (TAlloc::*)(TSize, THint),
-                              int, int, int) { return 0; }
-template <class TAlloc, class PIn, class TSize>
-inline PIn hash_allocate_type(PIn (TAlloc::*)(TSize),
-                              int, int, long) { return 0; }
-template <class PIn, class TSize, class THint>
-inline PIn hash_allocate_type(PIn (*)(TSize, THint),
-                              int, long, long) { return 0; }
-template <class PIn, class TSize>
-inline PIn hash_allocate_type(PIn (*)(TSize),
-                              long, long, long) { return 0; }
-
-// Define the comparison operators in terms of a base type to avoid
-// needing templated versions.
-class hash_allocator_base {};
-inline bool operator==(const hash_allocator_base&,
-                const hash_allocator_base&) throw() { return true; }
-inline bool operator!=(const hash_allocator_base&,
-                const hash_allocator_base&) throw() { return false; }
-
-// Define the allocator template.
-template <class T, class Alloc>
-class hash_allocator: public hash_allocator_base
-{
-private:
-  // Store the real allocator privately.
-  typedef Alloc alloc_type;
-  alloc_type alloc_;
-
-public:
-  // Standard allocator interface.
-  typedef size_t size_type;
-  typedef ptrdiff_t difference_type;
-  typedef T* pointer;
-  typedef const T* const_pointer;
-  typedef T& reference;
-  typedef const T& const_reference;
-  typedef T value_type;
-
-  hash_allocator() throw(): alloc_() {}
-  hash_allocator(const hash_allocator_base&) throw() : alloc_() {}
-  hash_allocator(const hash_allocator& a) throw() : alloc_(a.alloc_) {}
-  hash_allocator(const alloc_type& a) throw() : alloc_(a) {}
-  ~hash_allocator() throw() {}
-# if @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES
-  template <class U>
-  struct rebind { typedef hash_allocator<U, alloc_type> other; };
-# endif
-  pointer address(reference x) const { return &x; }
-  const_pointer address(const_reference x) const { return &x; }
-  typedef void* void_pointer;
-  typedef const void* const_void_pointer;
-  pointer allocate(size_type n=1, const_void_pointer hint = 0)
-    {
-    if(n)
-      {
-      pointer p;
-      hash_allocate(&alloc_, &alloc_type::allocate, n, hint, p, 1, 1, 1);
-      return p;
-      }
-    else
-      {
-      return 0;
-      }
-    }
-  void deallocate(pointer p, size_type n=1)
-    {
-    if(n)
-      {
-      hash_deallocate(&alloc_, &alloc_type::deallocate,
-                      hash_allocate_type(&alloc_type::allocate, 1, 1, 1),
-                      p, n, 1, 1, 1);
-      }
-    }
-#if @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
-  size_type max_size(size_type s) const throw()
-    {
-    return alloc_.max_size(s);
-    }
-#else
-  size_type max_size() const throw()
-    {
-    size_type n = alloc_.max_size() / sizeof(value_type);
-    return n>0? n:1;
-    }
-#endif
-  void construct(pointer p, const value_type& val) { new (p) value_type(val); }
-  void destroy(pointer p) { (void)p; p->~value_type(); }
-};
-#endif
-
 template <class _Val>
 struct _Hashtable_node
 {
@@ -317,7 +88,7 @@ private:
 
 template <class _Val, class _Key, class _HashFcn,
           class _ExtractKey, class _EqualKey,
-          class _Alloc = @KWSYS_NAMESPACE@_HASH_DEFAULT_ALLOCATOR(char) >
+          class _Alloc = std::allocator<char> >
 class hashtable;
 
 template <class _Val, class _Key, class _HashFcn,
@@ -341,7 +112,7 @@ struct _Hashtable_iterator {
           const_iterator;
   typedef _Hashtable_node<_Val> _Node;
 
-  typedef @KWSYS_NAMESPACE@_stl::forward_iterator_tag iterator_category;
+  typedef std::forward_iterator_tag iterator_category;
   typedef _Val value_type;
   typedef ptrdiff_t difference_type;
   typedef size_t size_type;
@@ -378,7 +149,7 @@ struct _Hashtable_const_iterator {
           const_iterator;
   typedef _Hashtable_node<_Val> _Node;
 
-  typedef @KWSYS_NAMESPACE@_stl::forward_iterator_tag iterator_category;
+  typedef std::forward_iterator_tag iterator_category;
   typedef _Val value_type;
   typedef ptrdiff_t difference_type;
   typedef size_t size_type;
@@ -427,7 +198,7 @@ static inline size_t _stl_next_prime(size_t __n)
 {
   const unsigned long* __first = get_stl_prime_list();
   const unsigned long* __last = get_stl_prime_list() + (int)_stl_num_primes;
-  const unsigned long* pos = @KWSYS_NAMESPACE@_stl::lower_bound(__first, __last, __n);
+  const unsigned long* pos = std::lower_bound(__first, __last, __n);
   return pos == __last ? *(__last - 1) : *pos;
 }
 
@@ -470,27 +241,13 @@ public:
 private:
   typedef _Hashtable_node<_Val> _Node;
 
-#if @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_REBIND
 public:
   typedef typename _Alloc::template rebind<_Val>::other allocator_type;
   allocator_type get_allocator() const { return _M_node_allocator; }
 private:
   typedef typename _Alloc::template rebind<_Node>::other _M_node_allocator_type;
   typedef typename _Alloc::template rebind<_Node*>::other _M_node_ptr_allocator_type;
-  typedef @KWSYS_NAMESPACE@_stl::vector<_Node*,_M_node_ptr_allocator_type> _M_buckets_type;
-#else
-public:
-  typedef hash_allocator<_Val, _Alloc> allocator_type;
-  allocator_type get_allocator() const { return allocator_type(); }
-private:
-  typedef hash_allocator<_Node, _Alloc> _M_node_allocator_type;
-# if @KWSYS_NAMESPACE@_STL_HAS_ALLOCATOR_OBJECTS
-  typedef hash_allocator<_Node*, _Alloc> _M_node_ptr_allocator_type;
-# else
-  typedef _Alloc _M_node_ptr_allocator_type;
-# endif
-  typedef @KWSYS_NAMESPACE@_stl::vector<_Node*,_M_node_ptr_allocator_type> _M_buckets_type;
-#endif
+  typedef std::vector<_Node*,_M_node_ptr_allocator_type> _M_buckets_type;
 
 private:
   _M_node_allocator_type _M_node_allocator;
@@ -525,7 +282,7 @@ public:
       _M_hash(__hf),
       _M_equals(__eql),
       _M_get_key(__ext),
-      @KWSYS_NAMESPACE@_HASH_BUCKETS_INIT(__a),
+      _M_buckets(__a),
       _M_num_elements(0)
   {
     _M_initialize_buckets(__n);
@@ -539,7 +296,7 @@ public:
       _M_hash(__hf),
       _M_equals(__eql),
       _M_get_key(_ExtractKey()),
-      @KWSYS_NAMESPACE@_HASH_BUCKETS_INIT(__a),
+      _M_buckets(__a),
       _M_num_elements(0)
   {
     _M_initialize_buckets(__n);
@@ -550,7 +307,7 @@ public:
       _M_hash(__ht._M_hash),
       _M_equals(__ht._M_equals),
       _M_get_key(__ht._M_get_key),
-      @KWSYS_NAMESPACE@_HASH_BUCKETS_INIT(__ht.get_allocator()),
+      _M_buckets(__ht.get_allocator()),
       _M_num_elements(0)
   {
     _M_copy_from(__ht);
@@ -576,11 +333,11 @@ public:
 
   void swap(hashtable& __ht)
   {
-    @KWSYS_NAMESPACE@_stl::swap(_M_hash, __ht._M_hash);
-    @KWSYS_NAMESPACE@_stl::swap(_M_equals, __ht._M_equals);
-    @KWSYS_NAMESPACE@_stl::swap(_M_get_key, __ht._M_get_key);
+    std::swap(_M_hash, __ht._M_hash);
+    std::swap(_M_equals, __ht._M_equals);
+    std::swap(_M_get_key, __ht._M_get_key);
     _M_buckets.swap(__ht._M_buckets);
-    @KWSYS_NAMESPACE@_stl::swap(_M_num_elements, __ht._M_num_elements);
+    std::swap(_M_num_elements, __ht._M_num_elements);
   }
 
   iterator begin()
@@ -603,8 +360,8 @@ public:
 
   const_iterator end() const { return const_iterator(0, this); }
 
-  friend bool operator==@KWSYS_NAMESPACE@_CXX_NULL_TEMPLATE_ARGS(const hashtable&,
-                                                                 const hashtable&);
+  friend bool operator==<>(const hashtable&,
+                           const hashtable&);
 
 public:
 
@@ -621,7 +378,7 @@ public:
     return __result;
   }
 
-  @KWSYS_NAMESPACE@_stl::pair<iterator, bool> insert_unique(const value_type& __obj)
+  std::pair<iterator, bool> insert_unique(const value_type& __obj)
   {
     resize(_M_num_elements + 1);
     return insert_unique_noresize(__obj);
@@ -633,38 +390,26 @@ public:
     return insert_equal_noresize(__obj);
   }
 
-  @KWSYS_NAMESPACE@_stl::pair<iterator, bool> insert_unique_noresize(const value_type& __obj);
+  std::pair<iterator, bool> insert_unique_noresize(const value_type& __obj);
   iterator insert_equal_noresize(const value_type& __obj);
 
-#if @KWSYS_NAMESPACE@_STL_HAS_ITERATOR_TRAITS
-# define @KWSYS_NAMESPACE@_HASH_ITERATOR_CATEGORY(T,I) \
-  typename @KWSYS_NAMESPACE@_stl::iterator_traits< T >::iterator_category()
-#elif @KWSYS_NAMESPACE@_STL_HAS_ITERATOR_CATEGORY
-# define @KWSYS_NAMESPACE@_HASH_ITERATOR_CATEGORY(T,I) \
-  @KWSYS_NAMESPACE@_stl::iterator_category( I )
-#elif @KWSYS_NAMESPACE@_STL_HAS___ITERATOR_CATEGORY
-# define @KWSYS_NAMESPACE@_HASH_ITERATOR_CATEGORY(T,I) \
-  @KWSYS_NAMESPACE@_stl::__iterator_category( I )
-#endif
-
-#if @KWSYS_NAMESPACE@_CXX_HAS_MEMBER_TEMPLATES && defined(@KWSYS_NAMESPACE@_HASH_ITERATOR_CATEGORY)
   template <class _InputIterator>
   void insert_unique(_InputIterator __f, _InputIterator __l)
   {
     insert_unique(__f, __l,
-      @KWSYS_NAMESPACE@_HASH_ITERATOR_CATEGORY(_InputIterator, __f));
+      typename std::iterator_traits<_InputIterator>::iterator_category());
   }
 
   template <class _InputIterator>
   void insert_equal(_InputIterator __f, _InputIterator __l)
   {
     insert_equal(__f, __l,
-      @KWSYS_NAMESPACE@_HASH_ITERATOR_CATEGORY(_InputIterator, __f));
+      typename std::iterator_traits<_InputIterator>::iterator_category());
   }
 
   template <class _InputIterator>
   void insert_unique(_InputIterator __f, _InputIterator __l,
-                     @KWSYS_NAMESPACE@_stl::input_iterator_tag)
+                     std::input_iterator_tag)
   {
     for ( ; __f != __l; ++__f)
       insert_unique(*__f);
@@ -672,7 +417,7 @@ public:
 
   template <class _InputIterator>
   void insert_equal(_InputIterator __f, _InputIterator __l,
-                    @KWSYS_NAMESPACE@_stl::input_iterator_tag)
+                    std::input_iterator_tag)
   {
     for ( ; __f != __l; ++__f)
       insert_equal(*__f);
@@ -680,10 +425,10 @@ public:
 
   template <class _ForwardIterator>
   void insert_unique(_ForwardIterator __f, _ForwardIterator __l,
-                     @KWSYS_NAMESPACE@_stl::forward_iterator_tag)
+                     std::forward_iterator_tag)
   {
     size_type __n = 0;
-    @KWSYS_NAMESPACE@_stl::distance(__f, __l, __n);
+    std::distance(__f, __l, __n);
     resize(_M_num_elements + __n);
     for ( ; __n > 0; --__n, ++__f)
       insert_unique_noresize(*__f);
@@ -691,51 +436,15 @@ public:
 
   template <class _ForwardIterator>
   void insert_equal(_ForwardIterator __f, _ForwardIterator __l,
-                    @KWSYS_NAMESPACE@_stl::forward_iterator_tag)
+                    std::forward_iterator_tag)
   {
     size_type __n = 0;
-    @KWSYS_NAMESPACE@_stl::distance(__f, __l, __n);
+    std::distance(__f, __l, __n);
     resize(_M_num_elements + __n);
     for ( ; __n > 0; --__n, ++__f)
       insert_equal_noresize(*__f);
   }
 
-#else
-  void insert_unique(const value_type* __f, const value_type* __l)
-  {
-    size_type __n = __l - __f;
-    resize(_M_num_elements + __n);
-    for ( ; __n > 0; --__n, ++__f)
-      insert_unique_noresize(*__f);
-  }
-
-  void insert_equal(const value_type* __f, const value_type* __l)
-  {
-    size_type __n = __l - __f;
-    resize(_M_num_elements + __n);
-    for ( ; __n > 0; --__n, ++__f)
-      insert_equal_noresize(*__f);
-  }
-
-  void insert_unique(const_iterator __f, const_iterator __l)
-  {
-    size_type __n = 0;
-    @KWSYS_NAMESPACE@_stl::distance(__f, __l, __n);
-    resize(_M_num_elements + __n);
-    for ( ; __n > 0; --__n, ++__f)
-      insert_unique_noresize(*__f);
-  }
-
-  void insert_equal(const_iterator __f, const_iterator __l)
-  {
-    size_type __n = 0;
-    @KWSYS_NAMESPACE@_stl::distance(__f, __l, __n);
-    resize(_M_num_elements + __n);
-    for ( ; __n > 0; --__n, ++__f)
-      insert_equal_noresize(*__f);
-  }
-#endif
-
   reference find_or_insert(const value_type& __obj);
 
   iterator find(const key_type& __key)
@@ -771,10 +480,10 @@ public:
     return __result;
   }
 
-  @KWSYS_NAMESPACE@_stl::pair<iterator, iterator>
+  std::pair<iterator, iterator>
   equal_range(const key_type& __key);
 
-  @KWSYS_NAMESPACE@_stl::pair<const_iterator, const_iterator>
+  std::pair<const_iterator, const_iterator>
   equal_range(const key_type& __key) const;
 
   size_type erase(const key_type& __key);
@@ -936,7 +645,7 @@ inline void swap(hashtable<_Val, _Key, _HF, _Extract, _EqKey, _All>& __ht1,
 }
 
 template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
-@KWSYS_NAMESPACE@_stl::pair<@KWSYS_NAMESPACE@_CXX_DECL_TYPENAME hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator, bool>
+std::pair<typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator, bool>
 hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
   ::insert_unique_noresize(const value_type& __obj)
 {
@@ -945,13 +654,13 @@ hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
 
   for (_Node* __cur = __first; __cur; __cur = __cur->_M_next)
     if (_M_equals(_M_get_key(__cur->_M_val), _M_get_key(__obj)))
-      return @KWSYS_NAMESPACE@_stl::pair<iterator, bool>(iterator(__cur, this), false);
+      return std::pair<iterator, bool>(iterator(__cur, this), false);
 
   _Node* __tmp = _M_new_node(__obj);
   __tmp->_M_next = __first;
   _M_buckets[__n] = __tmp;
   ++_M_num_elements;
-  return @KWSYS_NAMESPACE@_stl::pair<iterator, bool>(iterator(__tmp, this), true);
+  return std::pair<iterator, bool>(iterator(__tmp, this), true);
 }
 
 template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
@@ -999,11 +708,11 @@ hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::find_or_insert(const value_type& __obj)
 }
 
 template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
-@KWSYS_NAMESPACE@_stl::pair<@KWSYS_NAMESPACE@_CXX_DECL_TYPENAME hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator,
-     @KWSYS_NAMESPACE@_CXX_DECL_TYPENAME hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator>
+std::pair<typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator,
+          typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::iterator>
 hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::equal_range(const key_type& __key)
 {
-  typedef @KWSYS_NAMESPACE@_stl::pair<iterator, iterator> _Pii;
+  typedef std::pair<iterator, iterator> _Pii;
   const size_type __n = _M_bkt_num_key(__key);
 
   for (_Node* __first = _M_buckets[__n]; __first; __first = __first->_M_next)
@@ -1021,12 +730,12 @@ hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::equal_range(const key_type& __key)
 }
 
 template <class _Val, class _Key, class _HF, class _Ex, class _Eq, class _All>
-@KWSYS_NAMESPACE@_stl::pair<@KWSYS_NAMESPACE@_CXX_DECL_TYPENAME hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::const_iterator,
-     @KWSYS_NAMESPACE@_CXX_DECL_TYPENAME hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::const_iterator>
+std::pair<typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::const_iterator,
+          typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::const_iterator>
 hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
   ::equal_range(const key_type& __key) const
 {
-  typedef @KWSYS_NAMESPACE@_stl::pair<const_iterator, const_iterator> _Pii;
+  typedef std::pair<const_iterator, const_iterator> _Pii;
   const size_type __n = _M_bkt_num_key(__key);
 
   for (const _Node* __first = _M_buckets[__n] ;
@@ -1164,8 +873,8 @@ void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
     const size_type __n = _M_next_size(__num_elements_hint);
     if (__n > __old_n) {
       _M_buckets_type __tmp(
-        __n, (_Node*)(0)
-        @KWSYS_NAMESPACE@_HASH_BUCKETS_GET_ALLOCATOR(_M_buckets));
+        __n, (_Node*)(0),
+        _M_buckets.get_allocator());
       try {
         for (size_type __bucket = 0; __bucket < __old_n; ++__bucket) {
           _Node* __first = _M_buckets[__bucket];
@@ -1274,14 +983,6 @@ void hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>
 
 } // namespace @KWSYS_NAMESPACE@
 
-// Normally the comparison operators should be found in the @KWSYS_NAMESPACE@
-// namespace by argument dependent lookup.  For compilers that do not
-// support it we must bring them into the global namespace now.
-#if !@KWSYS_NAMESPACE@_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
-using @KWSYS_NAMESPACE@::operator==;
-using @KWSYS_NAMESPACE@::operator!=;
-#endif
-
 // Undo warning suppression.
 #if defined(__clang__) && defined(__has_warning)
 # if __has_warning("-Wdeprecated")

Source/kwsys/kwsysPlatformTestsCXX.cxx

@@ -9,110 +9,11 @@
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the License for more information.
 ============================================================================*/
-// Setup for tests that use result of stl namespace test.
-#if defined(KWSYS_STL_HAVE_STD)
-# if KWSYS_STL_HAVE_STD
-#  define kwsys_stl std
-# else
-#  define kwsys_stl
-# endif
-#endif
-
-// Setup for tests that use iostreams.
-#if defined(KWSYS_IOS_USE_ANSI) && defined(KWSYS_IOS_HAVE_STD)
-# if defined(_MSC_VER)
-#  pragma warning (push,1)
-# endif
-# if KWSYS_IOS_USE_ANSI
-#  include <iostream>
-# else
-#  include <iostream.h>
-# endif
-# if defined(_MSC_VER)
-#  pragma warning (pop)
-# endif
-# if KWSYS_IOS_HAVE_STD
-#  define kwsys_ios std
-# else
-#  define kwsys_ios
-# endif
-#endif
-
-#ifdef TEST_KWSYS_STL_HAVE_STD
-#include <list>
-void f(std ::list<int>*) {}
-int main() { return 0; }
-#endif
-
-#ifdef TEST_KWSYS_IOS_USE_ANSI
-#include <iosfwd>
-int main() { return 0; }
-#endif
-
-#ifdef TEST_KWSYS_IOS_HAVE_STD
-#include <iosfwd>
-void f(std ::ostream*) {}
-int main() { return 0; }
-#endif
-
-#ifdef TEST_KWSYS_IOS_USE_SSTREAM
-#include <sstream>
-#if defined(__GNUC__) && __GNUC__ == 2 && __GNUC_MINOR__ == 96
-# error "GCC 2.96 stringstream is buggy"
-#endif
-int main()
-{
-  std ::ostringstream ostr;
-  ostr << "hello";
-  if(ostr.str().size() == 5)
-    {
-    return 0;
-    }
-  return -1;
-}
-#endif
-
-#ifdef TEST_KWSYS_IOS_USE_STRSTREAM_H
-#include <strstream.h>
-int main() { return 0; }
-#endif
-
-#ifdef TEST_KWSYS_IOS_USE_STRSTREA_H
-#include <strstrea.h>
-int main() { return 0; }
-#endif
-
-#ifdef TEST_KWSYS_STL_STRING_HAVE_OSTREAM
-# include <iostream.h>
-# include <string>
-void f(ostream& os, const kwsys_stl::string& s) { os << s; }
-int main() { return 0; }
-#endif
-
-#ifdef TEST_KWSYS_STL_STRING_HAVE_ISTREAM
-# include <iostream.h>
-# include <string>
-void f(istream& is, kwsys_stl::string& s) { is >> s; }
-int main() { return 0; }
-#endif
-
-#ifdef TEST_KWSYS_STL_STRING_HAVE_NEQ_CHAR
-# include <string>
-bool f(const kwsys_stl::string& s) { return s != ""; }
-int main() { return 0; }
-#endif
-
 #ifdef TEST_KWSYS_CXX_HAS_CSTDIO
 #include <cstdio>
 int main() { return 0; }
 #endif
 
-#ifdef TEST_KWSYS_CXX_HAS_CSTDDEF
-#include <cstddef>
-void f(size_t) {}
-int main() { return 0; }
-#endif
-
 #ifdef TEST_KWSYS_CXX_HAS_LONG_LONG
 long long f(long long n) { return n; }
 int main()
@@ -131,150 +32,6 @@ int main()
 }
 #endif
 
-#ifdef TEST_KWSYS_CXX_HAS_NULL_TEMPLATE_ARGS
-template <class T> class A;
-template <class T> int f(A<T>&);
-template <class T> class A
-{
-public:
-  // "friend int f<>(A<T>&)" would conform
-  friend int f(A<T>&);
-private:
-  int x;
-};
-
-template <class T> int f(A<T>& a) { return a.x = 0; }
-template int f(A<int>&);
-
-int main()
-{
-  A<int> a;
-  return f(a);
-}
-#endif
-
-#ifdef TEST_KWSYS_CXX_HAS_MEMBER_TEMPLATES
-template <class U>
-class A
-{
-public:
-  U u;
-  A(): u(0) {}
-  template <class V> V m(V* p) { return *p = u; }
-};
-
-int main()
-{
-  A<short> a;
-  int s = 1;
-  return a.m(&s);
-}
-#endif
-
-#ifdef TEST_KWSYS_CXX_HAS_FULL_SPECIALIZATION
-template <class T> struct A {};
-template <> struct A<int*>
-{
-  static int f() { return 0; }
-};
-int main() { return A<int*>::f(); }
-#endif
-
-#ifdef TEST_KWSYS_CXX_HAS_ARGUMENT_DEPENDENT_LOOKUP
-namespace N
-{
-  class A {};
-  int f(A*) { return 0; }
-}
-void f(void*);
-int main()
-{
-  N::A* a = 0;
-  return f(a);
-}
-#endif
-
-#ifdef TEST_KWSYS_STL_HAS_ITERATOR_TRAITS
-#include <iterator>
-#include <list>
-void f(kwsys_stl::iterator_traits<kwsys_stl::list<int>::iterator>::iterator_category const&) {}
-int main() { return 0; }
-#endif
-
-#ifdef TEST_KWSYS_STL_HAS_ITERATOR_CATEGORY
-#include <iterator>
-#include <list>
-void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::iterator_category(x); }
-int main() { return 0; }
-#endif
-
-#ifdef TEST_KWSYS_STL_HAS___ITERATOR_CATEGORY
-#include <iterator>
-#include <list>
-void f(kwsys_stl::list<int>::iterator x) { kwsys_stl::__iterator_category(x); }
-int main() { return 0; }
-#endif
-
-#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_TEMPLATE
-#include <memory>
-template <class Alloc>
-void f(const Alloc&)
-{
-  typedef typename Alloc::size_type alloc_size_type;
-}
-int main()
-{
-  f(kwsys_stl::allocator<char>());
-  return 0;
-}
-#endif
-
-#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_NONTEMPLATE
-#include <memory>
-void f(kwsys_stl::allocator::size_type const&) {}
-int main() { return 0; }
-#endif
-
-#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_REBIND
-#include <memory>
-template <class T, class Alloc>
-void f(const T&, const Alloc&)
-{
-  typedef typename Alloc::template rebind<T>::other alloc_type;
-}
-int main()
-{
-  f(0, kwsys_stl::allocator<char>());
-  return 0;
-}
-#endif
-
-#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_MAX_SIZE_ARGUMENT
-#include <memory>
-void f(kwsys_stl::allocator<char> const& a)
-{
-  a.max_size(sizeof(int));
-}
-int main()
-{
-  f(kwsys_stl::allocator<char>());
-  return 0;
-}
-#endif
-
-#ifdef TEST_KWSYS_STL_HAS_ALLOCATOR_OBJECTS
-#include <vector>
-void f(kwsys_stl::vector<int> const& v1)
-{
-  kwsys_stl::vector<int>(1, 1, v1.get_allocator());
-}
-int main()
-{
-  f(kwsys_stl::vector<int>());
-  return 0;
-}
-#endif
-
 #ifdef TEST_KWSYS_STAT_HAS_ST_MTIM
 #include <sys/types.h>
 #include <sys/stat.h>
@@ -323,62 +80,55 @@ int main()
 }
 #endif
 
-#ifdef TEST_KWSYS_IOS_HAVE_BINARY
-int test_binary(int, ...)
-{
-  return 0;
-}
-int main()
-{
-  return test_binary(1, kwsys_ios::ios::binary);
-}
-#endif
-
 #ifdef TEST_KWSYS_IOS_HAS_ISTREAM_LONG_LONG
-int test_istream(kwsys_ios::istream& is, long long& x)
+# include <iostream>
+int test_istream(std::istream& is, long long& x)
 {
   return (is >> x)? 1:0;
 }
 int main()
 {
   long long x = 0;
-  return test_istream(kwsys_ios::cin, x);
+  return test_istream(std::cin, x);
 }
 #endif
 
 #ifdef TEST_KWSYS_IOS_HAS_OSTREAM_LONG_LONG
-int test_ostream(kwsys_ios::ostream& os, long long x)
+# include <iostream>
+int test_ostream(std::ostream& os, long long x)
 {
   return (os << x)? 1:0;
 }
 int main()
 {
   long long x = 0;
-  return test_ostream(kwsys_ios::cout, x);
+  return test_ostream(std::cout, x);
 }
 #endif
 
 #ifdef TEST_KWSYS_IOS_HAS_ISTREAM___INT64
-int test_istream(kwsys_ios::istream& is, __int64& x)
+# include <iostream>
+int test_istream(std::istream& is, __int64& x)
 {
   return (is >> x)? 1:0;
 }
 int main()
 {
   __int64 x = 0;
-  return test_istream(kwsys_ios::cin, x);
+  return test_istream(std::cin, x);
 }
 #endif
 
 #ifdef TEST_KWSYS_IOS_HAS_OSTREAM___INT64
-int test_ostream(kwsys_ios::ostream& os, __int64 x)
+# include <iostream>
+int test_ostream(std::ostream& os, __int64 x)
 {
   return (os << x)? 1:0;
 }
 int main()
 {
   __int64 x = 0;
-  return test_ostream(kwsys_ios::cout, x);
+  return test_ostream(std::cout, x);
 }
 #endif
 

Source/kwsys/kwsys_cstddef.hxx.in

@@ -1,35 +0,0 @@
-/*============================================================================
-  KWSys - Kitware System Library
-  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
-
-  Distributed under the OSI-approved BSD License (the "License");
-  see accompanying file Copyright.txt for details.
-
-  This software is distributed WITHOUT ANY WARRANTY; without even the
-  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-  See the License for more information.
-============================================================================*/
-#ifndef @KWSYS_NAMESPACE@_cstddef
-#define @KWSYS_NAMESPACE@_cstddef
-
-#include <@KWSYS_NAMESPACE@/Configure.hxx>
-
-/* Avoid warnings in MSVC standard headers.  */
-#ifdef _MSC_VER
-# pragma warning (push, 1)
-# pragma warning (disable: 4702)
-# pragma warning (disable: 4786)
-#endif
-
-/* Include the real header.  */
-#if @KWSYS_NAMESPACE@_CXX_HAS_CSTDDEF
-# include <cstddef>
-#else
-# include <stddef.h>
-#endif
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-#endif

Source/kwsys/kwsys_ios_fstream.h.in

@@ -1,46 +0,0 @@
-/*============================================================================
-  KWSys - Kitware System Library
-  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
-
-  Distributed under the OSI-approved BSD License (the "License");
-  see accompanying file Copyright.txt for details.
-
-  This software is distributed WITHOUT ANY WARRANTY; without even the
-  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-  See the License for more information.
-============================================================================*/
-#ifndef @KWSYS_NAMESPACE@_ios_fstream
-#define @KWSYS_NAMESPACE@_ios_fstream
-
-#include <@KWSYS_NAMESPACE@/Configure.hxx>
-
-#ifdef _MSC_VER
-# pragma warning (push, 1)
-# pragma warning (disable: 4702)
-# pragma warning (disable: 4995) /* Old streams are deprecated.  */
-#endif
-
-#if @KWSYS_NAMESPACE@_IOS_USE_ANSI
-# include <fstream>
-#else
-# include <fstream.h>
-#endif
-
-#if !@KWSYS_NAMESPACE@_IOS_USE_SSTREAM
-namespace @KWSYS_NAMESPACE@_ios
-{
-  using @KWSYS_NAMESPACE@_ios_namespace::ostream;
-  using @KWSYS_NAMESPACE@_ios_namespace::istream;
-  using @KWSYS_NAMESPACE@_ios_namespace::ofstream;
-  using @KWSYS_NAMESPACE@_ios_namespace::ifstream;
-  using @KWSYS_NAMESPACE@_ios_namespace::ios;
-  using @KWSYS_NAMESPACE@_ios_namespace::endl;
-  using @KWSYS_NAMESPACE@_ios_namespace::flush;
-}
-#endif
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-#endif

Source/kwsys/kwsys_ios_iosfwd.h.in

@@ -1,49 +0,0 @@
-/*============================================================================
-  KWSys - Kitware System Library
-  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
-
-  Distributed under the OSI-approved BSD License (the "License");
-  see accompanying file Copyright.txt for details.
-
-  This software is distributed WITHOUT ANY WARRANTY; without even the
-  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-  See the License for more information.
-============================================================================*/
-#ifndef @KWSYS_NAMESPACE@_ios_iosfwd
-#define @KWSYS_NAMESPACE@_ios_iosfwd
-
-#include <@KWSYS_NAMESPACE@/Configure.hxx>
-
-#ifdef _MSC_VER
-#pragma warning (push, 1)
-#pragma warning (disable: 4702)
-#endif
-
-#if @KWSYS_NAMESPACE@_IOS_USE_ANSI
-# include <iosfwd>
-#else
-class fstream;
-class ifstream;
-class ios;
-class istream;
-class ofstream;
-class ostream;
-#endif
-
-#if !@KWSYS_NAMESPACE@_IOS_USE_SSTREAM
-namespace @KWSYS_NAMESPACE@_ios
-{
-  using @KWSYS_NAMESPACE@_ios_namespace::fstream;
-  using @KWSYS_NAMESPACE@_ios_namespace::ifstream;
-  using @KWSYS_NAMESPACE@_ios_namespace::ios;
-  using @KWSYS_NAMESPACE@_ios_namespace::istream;
-  using @KWSYS_NAMESPACE@_ios_namespace::ofstream;
-  using @KWSYS_NAMESPACE@_ios_namespace::ostream;
-}
-#endif
-
-#ifdef _MSC_VER
-#pragma warning(pop)
-#endif
-
-#endif

Source/kwsys/kwsys_ios_iostream.h.in

@@ -1,99 +0,0 @@
-/*============================================================================
-  KWSys - Kitware System Library
-  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
-
-  Distributed under the OSI-approved BSD License (the "License");
-  see accompanying file Copyright.txt for details.
-
-  This software is distributed WITHOUT ANY WARRANTY; without even the
-  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-  See the License for more information.
-============================================================================*/
-#ifndef @KWSYS_NAMESPACE@_ios_iostream
-#define @KWSYS_NAMESPACE@_ios_iostream
-
-#include <@KWSYS_NAMESPACE@/Configure.hxx>
-
-#ifdef _MSC_VER
-# pragma warning (push, 1)
-# pragma warning (disable: 4702)
-# pragma warning (disable: 4995) /* Old streams are deprecated.  */
-#endif
-
-#if @KWSYS_NAMESPACE@_IOS_USE_ANSI
-# include <iostream>
-#else
-# include <iostream.h>
-#endif
-
-// The HP implementation of iostream defines cin, cout, cerr, and clog
-// as macros in order to do thread-private streams.
-// See /opt/aCC/include/iostream/iostream.h for details.
-// This block redefines the macros in a safe way that is also compatible
-// with the HP definitions and the using declarations below.
-
-#if !@KWSYS_NAMESPACE@_IOS_USE_SSTREAM
-# if defined(__HP_aCC) && (defined(HP_THREAD_SAFE) || defined(_THREAD_SAFE))
-#  if defined(cin) && !defined(@KWSYS_NAMESPACE@_IOS_HP_HACK_CIN)
-#   define @KWSYS_NAMESPACE@_IOS_HP_HACK_CIN
-#   undef cin
-#   define cin __tcin.ref()
-#  endif
-#  if defined(cout) && !defined(@KWSYS_NAMESPACE@_IOS_HP_HACK_COUT)
-#   define @KWSYS_NAMESPACE@_IOS_HP_HACK_COUT
-#   undef cout
-#   define cout __tcout.ref()
-#  endif
-#  if defined(cerr) && !defined(@KWSYS_NAMESPACE@_IOS_HP_HACK_CERR)
-#   define @KWSYS_NAMESPACE@_IOS_HP_HACK_CERR
-#   undef cerr
-#   define cerr __tcerr.ref()
-#  endif
-#  if defined(clog) && !defined(@KWSYS_NAMESPACE@_IOS_HP_HACK_CLOG)
-#   define @KWSYS_NAMESPACE@_IOS_HP_HACK_CLOG
-#   undef clog
-#   define clog __tclog.ref()
-#  endif
-# endif
-#endif
-
-// If using our own sstream emulation code, put the standard
-// streams in the same namespace.
-#if !@KWSYS_NAMESPACE@_IOS_USE_SSTREAM
-namespace @KWSYS_NAMESPACE@_ios
-{
-  typedef int streamsize;
-  typedef int streamoff;
-  using @KWSYS_NAMESPACE@_ios_namespace::ostream;
-  using @KWSYS_NAMESPACE@_ios_namespace::istream;
-  using @KWSYS_NAMESPACE@_ios_namespace::ios;
-  using @KWSYS_NAMESPACE@_ios_namespace::endl;
-  using @KWSYS_NAMESPACE@_ios_namespace::flush;
-# if defined(@KWSYS_NAMESPACE@_IOS_HP_HACK_CIN)
-  using @KWSYS_NAMESPACE@_ios_namespace::__tcin;
-# else
-  using @KWSYS_NAMESPACE@_ios_namespace::cin;
-# endif
-# if defined(@KWSYS_NAMESPACE@_IOS_HP_HACK_COUT)
-  using @KWSYS_NAMESPACE@_ios_namespace::__tcout;
-# else
-  using @KWSYS_NAMESPACE@_ios_namespace::cout;
-# endif
-# if defined(@KWSYS_NAMESPACE@_IOS_HP_HACK_CERR)
-  using @KWSYS_NAMESPACE@_ios_namespace::__tcerr;
-# else
-  using @KWSYS_NAMESPACE@_ios_namespace::cerr;
-# endif
-# if defined(@KWSYS_NAMESPACE@_IOS_HP_HACK_CLOG)
-  using @KWSYS_NAMESPACE@_ios_namespace::__tclog;
-# else
-  using @KWSYS_NAMESPACE@_ios_namespace::clog;
-# endif
-}
-#endif
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-#endif

Source/kwsys/kwsys_ios_sstream.h.in

@@ -1,199 +0,0 @@
-/*============================================================================
-  KWSys - Kitware System Library
-  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
-
-  Distributed under the OSI-approved BSD License (the "License");
-  see accompanying file Copyright.txt for details.
-
-  This software is distributed WITHOUT ANY WARRANTY; without even the
-  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-  See the License for more information.
-============================================================================*/
-#ifndef @KWSYS_NAMESPACE@_ios_sstream
-#define @KWSYS_NAMESPACE@_ios_sstream
-
-#include <@KWSYS_NAMESPACE@/Configure.hxx>
-
-/* Define this macro temporarily to keep the code readable.  */
-#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-# define kwsys_stl @KWSYS_NAMESPACE@_stl
-#endif
-
-#if @KWSYS_NAMESPACE@_IOS_USE_SSTREAM
-# ifdef _MSC_VER
-#  pragma warning (push, 1)
-#  pragma warning (disable: 4702)
-# endif
-# include <sstream>
-# ifdef _MSC_VER
-#  pragma warning(pop)
-# endif
-#else
-# ifdef _MSC_VER
-#  pragma warning (push, 1)
-#  pragma warning (disable: 4702)
-#  pragma warning (disable: 4995) /* Old streams are deprecated.  */
-# endif
-# if @KWSYS_NAMESPACE@_IOS_USE_ANSI
-#  include <strstream>
-# elif @KWSYS_NAMESPACE@_IOS_USE_STRSTREAM_H
-#  include <strstream.h>
-# elif @KWSYS_NAMESPACE@_IOS_USE_STRSTREA_H
-#  include <strstrea.h>
-# endif
-# if @KWSYS_NAMESPACE@_IOS_USE_ANSI
-#  include <new> // Need placement operator new.
-# else
-#  include <new.h> // Need placement operator new.
-# endif
-# ifdef _MSC_VER
-#  pragma warning(pop)
-# endif
-
-// Only have old std strstream classes.  Wrap them to look like new
-// ostringstream and istringstream classes.
-
-# include <@KWSYS_NAMESPACE@/stl/string>
-
-namespace @KWSYS_NAMESPACE@_ios
-{
-using @KWSYS_NAMESPACE@_ios_namespace::streambuf;
-using @KWSYS_NAMESPACE@_ios_namespace::ostream;
-using @KWSYS_NAMESPACE@_ios_namespace::istream;
-using @KWSYS_NAMESPACE@_ios_namespace::strstream;
-using @KWSYS_NAMESPACE@_ios_namespace::istrstream;
-using @KWSYS_NAMESPACE@_ios_namespace::ostrstream;
-using @KWSYS_NAMESPACE@_ios_namespace::ios;
-using @KWSYS_NAMESPACE@_ios_namespace::endl;
-using @KWSYS_NAMESPACE@_ios_namespace::ends;
-using @KWSYS_NAMESPACE@_ios_namespace::flush;
-
-class stringstream_cleanup
-{
-public:
-  stringstream_cleanup(strstream& str): m_StrStream(str) {}
-  ~stringstream_cleanup() { m_StrStream.rdbuf()->freeze(0); }
-  static void IgnoreUnusedVariable(const stringstream_cleanup&) {}
-protected:
-  strstream& m_StrStream;
-private:
-  void operator=(stringstream_cleanup const&);
-};
-
-class stringstream: public strstream
-{
-public:
-  typedef strstream Superclass;
-  stringstream() {}
-  stringstream(const kwsys_stl::string& s) { *this << s.c_str(); }
-  kwsys_stl::string str()
-    {
-    stringstream_cleanup cleanup(*this);
-    stringstream_cleanup::IgnoreUnusedVariable(cleanup);
-// Visual Studio 6 has a strstream::pcount, but this is not rdbuf()->pcount()
-#if (@KWSYS_NAMESPACE@_IOS_USE_STRSTREA_H) && defined(_MSC_VER) && (_MSC_VER == 1200)
-    int count = this->pcount();
-#elif defined(__WATCOMC__)
-    int count = this->rdbuf()->out_waiting();
-#else
-    int count = this->rdbuf()->pcount();
-#endif
-    const char* ptr = this->Superclass::str();
-    return kwsys_stl::string(ptr?ptr:"", count);
-    }
-  void str(const kwsys_stl::string& s)
-    {
-    this->~stringstream();
-    new (this) stringstream(s);
-    }
-private:
-  stringstream(const stringstream&);
-  void operator=(const stringstream&);
-};
-
-class ostringstream_cleanup
-{
-public:
-  ostringstream_cleanup(ostrstream& ostr): m_OStrStream(ostr) {}
-  ~ostringstream_cleanup() { m_OStrStream.rdbuf()->freeze(0); }
-  static void IgnoreUnusedVariable(const ostringstream_cleanup&) {}
-protected:
-  ostrstream& m_OStrStream;
-private:
-  void operator=(ostringstream_cleanup const&);
-};
-
-class ostringstream: public ostrstream
-{
-public:
-  typedef ostrstream Superclass;
-  ostringstream() {}
-  ostringstream(const kwsys_stl::string& s) { *this << s.c_str(); }
-  kwsys_stl::string str()
-    {
-    ostringstream_cleanup cleanup(*this);
-    ostringstream_cleanup::IgnoreUnusedVariable(cleanup);
-    int count = this->pcount();
-    const char* ptr = this->Superclass::str();
-    return kwsys_stl::string(ptr?ptr:"", count);
-    }
-  void str(const kwsys_stl::string& s)
-    {
-    this->~ostringstream();
-    new (this) ostringstream(s);
-    }
-private:
-  ostringstream(const ostringstream&);
-  void operator=(const ostringstream&);
-};
-
-#if defined(_MSC_VER)
-# pragma warning (push)
-# pragma warning (disable: 4097) /* typedef-name used as synonym for class */
-#endif
-#if defined(__WATCOMC__)
-// W728: class modifiers for 'A' conflict with class modifiers for 'B'
-# pragma warning 728 10
-#endif
-
-class istringstream: private kwsys_stl::string, public istrstream
-{
-public:
-  typedef kwsys_stl::string StdString;
-  typedef istrstream IStrStream;
-  istringstream(): StdString(),
-                   IStrStream(const_cast<char*>(StdString::c_str())) {}
-  istringstream(const kwsys_stl::string& s):
-    StdString(s), IStrStream(const_cast<char*>(StdString::c_str())) {}
-  kwsys_stl::string str() const { return *this; }
-  void str(const kwsys_stl::string& s)
-    {
-    this->~istringstream();
-    new (this) istringstream(s);
-    }
-  void clear(int flags)
-    {
-    this->IStrStream::clear(flags);
-    }
-private:
-  istringstream(const istringstream&);
-  void operator=(const istringstream&);
-};
-
-#if defined(__WATCOMC__)
-# pragma warning 728 9
-#endif
-#if defined(_MSC_VER)
-# pragma warning (pop)
-#endif
-
-} // namespace @KWSYS_NAMESPACE@_ios
-
-#endif
-
-/* Undefine temporary macro.  */
-#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
-# undef kwsys_stl
-#endif
-
-#endif

Source/kwsys/kwsys_stl.hxx.in

@@ -1,49 +0,0 @@
-/*============================================================================
-  KWSys - Kitware System Library
-  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
-
-  Distributed under the OSI-approved BSD License (the "License");
-  see accompanying file Copyright.txt for details.
-
-  This software is distributed WITHOUT ANY WARRANTY; without even the
-  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-  See the License for more information.
-============================================================================*/
-#ifndef @KWSYS_NAMESPACE@_stl_@KWSYS_STL_HEADER@
-#define @KWSYS_NAMESPACE@_stl_@KWSYS_STL_HEADER@
-
-#include <@KWSYS_NAMESPACE@/Configure.hxx>
-
-/* Avoid warnings in MSVC standard headers.  */
-#ifdef _MSC_VER
-# pragma warning (push, 1)
-# pragma warning (disable: 4702)
-# pragma warning (disable: 4786)
-#endif
-
-/* The HP standard library defines the functor "times" instead of
-   "multiplies" as specified by C++98 20.3.2 for backward
-   compatibility with earlier specifications.  Defining this macro
-   fixes this behavior.  The name "times" also conflicts with the
-   function declared in sys/times.h on that platform, so we must do
-   this as a work-around anyway.  */
-#if defined(__HP_aCC) && !defined(__HPACC_USING_MULTIPLIES_IN_FUNCTIONAL)
-# define __HPACC_USING_MULTIPLIES_IN_FUNCTIONAL
-# define @KWSYS_NAMESPACE@_DEFINED___HPACC_USING_MULTIPLIES_IN_FUNCTIONAL
-#endif
-
-/* Include the real header.  */
-#include <@KWSYS_STL_HEADER@>
-
-/* Cleanup.  */
-#if defined(@KWSYS_NAMESPACE@_DEFINED___HPACC_USING_MULTIPLIES_IN_FUNCTIONAL)
-# undef @KWSYS_NAMESPACE@_DEFINED___HPACC_USING_MULTIPLIES_IN_FUNCTIONAL
-# undef __HPACC_USING_MULTIPLIES_IN_FUNCTIONAL
-#endif
-
-#ifdef _MSC_VER
-# pragma warning(pop)
-#endif
-
-@KWSYS_STL_HEADER_EXTRA@
-#endif

Source/kwsys/kwsys_stl_string.hxx.in

@@ -1,123 +0,0 @@
-/*============================================================================
-  KWSys - Kitware System Library
-  Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
-
-  Distributed under the OSI-approved BSD License (the "License");
-  see accompanying file Copyright.txt for details.
-
-  This software is distributed WITHOUT ANY WARRANTY; without even the
-  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-  See the License for more information.
-============================================================================*/
-
-// This header is extra code for <@KWSYS_NAMESPACE@/stl/string>.
-#if !defined(@KWSYS_NAMESPACE@_stl_string_including_hxx)
-# error "The header <@KWSYS_NAMESPACE@/stl/string.hxx> may be included only by <@KWSYS_NAMESPACE@/stl/string>."
-#endif
-
-// Provide the istream operator for the stl string if it is not
-// provided by the system or another copy of kwsys.  Allow user code
-// to block this definition by defining the macro
-// @KWSYS_NAMESPACE@_STL_STRING_NO_ISTREAM
-// to avoid conflicts with other libraries.  User code can test for
-// this definition by checking the macro
-// @KWSYS_NAMESPACE@_STL_STRING_ISTREAM_DEFINED
-#if !@KWSYS_NAMESPACE@_STL_STRING_HAVE_ISTREAM && !defined(@KWSYS_NAMESPACE@_STL_STRING_NO_ISTREAM) && !defined(KWSYS_STL_STRING_ISTREAM_DEFINED)
-# define KWSYS_STL_STRING_ISTREAM_DEFINED
-# define @KWSYS_NAMESPACE@_STL_STRING_ISTREAM_DEFINED
-# include <ctype.h> // isspace
-# include <@KWSYS_NAMESPACE@/ios/iostream>
-# if defined(__WATCOMC__)
-namespace @KWSYS_NAMESPACE@
-{
-struct ios_istream_hack: public kwsys_ios::istream
-{ void eatwhite() { this->@KWSYS_NAMESPACE@_ios::istream::eatwhite(); } };
-}
-# endif
-inline @KWSYS_NAMESPACE@_ios::istream&
-operator>>(@KWSYS_NAMESPACE@_ios::istream& is,
-           @KWSYS_NAMESPACE@_stl::string& s)
-{
-  // Keep track of the resulting state.
-  int state = @KWSYS_NAMESPACE@_ios::ios::goodbit;
-
-  // Save the width setting and set it back to zero.
-  size_t n = static_cast<size_t>(is.width(0));
-
-  // Clear any old contents of the output string.
-  s.erase();
-
-  // Skip leading whitespace.
-#if defined(__WATCOMC__)
-  static_cast<@KWSYS_NAMESPACE@::ios_istream_hack&>(is).eatwhite();
-#else
-  is.eatwhite();
-#endif
-  @KWSYS_NAMESPACE@_ios::istream& okay = is;
-
-  if(okay)
-    {
-    // Select a maximum possible length.
-    if(n == 0 || n >= s.max_size())
-      {
-      n = s.max_size();
-      }
-
-    // Read until a space is found or the maximum length is reached.
-    bool success = false;
-    for(int c = is.peek(); (--n > 0 && c != EOF && !isspace(c)); c = is.peek())
-      {
-      s += static_cast<char>(c);
-      success = true;
-      is.ignore();
-      }
-
-    // Set flags for resulting state.
-    if(is.peek() == EOF) { state |= @KWSYS_NAMESPACE@_ios::ios::eofbit; }
-    if(!success) { state |= @KWSYS_NAMESPACE@_ios::ios::failbit; }
-    }
-
-  // Set the final result state.
-  is.clear(state);
-  return is;
-}
-#endif
-
-// Provide the ostream operator for the stl string if it is not
-// provided by the system or another copy of kwsys.  Allow user code
-// to block this definition by defining the macro
-// @KWSYS_NAMESPACE@_STL_STRING_NO_OSTREAM
-// to avoid conflicts with other libraries.  User code can test for
-// this definition by checking the macro
-// @KWSYS_NAMESPACE@_STL_STRING_OSTREAM_DEFINED
-#if !@KWSYS_NAMESPACE@_STL_STRING_HAVE_OSTREAM && !defined(@KWSYS_NAMESPACE@_STL_STRING_NO_OSTREAM) && !defined(KWSYS_STL_STRING_OSTREAM_DEFINED)
-# define KWSYS_STL_STRING_OSTREAM_DEFINED
-# define @KWSYS_NAMESPACE@_STL_STRING_OSTREAM_DEFINED
-# include <@KWSYS_NAMESPACE@/ios/iostream>
-inline @KWSYS_NAMESPACE@_ios::ostream&
-operator<<(@KWSYS_NAMESPACE@_ios::ostream& os,
-           @KWSYS_NAMESPACE@_stl::string const& s)
-{
-  return os << s.c_str();
-}
-#endif
-
-// Provide the operator!= for the stl string and char* if it is not
-// provided by the system or another copy of kwsys.  Allow user code
-// to block this definition by defining the macro
-// @KWSYS_NAMESPACE@_STL_STRING_NO_NEQ_CHAR
-// to avoid conflicts with other libraries.  User code can test for
-// this definition by checking the macro
-// @KWSYS_NAMESPACE@_STL_STRING_NEQ_CHAR_DEFINED
-#if !@KWSYS_NAMESPACE@_STL_STRING_HAVE_NEQ_CHAR && !defined(@KWSYS_NAMESPACE@_STL_STRING_NO_NEQ_CHAR) && !defined(KWSYS_STL_STRING_NEQ_CHAR_DEFINED)
-# define KWSYS_STL_STRING_NEQ_CHAR_DEFINED
-# define @KWSYS_NAMESPACE@_STL_STRING_NEQ_CHAR_DEFINED
-inline bool operator!=(@KWSYS_NAMESPACE@_stl::string const& s, const char* c)
-{
-  return !(s == c);
-}
-inline bool operator!=(const char* c, @KWSYS_NAMESPACE@_stl::string const& s)
-{
-  return !(s == c);
-}
-#endif

Source/kwsys/testCommandLineArguments.cxx

@@ -11,16 +11,16 @@
 ============================================================================*/
 #include "kwsysPrivate.h"
 #include KWSYS_HEADER(CommandLineArguments.hxx)
-#include KWSYS_HEADER(ios/iostream)
-#include KWSYS_HEADER(stl/vector)
 
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
 # include "CommandLineArguments.hxx.in"
-# include "kwsys_ios_iostream.h.in"
 #endif
 
+#include <iostream>
+#include <vector>
+
 #include <stddef.h> /* size_t */
 #include <string.h> /* strcmp */
 
@@ -28,10 +28,10 @@ static void* random_ptr = reinterpret_cast<void*>(0x123);
 
 static int argument(const char* arg, const char* value, void* call_data)
 {
-  kwsys_ios::cout << "Got argument: \"" << arg << "\" value: \"" << (value?value:"(null)") << "\"" << kwsys_ios::endl;
+  std::cout << "Got argument: \"" << arg << "\" value: \"" << (value?value:"(null)") << "\"" << std::endl;
   if ( call_data != random_ptr )
     {
-    kwsys_ios::cerr << "Problem processing call_data" << kwsys_ios::endl;
+    std::cerr << "Problem processing call_data" << std::endl;
     return 0;
     }
   return 1;
@@ -39,10 +39,10 @@ static int argument(const char* arg, const char* value, void* call_data)
 
 static int unknown_argument(const char* argument, void* call_data)
 {
-  kwsys_ios::cout << "Got unknown argument: \"" << argument << "\"" << kwsys_ios::endl;
+  std::cout << "Got unknown argument: \"" << argument << "\"" << std::endl;
   if ( call_data != random_ptr )
     {
-    kwsys_ios::cerr << "Problem processing call_data" << kwsys_ios::endl;
+    std::cerr << "Problem processing call_data" << std::endl;
     return 0;
     }
   return 1;
@@ -53,8 +53,8 @@ static bool CompareTwoItemsOnList(int i1, int i2) { return i1 == i2; }
 static bool CompareTwoItemsOnList(double i1, double i2) { return i1 == i2; }
 static bool CompareTwoItemsOnList(const char* i1,
   const char* i2) { return strcmp(i1, i2) == 0; }
-static bool CompareTwoItemsOnList(const kwsys_stl::string& i1,
-  const kwsys_stl::string& i2) { return i1 == i2; }
+static bool CompareTwoItemsOnList(const std::string& i1,
+  const std::string& i2) { return i1 == i2; }
 
 int testCommandLineArguments(int argc, char* argv[])
 {
@@ -74,26 +74,26 @@ int testCommandLineArguments(int argc, char* argv[])
   int some_int_variable = 10;
   double some_double_variable = 10.10;
   char* some_string_variable = 0;
-  kwsys_stl::string some_stl_string_variable = "";
+  std::string some_stl_string_variable = "";
   bool some_bool_variable = false;
   bool some_bool_variable1 = false;
   bool bool_arg1 = false;
   int bool_arg2 = 0;
 
-  kwsys_stl::vector<int> numbers_argument;
+  std::vector<int> numbers_argument;
   int valid_numbers[] = { 5, 1, 8, 3, 7, 1, 3, 9, 7, 1 };
 
-  kwsys_stl::vector<double> doubles_argument;
+  std::vector<double> doubles_argument;
   double valid_doubles[] = { 12.5, 1.31, 22 };
 
-  kwsys_stl::vector<bool> bools_argument;
+  std::vector<bool> bools_argument;
   bool valid_bools[] = { true, true, false };
 
-  kwsys_stl::vector<char*> strings_argument;
+  std::vector<char*> strings_argument;
   const char* valid_strings[] = { "andy", "bill", "brad", "ken" };
 
-  kwsys_stl::vector<kwsys_stl::string> stl_strings_argument;
-  kwsys_stl::string valid_stl_strings[] = { "ken", "brad", "bill", "andy" };
+  std::vector<std::string> stl_strings_argument;
+  std::string valid_stl_strings[] = { "ken", "brad", "bill", "andy" };
 
   typedef kwsys::CommandLineArguments argT;
 
@@ -122,47 +122,47 @@ int testCommandLineArguments(int argc, char* argv[])
 
   if ( !arg.Parse() )
     {
-    kwsys_ios::cerr << "Problem parsing arguments" << kwsys_ios::endl;
+    std::cerr << "Problem parsing arguments" << std::endl;
     res = 1;
     }
-  kwsys_ios::cout << "Help: " << arg.GetHelp() << kwsys_ios::endl;
+  std::cout << "Help: " << arg.GetHelp() << std::endl;
 
-  kwsys_ios::cout << "Some int variable was set to: " << some_int_variable << kwsys_ios::endl;
-  kwsys_ios::cout << "Some double variable was set to: " << some_double_variable << kwsys_ios::endl;
+  std::cout << "Some int variable was set to: " << some_int_variable << std::endl;
+  std::cout << "Some double variable was set to: " << some_double_variable << std::endl;
   if ( some_string_variable && strcmp(some_string_variable, "test string with space") == 0)
     {
-    kwsys_ios::cout << "Some string variable was set to: " << some_string_variable << kwsys_ios::endl;
+    std::cout << "Some string variable was set to: " << some_string_variable << std::endl;
     delete [] some_string_variable;
     }
   else
     {
-    kwsys_ios::cerr << "Problem setting string variable" << kwsys_ios::endl;
+    std::cerr << "Problem setting string variable" << std::endl;
     res = 1;
     }
   size_t cc;
 #define CompareTwoLists(list1, list_valid, lsize) \
   if ( list1.size() != lsize ) \
     { \
-    kwsys_ios::cerr << "Problem setting " #list1 ". Size is: " << list1.size() \
-     << " should be: " << lsize << kwsys_ios::endl; \
+    std::cerr << "Problem setting " #list1 ". Size is: " << list1.size() \
+     << " should be: " << lsize << std::endl; \
     res = 1; \
     } \
   else \
     { \
-    kwsys_ios::cout << #list1 " argument set:"; \
+    std::cout << #list1 " argument set:"; \
     for ( cc =0; cc < lsize; ++ cc ) \
       { \
-      kwsys_ios::cout << " " << list1[cc]; \
+      std::cout << " " << list1[cc]; \
       if ( !CompareTwoItemsOnList(list1[cc], list_valid[cc]) ) \
         { \
-        kwsys_ios::cerr << "Problem setting " #list1 ". Value of " \
+        std::cerr << "Problem setting " #list1 ". Value of " \
         << cc << " is: [" << list1[cc] << "] <> [" \
-        << list_valid[cc] << "]" << kwsys_ios::endl; \
+        << list_valid[cc] << "]" << std::endl; \
         res = 1; \
         break; \
         } \
       } \
-    kwsys_ios::cout << kwsys_ios::endl; \
+    std::cout << std::endl; \
     }
 
   CompareTwoLists(numbers_argument, valid_numbers, 10);
@@ -171,12 +171,12 @@ int testCommandLineArguments(int argc, char* argv[])
   CompareTwoLists(strings_argument, valid_strings, 4);
   CompareTwoLists(stl_strings_argument, valid_stl_strings, 4);
 
-  kwsys_ios::cout << "Some STL String variable was set to: " << some_stl_string_variable << kwsys_ios::endl;
-  kwsys_ios::cout << "Some bool variable was set to: " << some_bool_variable << kwsys_ios::endl;
-  kwsys_ios::cout << "Some bool variable was set to: " << some_bool_variable1 << kwsys_ios::endl;
-  kwsys_ios::cout << "bool_arg1 variable was set to: " << bool_arg1 << kwsys_ios::endl;
-  kwsys_ios::cout << "bool_arg2 variable was set to: " << bool_arg2 << kwsys_ios::endl;
-  kwsys_ios::cout << kwsys_ios::endl;
+  std::cout << "Some STL String variable was set to: " << some_stl_string_variable << std::endl;
+  std::cout << "Some bool variable was set to: " << some_bool_variable << std::endl;
+  std::cout << "Some bool variable was set to: " << some_bool_variable1 << std::endl;
+  std::cout << "bool_arg1 variable was set to: " << bool_arg1 << std::endl;
+  std::cout << "bool_arg2 variable was set to: " << bool_arg2 << std::endl;
+  std::cout << std::endl;
 
   for ( cc = 0; cc < strings_argument.size(); ++ cc )
     {

Source/kwsys/testCommandLineArguments1.cxx

@@ -11,16 +11,16 @@
 ============================================================================*/
 #include "kwsysPrivate.h"
 #include KWSYS_HEADER(CommandLineArguments.hxx)
-#include KWSYS_HEADER(ios/iostream)
-#include KWSYS_HEADER(stl/vector)
 
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
 # include "CommandLineArguments.hxx.in"
-# include "kwsys_ios_iostream.h.in"
 #endif
 
+#include <iostream>
+#include <vector>
+
 #include <assert.h> /* assert */
 #include <string.h> /* strcmp */
 
@@ -31,7 +31,7 @@ int testCommandLineArguments1(int argc, char* argv[])
 
   int n = 0;
   char* m = 0;
-  kwsys_stl::string p;
+  std::string p;
   int res = 0;
 
   typedef kwsys::CommandLineArguments argT;
@@ -43,27 +43,27 @@ int testCommandLineArguments1(int argc, char* argv[])
 
   if ( !arg.Parse() )
     {
-    kwsys_ios::cerr << "Problem parsing arguments" << kwsys_ios::endl;
+    std::cerr << "Problem parsing arguments" << std::endl;
     res = 1;
     }
   if ( n != 24 )
     {
-    kwsys_ios::cout << "Problem setting N. Value of N: " << n << kwsys_ios::endl;
+    std::cout << "Problem setting N. Value of N: " << n << std::endl;
     res = 1;
     }
   if ( !m || strcmp(m, "test value") != 0 )
     {
-    kwsys_ios::cout << "Problem setting M. Value of M: " << m << kwsys_ios::endl;
+    std::cout << "Problem setting M. Value of M: " << m << std::endl;
     res = 1;
     }
   if ( p != "1" )
     {
-    kwsys_ios::cout << "Problem setting P. Value of P: " << p << kwsys_ios::endl;
+    std::cout << "Problem setting P. Value of P: " << p << std::endl;
     res = 1;
     }
-  kwsys_ios::cout << "Value of N: " << n << kwsys_ios::endl;
-  kwsys_ios::cout << "Value of M: " << m << kwsys_ios::endl;
-  kwsys_ios::cout << "Value of P: " << p << kwsys_ios::endl;
+  std::cout << "Value of N: " << n << std::endl;
+  std::cout << "Value of M: " << m << std::endl;
+  std::cout << "Value of P: " << p << std::endl;
   if ( m )
     {
     delete [] m;
@@ -79,25 +79,25 @@ int testCommandLineArguments1(int argc, char* argv[])
   };
   if ( newArgc != 9 )
     {
-    kwsys_ios::cerr << "Bad number of unused arguments: " << newArgc << kwsys_ios::endl;
+    std::cerr << "Bad number of unused arguments: " << newArgc << std::endl;
     res = 1;
     }
   for ( cc = 0; cc < newArgc; ++ cc )
     {
     assert(newArgv[cc]); /* Quiet Clang scan-build. */
-    kwsys_ios::cout << "Unused argument[" << cc << "] = [" << newArgv[cc] << "]"
-      << kwsys_ios::endl;
+    std::cout << "Unused argument[" << cc << "] = [" << newArgv[cc] << "]"
+      << std::endl;
     if ( cc >= 9 )
       {
-      kwsys_ios::cerr << "Too many unused arguments: " << cc << kwsys_ios::endl;
+      std::cerr << "Too many unused arguments: " << cc << std::endl;
       res = 1;
       }
     else if ( valid_unused_args[cc] &&
       strcmp(valid_unused_args[cc], newArgv[cc]) != 0 )
       {
-      kwsys_ios::cerr << "Bad unused argument [" << cc << "] \""
+      std::cerr << "Bad unused argument [" << cc << "] \""
         << newArgv[cc] << "\" should be: \"" << valid_unused_args[cc] << "\""
-        << kwsys_ios::endl;
+        << std::endl;
       res = 1;
       }
     }

Source/kwsys/testDynamicLoader.cxx

@@ -12,8 +12,6 @@
 #include "kwsysPrivate.h"
 
 #include KWSYS_HEADER(DynamicLoader.hxx)
-#include KWSYS_HEADER(ios/iostream)
-#include KWSYS_HEADER(stl/string)
 
 #if defined(__BEOS__) || defined(__HAIKU__)
 #include <be/kernel/OS.h>  /* disable_debugger() API. */
@@ -23,18 +21,19 @@
 // duplicate the above list of headers.
 #if 0
 # include "DynamicLoader.hxx.in"
-# include "kwsys_ios_iostream.h.in"
-# include "kwsys_stl_string.hxx.in"
 #endif
 
+#include <string>
+#include <iostream>
+
 // Include with <> instead of "" to avoid getting any in-source copy
 // left on disk.
 #include <testSystemTools.h>
 
-static kwsys_stl::string GetLibName(const char* lname)
+static std::string GetLibName(const char* lname)
 {
   // Construct proper name of lib
-  kwsys_stl::string slname;
+  std::string slname;
   slname = EXECUTABLE_OUTPUT_PATH;
 #ifdef CMAKE_INTDIR
   slname += "/";
@@ -56,30 +55,30 @@ static kwsys_stl::string GetLibName(const char* lname)
  */
 int TestDynamicLoader(const char* libname, const char* symbol, int r1, int r2, int r3)
 {
-  kwsys_ios::cerr << "Testing: " << libname << kwsys_ios::endl;
+  std::cerr << "Testing: " << libname << std::endl;
   kwsys::DynamicLoader::LibraryHandle l
     = kwsys::DynamicLoader::OpenLibrary(libname);
   // If result is incompatible with expectation just fails (xor):
   if( (r1 && !l) || (!r1 && l) )
     {
-    kwsys_ios::cerr
-      << kwsys::DynamicLoader::LastError() << kwsys_ios::endl;
+    std::cerr
+      << kwsys::DynamicLoader::LastError() << std::endl;
     return 1;
     }
   kwsys::DynamicLoader::SymbolPointer f
     = kwsys::DynamicLoader::GetSymbolAddress(l, symbol);
   if( (r2 && !f) || (!r2 && f) )
     {
-    kwsys_ios::cerr
-      << kwsys::DynamicLoader::LastError() << kwsys_ios::endl;
+    std::cerr
+      << kwsys::DynamicLoader::LastError() << std::endl;
     return 1;
     }
 #ifndef __APPLE__
   int s = kwsys::DynamicLoader::CloseLibrary(l);
   if( (r3 && !s) || (!r3 && s) )
     {
-    kwsys_ios::cerr
-      << kwsys::DynamicLoader::LastError() << kwsys_ios::endl;
+    std::cerr
+      << kwsys::DynamicLoader::LastError() << std::endl;
     return 1;
     }
 #else
@@ -118,7 +117,7 @@ int testDynamicLoader(int argc, char *argv[])
   res += TestDynamicLoader("libdl.so", "TestDynamicLoader",1,0,1);
 #endif
   // Now try on the generated library
-  kwsys_stl::string libname = GetLibName(KWSYS_NAMESPACE_STRING "TestDynload");
+  std::string libname = GetLibName(KWSYS_NAMESPACE_STRING "TestDynload");
   res += TestDynamicLoader(libname.c_str(), "dummy",1,0,1);
   res += TestDynamicLoader(libname.c_str(), "TestDynamicLoaderSymbolPointer",1,1,1);
   res += TestDynamicLoader(libname.c_str(), "_TestDynamicLoaderSymbolPointer",1,0,1);

Source/kwsys/testEncoding.cxx

@@ -17,8 +17,8 @@
 
 #include KWSYS_HEADER(Encoding.hxx)
 #include KWSYS_HEADER(Encoding.h)
-#include KWSYS_HEADER(ios/iostream)
 
+#include <iostream>
 #include <locale.h>
 #include <string.h>
 #include <stdlib.h>
@@ -28,7 +28,6 @@
 #if 0
 # include "Encoding.hxx.in"
 # include "Encoding.h.in"
-# include "kwsys_ios_iostream.h.in"
 #endif
 
 //----------------------------------------------------------------------------

Source/kwsys/testFStream.cxx

@@ -16,7 +16,6 @@
 #endif
 
 #include KWSYS_HEADER(FStream.hxx)
-#include KWSYS_HEADER(ios/iostream)
 #include <string.h>
 #ifdef __BORLANDC__
 # include <mem.h> /* memcmp */
@@ -26,9 +25,9 @@
 // duplicate the above list of headers.
 #if 0
 # include "FStream.hxx.in"
-# include "kwsys_ios_iostream.h.in"
 #endif
 
+#include <iostream>
 
 //----------------------------------------------------------------------------
 static int testNoFile()
@@ -95,20 +94,20 @@ static int testBOM()
     kwsys::FStream::BOM bom = kwsys::FStream::ReadBOM(in);
     if(bom != expected_bom[i])
       {
-      kwsys_ios::cout << "Unexpected BOM " << i << std::endl;
+      std::cout << "Unexpected BOM " << i << std::endl;
       return 1;
       }
     char data[45];
     in.read(data, file_data[i][0]);
     if(!in.good())
       {
-      kwsys_ios::cout << "Unable to read data " << i << std::endl;
+      std::cout << "Unable to read data " << i << std::endl;
       return 1;
       }
 
     if(memcmp(data, file_data[i]+1, file_data[i][0]) != 0)
       {
-      kwsys_ios::cout << "Incorrect read data " << i << std::endl;
+      std::cout << "Incorrect read data " << i << std::endl;
       return 1;
       }
 
@@ -125,20 +124,20 @@ static int testBOM()
     kwsys::FStream::BOM bom = kwsys::FStream::ReadBOM(in);
     if(bom != kwsys::FStream::BOM_None)
       {
-      kwsys_ios::cout << "Unexpected BOM for none case" << std::endl;
+      std::cout << "Unexpected BOM for none case" << std::endl;
       return 1;
       }
     char data[45];
     in.read(data, file_data[0][0]);
     if(!in.good())
       {
-      kwsys_ios::cout << "Unable to read data for none case" << std::endl;
+      std::cout << "Unable to read data for none case" << std::endl;
       return 1;
       }
 
     if(memcmp(data, file_data[0]+1, file_data[0][0]) != 0)
       {
-      kwsys_ios::cout << "Incorrect read data for none case" << std::endl;
+      std::cout << "Incorrect read data for none case" << std::endl;
       return 1;
       }
   }
@@ -156,20 +155,20 @@ static int testBOM()
     kwsys::FStream::BOM bom = kwsys::FStream::ReadBOM(in);
     if(bom != kwsys::FStream::BOM_UTF8)
       {
-      kwsys_ios::cout << "Unexpected BOM for utf-8 case" << std::endl;
+      std::cout << "Unexpected BOM for utf-8 case" << std::endl;
       return 1;
       }
     char data[45];
     in.read(data, file_data[0][0]);
     if(!in.good())
       {
-      kwsys_ios::cout << "Unable to read data for utf-8 case" << std::endl;
+      std::cout << "Unable to read data for utf-8 case" << std::endl;
       return 1;
       }
 
     if(memcmp(data, file_data[0]+1, file_data[0][0]) != 0)
       {
-      kwsys_ios::cout << "Incorrect read data for utf-8 case" << std::endl;
+      std::cout << "Incorrect read data for utf-8 case" << std::endl;
       return 1;
       }
   }

Source/kwsys/testHashSTL.cxx

@@ -12,7 +12,6 @@
 #include "kwsysPrivate.h"
 #include KWSYS_HEADER(hash_map.hxx)
 #include KWSYS_HEADER(hash_set.hxx)
-#include KWSYS_HEADER(ios/iostream)
 
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
@@ -20,9 +19,10 @@
 # include "hash_map.hxx.in"
 # include "hash_set.hxx.in"
 # include "hashtable.hxx.in"
-# include "kwsys_ios_iostream.h.in"
 #endif
 
+#include <iostream>
+
 #if defined(_MSC_VER)
 # pragma warning (disable:4786)
 #endif
@@ -44,8 +44,8 @@ static bool test_hash_map()
   int sum = 0;
   for(mtype::iterator mi = m.begin(); mi != m.end(); ++mi)
     {
-    kwsys_ios::cout << "Found entry [" << mi->first << "," << mi->second << "]"
-                    << kwsys_ios::endl;
+    std::cout << "Found entry [" << mi->first << "," << mi->second << "]"
+              << std::endl;
     sum += mi->second;
     }
   return sum == 3;
@@ -60,7 +60,7 @@ static bool test_hash_set()
   int sum = 0;
   for(stype::iterator si = s.begin(); si != s.end(); ++si)
     {
-    kwsys_ios::cout << "Found entry [" << *si << "]" << kwsys_ios::endl;
+    std::cout << "Found entry [" << *si << "]" << std::endl;
     sum += *si;
     }
   return sum == 3;

Source/kwsys/testIOS.cxx

@@ -10,158 +10,149 @@
   See the License for more information.
 ============================================================================*/
 #include "kwsysPrivate.h"
-#include KWSYS_HEADER(stl/vector)
-#include KWSYS_HEADER(ios/sstream)
-#include KWSYS_HEADER(ios/fstream)
-#include KWSYS_HEADER(ios/iostream)
-
-// Work-around CMake dependency scanning limitation.  This must
-// duplicate the above list of headers.
-#if 0
-# include "kwsys_stl_string.hxx.in"
-# include "kwsys_stl_vector.h.in"
-# include "kwsys_ios_sstream.h.in"
-# include "kwsys_ios_fstream.h.in"
-# include "kwsys_ios_iostream.h.in"
-#endif
+#include KWSYS_HEADER(Configure.hxx)
 
+#include <sstream>
+#include <fstream>
+#include <iostream>
+#include <vector>
 #include <string.h> /* strlen */
 
 int testIOS(int, char*[])
 {
-  kwsys_ios::ostringstream ostr;
+  std::ostringstream ostr;
   const char hello[] = "hello";
   ostr << hello;
   if(ostr.str() != hello)
     {
-    kwsys_ios::cerr << "failed to write hello to ostr" << kwsys_ios::endl;
+    std::cerr << "failed to write hello to ostr" << std::endl;
     return 1;
     }
   const char world[] = "world";
-  kwsys_ios::ostringstream ostr2;
+  std::ostringstream ostr2;
   ostr2.write( hello, strlen(hello) ); /* I could do sizeof */
   ostr2.put( '\0' );
   ostr2.write( world, strlen(world) );
   if(ostr2.str().size() !=  strlen(hello) + 1 + strlen(world) )
     {
-    kwsys_ios::cerr << "failed to write hello to ostr2" << kwsys_ios::endl;
+    std::cerr << "failed to write hello to ostr2" << std::endl;
     return 1;
     }
   static const unsigned char array[] = { 0xff,0x4f,0xff,0x51,0x00,0x29,0x00,0x00,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x3e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x3e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x07,0x01,0x01,0xff,0x52,0x00,0x0c,0x00,0x00,0x00,0x01,0x00,0x05,0x04,0x04,0x00,0x01,0xff,0x5c,0x00,0x13,0x40,0x40,0x48,0x48,0x50,0x48,0x48,0x50,0x48,0x48,0x50,0x48,0x48,0x50,0x48,0x48,0x50,0xff,0x64,0x00,0x2c,0x00,0x00,0x43,0x72,0x65,0x61,0x74,0x65,0x64,0x20,0x62,0x79,0x20,0x49,0x54,0x4b,0x2f,0x47,0x44,0x43,0x4d,0x2f,0x4f,0x70,0x65,0x6e,0x4a,0x50,0x45,0x47,0x20,0x76,0x65,0x72,0x73,0x69,0x6f,0x6e,0x20,0x31,0x2e,0x30,0xff,0x90,0x00,0x0a,0x00,0x00,0x00,0x00,0x06,0x2c,0x00,0x01,0xff,0x93,0xcf,0xb0,0x18,0x08,0x7f,0xc6,0x99,0xbf,0xff,0xc0,0xf8,0xc1,0xc1,0xf3,0x05,0x81,0xf2,0x83,0x0a,0xa5,0xff,0x10,0x90,0xbf,0x2f,0xff,0x04,0xa8,0x7f,0xc0,0xf8,0xc4,0xc1,0xf3,0x09,0x81,0xf3,0x0c,0x19,0x34 };
   const size_t narray = sizeof(array); // 180
-  kwsys_ios::stringstream strstr;
+  std::stringstream strstr;
   strstr.write( (char*)array, narray );
   //strstr.seekp( narray / 2 ); // set position of put pointer in mid string
   if(strstr.str().size() != narray )
     {
-    kwsys_ios::cerr << "failed to write array to strstr" << kwsys_ios::endl;
+    std::cerr << "failed to write array to strstr" << std::endl;
     return 1;
     }
 
-  kwsys_ios::istringstream istr(" 10 20 str ");
-  kwsys_stl::string s;
+  std::istringstream istr(" 10 20 str ");
+  std::string s;
   int x;
   if(istr >> x)
     {
     if(x != 10)
       {
-      kwsys_ios::cerr << "x != 10" << kwsys_ios::endl;
+      std::cerr << "x != 10" << std::endl;
       return 1;
       }
     }
   else
     {
-    kwsys_ios::cerr << "Failed to read 10 from istr" << kwsys_ios::endl;
+    std::cerr << "Failed to read 10 from istr" << std::endl;
     return 1;
     }
   if(istr >> x)
     {
     if(x != 20)
       {
-      kwsys_ios::cerr << "x != 20" << kwsys_ios::endl;
+      std::cerr << "x != 20" << std::endl;
       return 1;
       }
     }
   else
     {
-    kwsys_ios::cerr << "Failed to read 20 from istr" << kwsys_ios::endl;
+    std::cerr << "Failed to read 20 from istr" << std::endl;
     return 1;
     }
   if(istr >> s)
     {
     if(s != "str")
       {
-      kwsys_ios::cerr << "s != \"str\"" << kwsys_ios::endl;
+      std::cerr << "s != \"str\"" << std::endl;
       return 1;
       }
     }
   else
     {
-    kwsys_ios::cerr << "Failed to read str from istr" << kwsys_ios::endl;
+    std::cerr << "Failed to read str from istr" << std::endl;
     return 1;
     }
   if(istr >> s)
     {
-    kwsys_ios::cerr << "Able to read past end of stream" << kwsys_ios::endl;
+    std::cerr << "Able to read past end of stream" << std::endl;
     return 1;
     }
   else
     {
     // Clear the failure.
-    istr.clear(istr.rdstate() & ~kwsys_ios::ios::eofbit);
-    istr.clear(istr.rdstate() & ~kwsys_ios::ios::failbit);
+    istr.clear(istr.rdstate() & ~std::ios::eofbit);
+    istr.clear(istr.rdstate() & ~std::ios::failbit);
     }
   istr.str("30");
   if(istr >> x)
     {
     if(x != 30)
       {
-      kwsys_ios::cerr << "x != 30" << kwsys_ios::endl;
+      std::cerr << "x != 30" << std::endl;
       return 1;
       }
     }
   else
     {
-    kwsys_ios::cerr << "Failed to read 30 from istr" << kwsys_ios::endl;
+    std::cerr << "Failed to read 30 from istr" << std::endl;
     return 1;
     }
 
-  kwsys_ios::stringstream sstr;
+  std::stringstream sstr;
   sstr << "40 str2";
   if(sstr >> x)
     {
     if(x != 40)
       {
-      kwsys_ios::cerr << "x != 40" << kwsys_ios::endl;
+      std::cerr << "x != 40" << std::endl;
       return 1;
       }
     }
   else
     {
-    kwsys_ios::cerr << "Failed to read 40 from sstr" << kwsys_ios::endl;
+    std::cerr << "Failed to read 40 from sstr" << std::endl;
     return 1;
     }
   if(sstr >> s)
     {
     if(s != "str2")
       {
-      kwsys_ios::cerr << "s != \"str2\"" << kwsys_ios::endl;
+      std::cerr << "s != \"str2\"" << std::endl;
       return 1;
       }
     }
   else
     {
-    kwsys_ios::cerr << "Failed to read str2 from sstr" << kwsys_ios::endl;
+    std::cerr << "Failed to read str2 from sstr" << std::endl;
     return 1;
     }
 
   // Just try to compile this.
   if(x == 12345)
     {
-    kwsys_ios::ifstream fin("/does_not_exist",
-                            kwsys_ios::ios::in | kwsys_ios_binary);
+    std::ifstream fin("/does_not_exist",
+                      std::ios::in | std::ios::binary);
     }
 
-  kwsys_ios::cout << "IOS tests passed" << kwsys_ios::endl;
+  std::cout << "IOS tests passed" << std::endl;
   return 0;
 }

Source/kwsys/testSystemInformation.cxx

@@ -11,15 +11,15 @@
 ============================================================================*/
 #include "kwsysPrivate.h"
 #include KWSYS_HEADER(SystemInformation.hxx)
-#include KWSYS_HEADER(ios/iostream)
 
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
 # include "SystemInformation.hxx.in"
-# include "kwsys_ios_iostream.h.in"
 #endif
 
+#include <iostream>
+
 #if defined(KWSYS_USE_LONG_LONG)
 # if defined(KWSYS_IOS_HAS_OSTREAM_LONG_LONG)
 #  define iostreamLongLong(x) (x)
@@ -36,18 +36,18 @@
 # error "No Long Long"
 #endif
 
-#define printMethod(info, m) kwsys_ios::cout << #m << ": " \
+#define printMethod(info, m) std::cout << #m << ": " \
 << info.m() << "\n"
 
-#define printMethod2(info, m, unit) kwsys_ios::cout << #m << ": " \
+#define printMethod2(info, m, unit) std::cout << #m << ": " \
 << info.m() << " " << unit << "\n"
 
-#define printMethod3(info, m, unit) kwsys_ios::cout << #m << ": " \
+#define printMethod3(info, m, unit) std::cout << #m << ": " \
 << iostreamLongLong(info.m) << " " << unit << "\n"
 
 int testSystemInformation(int, char*[])
 {
-  kwsys_ios::cout << "CTEST_FULL_OUTPUT\n"; // avoid truncation
+  std::cout << "CTEST_FULL_OUTPUT\n"; // avoid truncation
 
   kwsys::SystemInformation info;
   info.RunCPUCheck();
@@ -93,16 +93,16 @@ int testSystemInformation(int, char*[])
     {
     if (info.DoesCPUSupportFeature(static_cast<long int>(1) << i))
       {
-      kwsys_ios::cout << "CPU feature " << i << "\n";
+      std::cout << "CPU feature " << i << "\n";
       }
     }
 
   /* test stack trace
   */
-  kwsys_ios::cout
-    << "Program Stack:" << kwsys_ios::endl
-    << kwsys::SystemInformation::GetProgramStack(0,0) << kwsys_ios::endl
-    << kwsys_ios::endl;
+  std::cout
+    << "Program Stack:" << std::endl
+    << kwsys::SystemInformation::GetProgramStack(0,0) << std::endl
+    << std::endl;
 
   /* test segv handler
   info.SetStackTraceOnError(1);

Source/kwsys/testSystemTools.cxx

@@ -16,19 +16,18 @@
 #endif
 
 #include KWSYS_HEADER(SystemTools.hxx)
-#include KWSYS_HEADER(ios/iostream)
 
 // Work-around CMake dependency scanning limitation.  This must
 // duplicate the above list of headers.
 #if 0
 # include "SystemTools.hxx.in"
-# include "kwsys_ios_iostream.h.in"
 #endif
 
 // Include with <> instead of "" to avoid getting any in-source copy
 // left on disk.
 #include <testSystemTools.h>
 
+#include <iostream>
 #include <string.h> /* strcmp */
 #if defined(_WIN32) && !defined(__CYGWIN__)
 # include <io.h> /* _umask (MSVC) / umask (Borland) */
@@ -63,17 +62,17 @@ static const char* toUnixPaths[][2] =
     {0, 0}
 };
 
-static bool CheckConvertToUnixSlashes(kwsys_stl::string input,
-                                      kwsys_stl::string output)
+static bool CheckConvertToUnixSlashes(std::string input,
+                                      std::string output)
 {
-  kwsys_stl::string result = input;
+  std::string result = input;
   kwsys::SystemTools::ConvertToUnixSlashes(result);
   if ( result != output )
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with ConvertToUnixSlashes - input: " << input
       << " output: " << result << " expected: " << output
-      << kwsys_ios::endl;
+      << std::endl;
     return false;
     }
   return true;
@@ -87,19 +86,19 @@ static const char* checkEscapeChars[][4] =
   {0, 0, 0, 0}
 };
 
-static bool CheckEscapeChars(kwsys_stl::string input,
+static bool CheckEscapeChars(std::string input,
                              const char *chars_to_escape,
                              char escape_char,
-                             kwsys_stl::string output)
+                             std::string output)
 {
-  kwsys_stl::string result = kwsys::SystemTools::EscapeChars(
+  std::string result = kwsys::SystemTools::EscapeChars(
     input.c_str(), chars_to_escape, escape_char);
   if (result != output)
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with CheckEscapeChars - input: " << input
       << " output: " << result << " expected: " << output
-      << kwsys_ios::endl;
+      << std::endl;
     return false;
     }
   return true;
@@ -109,75 +108,75 @@ static bool CheckEscapeChars(kwsys_stl::string input,
 static bool CheckFileOperations()
 {
   bool res = true;
-  const kwsys_stl::string testNonExistingFile(TEST_SYSTEMTOOLS_SOURCE_DIR
+  const std::string testNonExistingFile(TEST_SYSTEMTOOLS_SOURCE_DIR
     "/testSystemToolsNonExistingFile");
-  const kwsys_stl::string testDotFile(TEST_SYSTEMTOOLS_SOURCE_DIR
+  const std::string testDotFile(TEST_SYSTEMTOOLS_SOURCE_DIR
     "/.");
-  const kwsys_stl::string testBinFile(TEST_SYSTEMTOOLS_SOURCE_DIR
+  const std::string testBinFile(TEST_SYSTEMTOOLS_SOURCE_DIR
     "/testSystemTools.bin");
-  const kwsys_stl::string testTxtFile(TEST_SYSTEMTOOLS_SOURCE_DIR
+  const std::string testTxtFile(TEST_SYSTEMTOOLS_SOURCE_DIR
     "/testSystemTools.cxx");
-  const kwsys_stl::string testNewDir(TEST_SYSTEMTOOLS_BINARY_DIR
+  const std::string testNewDir(TEST_SYSTEMTOOLS_BINARY_DIR
     "/testSystemToolsNewDir");
-  const kwsys_stl::string testNewFile(testNewDir + "/testNewFile.txt");
+  const std::string testNewFile(testNewDir + "/testNewFile.txt");
 
   if (kwsys::SystemTools::DetectFileType(testNonExistingFile.c_str()) !=
       kwsys::SystemTools::FileTypeUnknown)
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with DetectFileType - failed to detect type of: "
-      << testNonExistingFile << kwsys_ios::endl;
+      << testNonExistingFile << std::endl;
     res = false;
     }
 
   if (kwsys::SystemTools::DetectFileType(testDotFile.c_str()) !=
       kwsys::SystemTools::FileTypeUnknown)
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with DetectFileType - failed to detect type of: "
-      << testDotFile << kwsys_ios::endl;
+      << testDotFile << std::endl;
     res = false;
     }
 
   if (kwsys::SystemTools::DetectFileType(testBinFile.c_str()) !=
       kwsys::SystemTools::FileTypeBinary)
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with DetectFileType - failed to detect type of: "
-      << testBinFile << kwsys_ios::endl;
+      << testBinFile << std::endl;
     res = false;
     }
 
   if (kwsys::SystemTools::DetectFileType(testTxtFile.c_str()) !=
       kwsys::SystemTools::FileTypeText)
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with DetectFileType - failed to detect type of: "
-      << testTxtFile << kwsys_ios::endl;
+      << testTxtFile << std::endl;
     res = false;
     }
 
   if (kwsys::SystemTools::FileLength(testBinFile) != 766)
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with FileLength - incorrect length for: "
-      << testBinFile << kwsys_ios::endl;
+      << testBinFile << std::endl;
     res = false;
     }
 
   if (!kwsys::SystemTools::MakeDirectory(testNewDir))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with MakeDirectory for: "
-      << testNewDir << kwsys_ios::endl;
+      << testNewDir << std::endl;
     res = false;
     }
 
   if (!kwsys::SystemTools::Touch(testNewFile.c_str(), true))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with Touch for: "
-      << testNewFile << kwsys_ios::endl;
+      << testNewFile << std::endl;
     res = false;
     }
 
@@ -195,34 +194,34 @@ static bool CheckFileOperations()
   mode_t origPerm, thisPerm;
   if (!kwsys::SystemTools::GetPermissions(testNewFile, origPerm))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with GetPermissions (1) for: "
-      << testNewFile << kwsys_ios::endl;
+      << testNewFile << std::endl;
     res = false;
     }
 
   if (!kwsys::SystemTools::SetPermissions(testNewFile, 0))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with SetPermissions (1) for: "
-      << testNewFile << kwsys_ios::endl;
+      << testNewFile << std::endl;
     res = false;
     }
 
   if (!kwsys::SystemTools::GetPermissions(testNewFile, thisPerm))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with GetPermissions (2) for: "
-      << testNewFile << kwsys_ios::endl;
+      << testNewFile << std::endl;
     res = false;
     }
 
   if ((thisPerm & fullMask) != 0)
     {
-    kwsys_ios::cerr
+    std::cerr
       << "SetPermissions failed to set permissions (1) for: "
       << testNewFile << ": actual = " << thisPerm << "; expected = "
-      << 0 << kwsys_ios::endl;
+      << 0 << std::endl;
     res = false;
     }
 
@@ -230,70 +229,70 @@ static bool CheckFileOperations()
   if (kwsys::SystemTools::TestFileAccess(testNewFile,
                                          kwsys::TEST_FILE_WRITE))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "TestFileAccess incorrectly indicated that this is a writable file:"
-      << testNewFile << kwsys_ios::endl;
+      << testNewFile << std::endl;
     res = false;
     }
 
   if (!kwsys::SystemTools::TestFileAccess(testNewFile,
                                           kwsys::TEST_FILE_OK))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "TestFileAccess incorrectly indicated that this file does not exist:"
-      << testNewFile << kwsys_ios::endl;
+      << testNewFile << std::endl;
     res = false;
     }
 
   // Test restoring/setting full permissions.
   if (!kwsys::SystemTools::SetPermissions(testNewFile, fullMask))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with SetPermissions (2) for: "
-      << testNewFile << kwsys_ios::endl;
+      << testNewFile << std::endl;
     res = false;
     }
 
   if (!kwsys::SystemTools::GetPermissions(testNewFile, thisPerm))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with GetPermissions (3) for: "
-      << testNewFile << kwsys_ios::endl;
+      << testNewFile << std::endl;
     res = false;
     }
 
   if ((thisPerm & fullMask) != fullMask)
     {
-    kwsys_ios::cerr
+    std::cerr
       << "SetPermissions failed to set permissions (2) for: "
       << testNewFile << ": actual = " << thisPerm << "; expected = "
-      << fullMask << kwsys_ios::endl;
+      << fullMask << std::endl;
     res = false;
     }
 
   // Test setting file permissions while honoring umask
   if (!kwsys::SystemTools::SetPermissions(testNewFile, fullMask, true))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with SetPermissions (3) for: "
-      << testNewFile << kwsys_ios::endl;
+      << testNewFile << std::endl;
     res = false;
     }
 
   if (!kwsys::SystemTools::GetPermissions(testNewFile, thisPerm))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with GetPermissions (4) for: "
-      << testNewFile << kwsys_ios::endl;
+      << testNewFile << std::endl;
     res = false;
     }
 
   if ((thisPerm & fullMask) != 0)
     {
-    kwsys_ios::cerr
+    std::cerr
       << "SetPermissions failed to honor umask for: "
       << testNewFile << ": actual = " << thisPerm << "; expected = "
-      << 0 << kwsys_ios::endl;
+      << 0 << std::endl;
     res = false;
     }
 
@@ -303,35 +302,35 @@ static bool CheckFileOperations()
   // Restore file permissions
   if (!kwsys::SystemTools::SetPermissions(testNewFile, origPerm))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with SetPermissions (4) for: "
-      << testNewFile << kwsys_ios::endl;
+      << testNewFile << std::endl;
     res = false;
     }
 
   // Remove the test file
   if (!kwsys::SystemTools::RemoveFile(testNewFile))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with RemoveFile: "
-      << testNewFile << kwsys_ios::endl;
+      << testNewFile << std::endl;
     res = false;
     }
 
-  kwsys_stl::string const testFileMissing(testNewDir + "/testMissingFile.txt");
+  std::string const testFileMissing(testNewDir + "/testMissingFile.txt");
   if (!kwsys::SystemTools::RemoveFile(testFileMissing))
     {
     std::string const& msg = kwsys::SystemTools::GetLastSystemError();
-    kwsys_ios::cerr <<
+    std::cerr <<
       "RemoveFile(\"" << testFileMissing << "\") failed: " << msg << "\n";
     res = false;
     }
 
-  kwsys_stl::string const testFileMissingDir(testNewDir + "/missing/file.txt");
+  std::string const testFileMissingDir(testNewDir + "/missing/file.txt");
   if (!kwsys::SystemTools::RemoveFile(testFileMissingDir))
     {
     std::string const& msg = kwsys::SystemTools::GetLastSystemError();
-    kwsys_ios::cerr <<
+    std::cerr <<
       "RemoveFile(\"" << testFileMissingDir << "\") failed: " << msg << "\n";
     res = false;
     }
@@ -339,9 +338,9 @@ static bool CheckFileOperations()
   kwsys::SystemTools::Touch(testNewFile.c_str(), true);
   if (!kwsys::SystemTools::RemoveADirectory(testNewDir))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with RemoveADirectory for: "
-      << testNewDir << kwsys_ios::endl;
+      << testNewDir << std::endl;
     res = false;
     }
 
@@ -349,14 +348,14 @@ static bool CheckFileOperations()
   // Perform the same file and directory creation and deletion tests but
   // with paths > 256 characters in length.
 
-  const kwsys_stl::string testNewLongDir(
+  const std::string testNewLongDir(
     TEST_SYSTEMTOOLS_BINARY_DIR "/"
     "012345678901234567890123456789012345678901234567890123456789"
     "012345678901234567890123456789012345678901234567890123456789"
     "012345678901234567890123456789012345678901234567890123456789"
     "012345678901234567890123456789012345678901234567890123456789"
     "01234567890123");
-  const kwsys_stl::string testNewLongFile(testNewLongDir + "/"
+  const std::string testNewLongFile(testNewLongDir + "/"
     "012345678901234567890123456789012345678901234567890123456789"
     "012345678901234567890123456789012345678901234567890123456789"
     "012345678901234567890123456789012345678901234567890123456789"
@@ -365,34 +364,34 @@ static bool CheckFileOperations()
 
   if (!kwsys::SystemTools::MakeDirectory(testNewLongDir))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with MakeDirectory for: "
-      << testNewLongDir << kwsys_ios::endl;
+      << testNewLongDir << std::endl;
     res = false;
     }
 
   if (!kwsys::SystemTools::Touch(testNewLongFile.c_str(), true))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with Touch for: "
-      << testNewLongFile << kwsys_ios::endl;
+      << testNewLongFile << std::endl;
     res = false;
     }
 
   if (!kwsys::SystemTools::RemoveFile(testNewLongFile))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with RemoveFile: "
-      << testNewLongFile << kwsys_ios::endl;
+      << testNewLongFile << std::endl;
     res = false;
     }
 
   kwsys::SystemTools::Touch(testNewLongFile.c_str(), true);
   if (!kwsys::SystemTools::RemoveADirectory(testNewLongDir))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with RemoveADirectory for: "
-      << testNewLongDir << kwsys_ios::endl;
+      << testNewLongDir << std::endl;
     res = false;
     }
 #endif
@@ -405,12 +404,12 @@ static bool CheckStringOperations()
 {
   bool res = true;
 
-  kwsys_stl::string test = "mary had a little lamb.";
+  std::string test = "mary had a little lamb.";
   if (kwsys::SystemTools::CapitalizedWords(test) != "Mary Had A Little Lamb.")
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with CapitalizedWords "
-      << '"' << test << '"' << kwsys_ios::endl;
+      << '"' << test << '"' << std::endl;
     res = false;
     }
 
@@ -418,9 +417,9 @@ static bool CheckStringOperations()
   if (kwsys::SystemTools::UnCapitalizedWords(test) !=
       "mary had a little lamb.")
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with UnCapitalizedWords "
-      << '"' << test << '"' << kwsys_ios::endl;
+      << '"' << test << '"' << std::endl;
     res = false;
     }
 
@@ -428,9 +427,9 @@ static bool CheckStringOperations()
   if (kwsys::SystemTools::AddSpaceBetweenCapitalizedWords(test) !=
       "Mary Had The Little Lamb.")
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with AddSpaceBetweenCapitalizedWords "
-      << '"' << test << '"' << kwsys_ios::endl;
+      << '"' << test << '"' << std::endl;
     res = false;
     }
 
@@ -438,9 +437,9 @@ static bool CheckStringOperations()
     kwsys::SystemTools::AppendStrings("Mary Had A"," Little Lamb.");
   if (strcmp(cres,"Mary Had A Little Lamb."))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with AppendStrings "
-      << "\"Mary Had A\" \" Little Lamb.\"" << kwsys_ios::endl;
+      << "\"Mary Had A\" \" Little Lamb.\"" << std::endl;
     res = false;
     }
   delete [] cres;
@@ -449,18 +448,18 @@ static bool CheckStringOperations()
     kwsys::SystemTools::AppendStrings("Mary Had"," A ","Little Lamb.");
   if (strcmp(cres,"Mary Had A Little Lamb."))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with AppendStrings "
-      << "\"Mary Had\" \" A \" \"Little Lamb.\"" << kwsys_ios::endl;
+      << "\"Mary Had\" \" A \" \"Little Lamb.\"" << std::endl;
     res = false;
     }
   delete [] cres;
 
   if (kwsys::SystemTools::CountChar("Mary Had A Little Lamb.",'a') != 3)
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with CountChar "
-      << "\"Mary Had A Little Lamb.\"" << kwsys_ios::endl;
+      << "\"Mary Had A Little Lamb.\"" << std::endl;
     res = false;
     }
 
@@ -468,9 +467,9 @@ static bool CheckStringOperations()
     kwsys::SystemTools::RemoveChars("Mary Had A Little Lamb.","aeiou");
   if (strcmp(cres,"Mry Hd A Lttl Lmb."))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with RemoveChars "
-      << "\"Mary Had A Little Lamb.\"" << kwsys_ios::endl;
+      << "\"Mary Had A Little Lamb.\"" << std::endl;
     res = false;
     }
   delete [] cres;
@@ -479,9 +478,9 @@ static bool CheckStringOperations()
     kwsys::SystemTools::RemoveCharsButUpperHex("Mary Had A Little Lamb.");
   if (strcmp(cres,"A"))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with RemoveCharsButUpperHex "
-      << "\"Mary Had A Little Lamb.\"" << kwsys_ios::endl;
+      << "\"Mary Had A Little Lamb.\"" << std::endl;
     res = false;
     }
   delete [] cres;
@@ -491,9 +490,9 @@ static bool CheckStringOperations()
   kwsys::SystemTools::ReplaceChars(cres2,"aeiou",'X');
   if (strcmp(cres2,"MXry HXd A LXttlX LXmb."))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with ReplaceChars "
-      << "\"Mary Had A Little Lamb.\"" << kwsys_ios::endl;
+      << "\"Mary Had A Little Lamb.\"" << std::endl;
     res = false;
     }
   delete [] cres2;
@@ -501,27 +500,27 @@ static bool CheckStringOperations()
   if (!kwsys::SystemTools::StringStartsWith("Mary Had A Little Lamb.",
                                             "Mary "))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with StringStartsWith "
-      << "\"Mary Had A Little Lamb.\"" << kwsys_ios::endl;
+      << "\"Mary Had A Little Lamb.\"" << std::endl;
     res = false;
     }
 
   if (!kwsys::SystemTools::StringEndsWith("Mary Had A Little Lamb.",
                                           " Lamb."))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with StringEndsWith "
-      << "\"Mary Had A Little Lamb.\"" << kwsys_ios::endl;
+      << "\"Mary Had A Little Lamb.\"" << std::endl;
     res = false;
     }
 
   cres = kwsys::SystemTools::DuplicateString("Mary Had A Little Lamb.");
   if (strcmp(cres,"Mary Had A Little Lamb."))
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with DuplicateString "
-      << "\"Mary Had A Little Lamb.\"" << kwsys_ios::endl;
+      << "\"Mary Had A Little Lamb.\"" << std::endl;
     res = false;
     }
   delete [] cres;
@@ -530,20 +529,20 @@ static bool CheckStringOperations()
   if (kwsys::SystemTools::CropString(test,13) !=
       "Mary ...Lamb.")
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with CropString "
-      << "\"Mary Had A Little Lamb.\"" << kwsys_ios::endl;
+      << "\"Mary Had A Little Lamb.\"" << std::endl;
     res = false;
     }
 
-  kwsys_stl::vector<kwsys_stl::string> lines;
+  std::vector<std::string> lines;
   kwsys::SystemTools::Split("Mary Had A Little Lamb.",lines,' ');
   if (lines[0] != "Mary" || lines[1] != "Had" ||
       lines[2] != "A" || lines[3] != "Little" || lines[4] != "Lamb.")
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with Split "
-      << "\"Mary Had A Little Lamb.\"" << kwsys_ios::endl;
+      << "\"Mary Had A Little Lamb.\"" << std::endl;
     res = false;
     }
 
@@ -552,10 +551,10 @@ static bool CheckStringOperations()
       ("L:\\Local Mojo\\Hex Power Pack\\Iffy Voodoo") !=
       L"\\\\?\\L:\\Local Mojo\\Hex Power Pack\\Iffy Voodoo")
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with ConvertToWindowsExtendedPath "
       << "\"L:\\Local Mojo\\Hex Power Pack\\Iffy Voodoo\""
-      << kwsys_ios::endl;
+      << std::endl;
     res = false;
     }
 
@@ -563,10 +562,10 @@ static bool CheckStringOperations()
       ("L:/Local Mojo/Hex Power Pack/Iffy Voodoo") !=
       L"\\\\?\\L:\\Local Mojo\\Hex Power Pack\\Iffy Voodoo")
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with ConvertToWindowsExtendedPath "
       << "\"L:/Local Mojo/Hex Power Pack/Iffy Voodoo\""
-      << kwsys_ios::endl;
+      << std::endl;
     res = false;
     }
 
@@ -574,10 +573,10 @@ static bool CheckStringOperations()
       ("\\\\Foo\\Local Mojo\\Hex Power Pack\\Iffy Voodoo") !=
       L"\\\\?\\UNC\\Foo\\Local Mojo\\Hex Power Pack\\Iffy Voodoo")
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with ConvertToWindowsExtendedPath "
       << "\"\\\\Foo\\Local Mojo\\Hex Power Pack\\Iffy Voodoo\""
-      << kwsys_ios::endl;
+      << std::endl;
     res = false;
     }
 
@@ -585,70 +584,70 @@ static bool CheckStringOperations()
       ("//Foo/Local Mojo/Hex Power Pack/Iffy Voodoo") !=
       L"\\\\?\\UNC\\Foo\\Local Mojo\\Hex Power Pack\\Iffy Voodoo")
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with ConvertToWindowsExtendedPath "
       << "\"//Foo/Local Mojo/Hex Power Pack/Iffy Voodoo\""
-      << kwsys_ios::endl;
+      << std::endl;
     res = false;
     }
 
   if (kwsys::SystemTools::ConvertToWindowsExtendedPath("//") !=
       L"//")
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with ConvertToWindowsExtendedPath "
       << "\"//\""
-      << kwsys_ios::endl;
+      << std::endl;
     res = false;
     }
 
   if (kwsys::SystemTools::ConvertToWindowsExtendedPath("\\\\.\\") !=
       L"\\\\.\\")
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with ConvertToWindowsExtendedPath "
       << "\"\\\\.\\\""
-      << kwsys_ios::endl;
+      << std::endl;
     res = false;
     }
 
   if (kwsys::SystemTools::ConvertToWindowsExtendedPath("\\\\.\\X") !=
       L"\\\\.\\X")
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with ConvertToWindowsExtendedPath "
       << "\"\\\\.\\X\""
-      << kwsys_ios::endl;
+      << std::endl;
     res = false;
     }
 
   if (kwsys::SystemTools::ConvertToWindowsExtendedPath("\\\\.\\X:") !=
       L"\\\\?\\X:")
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with ConvertToWindowsExtendedPath "
       << "\"\\\\.\\X:\""
-      << kwsys_ios::endl;
+      << std::endl;
     res = false;
     }
 
   if (kwsys::SystemTools::ConvertToWindowsExtendedPath("\\\\.\\X:\\") !=
       L"\\\\?\\X:\\")
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with ConvertToWindowsExtendedPath "
       << "\"\\\\.\\X:\\\""
-      << kwsys_ios::endl;
+      << std::endl;
     res = false;
     }
 
   if (kwsys::SystemTools::ConvertToWindowsExtendedPath("NUL") !=
       L"\\\\.\\NUL")
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with ConvertToWindowsExtendedPath "
       << "\"NUL\""
-      << kwsys_ios::endl;
+      << std::endl;
     res = false;
     }
 
@@ -658,10 +657,10 @@ static bool CheckStringOperations()
       ("L://Local Mojo/Hex Power Pack/Iffy Voodoo") !=
       "\"L:\\Local Mojo\\Hex Power Pack\\Iffy Voodoo\"")
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with ConvertToWindowsOutputPath "
       << "\"L://Local Mojo/Hex Power Pack/Iffy Voodoo\""
-      << kwsys_ios::endl;
+      << std::endl;
     res = false;
     }
 
@@ -669,10 +668,10 @@ static bool CheckStringOperations()
       ("//grayson/Local Mojo/Hex Power Pack/Iffy Voodoo") !=
       "\"\\\\grayson\\Local Mojo\\Hex Power Pack\\Iffy Voodoo\"")
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with ConvertToWindowsOutputPath "
       << "\"//grayson/Local Mojo/Hex Power Pack/Iffy Voodoo\""
-      << kwsys_ios::endl;
+      << std::endl;
     res = false;
     }
 
@@ -680,10 +679,10 @@ static bool CheckStringOperations()
       ("//Local Mojo/Hex Power Pack/Iffy Voodoo") !=
       "//Local\\ Mojo/Hex\\ Power\\ Pack/Iffy\\ Voodoo")
     {
-    kwsys_ios::cerr
+    std::cerr
       << "Problem with ConvertToUnixOutputPath "
       << "\"//Local Mojo/Hex Power Pack/Iffy Voodoo\""
-      << kwsys_ios::endl;
+      << std::endl;
     res = false;
     }
 
@@ -692,20 +691,20 @@ static bool CheckStringOperations()
 
 //----------------------------------------------------------------------------
 
-static bool CheckPutEnv(const kwsys_stl::string& env, const char* name, const char* value)
+static bool CheckPutEnv(const std::string& env, const char* name, const char* value)
 {
   if(!kwsys::SystemTools::PutEnv(env))
     {
-    kwsys_ios::cerr << "PutEnv(\"" << env
-                    << "\") failed!" << kwsys_ios::endl;
+    std::cerr << "PutEnv(\"" << env
+                    << "\") failed!" << std::endl;
     return false;
     }
   const char* v = kwsys::SystemTools::GetEnv(name);
   v = v? v : "(null)";
   if(strcmp(v, value) != 0)
     {
-    kwsys_ios::cerr << "GetEnv(\"" << name << "\") returned \""
-                    << v << "\", not \"" << value << "\"!" << kwsys_ios::endl;
+    std::cerr << "GetEnv(\"" << name << "\") returned \""
+                    << v << "\", not \"" << value << "\"!" << std::endl;
     return false;
     }
   return true;
@@ -715,14 +714,14 @@ static bool CheckUnPutEnv(const char* env, const char* name)
 {
   if(!kwsys::SystemTools::UnPutEnv(env))
     {
-    kwsys_ios::cerr << "UnPutEnv(\"" << env << "\") failed!"
-                    << kwsys_ios::endl;
+    std::cerr << "UnPutEnv(\"" << env << "\") failed!"
+                    << std::endl;
     return false;
     }
   if(const char* v = kwsys::SystemTools::GetEnv(name))
     {
-    kwsys_ios::cerr << "GetEnv(\"" << name << "\") returned \""
-                    << v << "\", not (null)!" << kwsys_ios::endl;
+    std::cerr << "GetEnv(\"" << name << "\") returned \""
+                    << v << "\", not (null)!" << std::endl;
     return false;
     }
   return true;
@@ -744,15 +743,15 @@ static bool CheckEnvironmentOperations()
 
 
 static bool CheckRelativePath(
-  const kwsys_stl::string& local,
-  const kwsys_stl::string& remote,
-  const kwsys_stl::string& expected)
+  const std::string& local,
+  const std::string& remote,
+  const std::string& expected)
 {
-  kwsys_stl::string result = kwsys::SystemTools::RelativePath(local, remote);
+  std::string result = kwsys::SystemTools::RelativePath(local, remote);
   if(expected != result)
     {
-    kwsys_ios::cerr << "RelativePath(" << local << ", " << remote
-      << ")  yielded " << result << " instead of " << expected << kwsys_ios::endl;
+    std::cerr << "RelativePath(" << local << ", " << remote
+      << ")  yielded " << result << " instead of " << expected << std::endl;
     return false;
     }
   return true;
@@ -770,14 +769,14 @@ static bool CheckRelativePaths()
 }
 
 static bool CheckCollapsePath(
-  const kwsys_stl::string& path,
-  const kwsys_stl::string& expected)
+  const std::string& path,
+  const std::string& expected)
 {
-  kwsys_stl::string result = kwsys::SystemTools::CollapseFullPath(path);
+  std::string result = kwsys::SystemTools::CollapseFullPath(path);
   if(expected != result)
     {
-    kwsys_ios::cerr << "CollapseFullPath(" << path
-      << ")  yielded " << result << " instead of " << expected << kwsys_ios::endl;
+    std::cerr << "CollapseFullPath(" << path
+      << ")  yielded " << result << " instead of " << expected << std::endl;
     return false;
     }
   return true;
@@ -803,7 +802,7 @@ int testSystemTools(int, char*[])
     }
 
   // Special check for ~
-  kwsys_stl::string output;
+  std::string output;
   if(kwsys::SystemTools::GetEnv("HOME", output))
     {
     output += "/foo bar/lala";