text: /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
     file Copyright.txt or https://cmake.org/licensing#kwsys for details.  */
  #ifdef __osf__
  #  define _OSF_SOURCE
  #  define _POSIX_C_SOURCE 199506L
  #  define _XOPEN_SOURCE_EXTENDED
  #endif
  
  #if defined(_WIN32) &&                                                        \
    (defined(_MSC_VER) || defined(__WATCOMC__) || defined(__BORLANDC__) ||      \
     defined(__MINGW32__))
  #  define KWSYS_WINDOWS_DIRS
  #else
  #  if defined(__SUNPRO_CC)
  #    include <fcntl.h>
  #  endif
  #endif
  
  #include "kwsysPrivate.h"
  #include KWSYS_HEADER(RegularExpression.hxx)
  #include KWSYS_HEADER(SystemTools.hxx)
  #include KWSYS_HEADER(Directory.hxx)
  #include KWSYS_HEADER(FStream.hxx)
  #include KWSYS_HEADER(Encoding.h)
  #include KWSYS_HEADER(Encoding.hxx)
  
  #include <fstream>
  #include <iostream>
  #include <set>
  #include <sstream>
  #include <utility>
  #include <vector>
  
  // Work-around CMake dependency scanning limitation.  This must
  // duplicate the above list of headers.
  #if 0
  #  include "Directory.hxx.in"
  #  include "Encoding.hxx.in"
  #  include "FStream.hxx.in"
  #  include "RegularExpression.hxx.in"
  #  include "SystemTools.hxx.in"
  #endif
  
  #ifdef _MSC_VER
  #  pragma warning(disable : 4786)
  #endif
  
  #if defined(__sgi) && !defined(__GNUC__)
  #  pragma set woff 1375 /* base class destructor not virtual */
  #endif
  
  #include <ctype.h>
  #include <errno.h>
  #ifdef __QNX__
  #  include <malloc.h> /* for malloc/free on QNX */
  #endif
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  #include <time.h>
  
  #if defined(_WIN32) && !defined(_MSC_VER) && defined(__GNUC__)
  #  include <strings.h> /* for strcasecmp */
  #endif
  
  #ifdef _MSC_VER
  #  define umask _umask // Note this is still umask on Borland
  #endif
  
  // support for realpath call
  #ifndef _WIN32
  #  include <limits.h>
  #  include <pwd.h>
  #  include <sys/ioctl.h>
  #  include <sys/time.h>
  #  include <sys/wait.h>
  #  include <unistd.h>
  #  include <utime.h>
  #  ifndef __VMS
  #    include <sys/param.h>
  #    include <termios.h>
  #  endif
  #  include <signal.h> /* sigprocmask */
  #endif
  
  #ifdef __linux
  #  include <linux/fs.h>
  #endif
  
  // Windows API.
  #if defined(_WIN32)
  #  include <windows.h>
  #  include <winioctl.h>
  #  ifndef INVALID_FILE_ATTRIBUTES
  #    define INVALID_FILE_ATTRIBUTES ((DWORD)-1)
  #  endif
  #  if defined(_MSC_VER) && _MSC_VER >= 1800
  #    define KWSYS_WINDOWS_DEPRECATED_GetVersionEx
  #  endif
  #elif defined(__CYGWIN__)
  #  include <windows.h>
  #  undef _WIN32
  #endif
  
  #if !KWSYS_CXX_HAS_ENVIRON_IN_STDLIB_H
  extern char** environ;
  #endif
  
  #ifdef __CYGWIN__
  #  include <sys/cygwin.h>
  #endif
  
  // getpwnam doesn't exist on Windows and Cray Xt3/Catamount
  // same for TIOCGWINSZ
  #if defined(_WIN32) || defined(__LIBCATAMOUNT__) ||                           \
    (defined(HAVE_GETPWNAM) && HAVE_GETPWNAM == 0)
  #  undef HAVE_GETPWNAM
  #  undef HAVE_TTY_INFO
  #else
  #  define HAVE_GETPWNAM 1
  #  define HAVE_TTY_INFO 1
  #endif
  
  #define VTK_URL_PROTOCOL_REGEX "([a-zA-Z0-9]*)://(.*)"
  #define VTK_URL_REGEX                                                         \
    "([a-zA-Z0-9]*)://(([A-Za-z0-9]+)(:([^:@]+))?@)?([^:@/]+)(:([0-9]+))?/"     \
    "(.+)?"
  
  #ifdef _MSC_VER
  #  include <sys/utime.h>
  #else
  #  include <utime.h>
  #endif
  
  // This is a hack to prevent warnings about these functions being
  // declared but not referenced.
  #if defined(__sgi) && !defined(__GNUC__)
  #  include <sys/termios.h>
  namespace KWSYS_NAMESPACE {
  class SystemToolsHack
  {
  public:
    enum
    {
      Ref1 = sizeof(cfgetospeed(0)),
      Ref2 = sizeof(cfgetispeed(0)),
      Ref3 = sizeof(tcgetattr(0, 0)),
      Ref4 = sizeof(tcsetattr(0, 0, 0)),
      Ref5 = sizeof(cfsetospeed(0, 0)),
      Ref6 = sizeof(cfsetispeed(0, 0))
    };
  };
  }
  #endif
  
  #if defined(_WIN32) &&                                                        \
    (defined(_MSC_VER) || defined(__WATCOMC__) || defined(__BORLANDC__) ||      \
     defined(__MINGW32__))
  #  include <direct.h>
  #  include <io.h>
  #  define _unlink unlink
  #endif
  
  /* The maximum length of a file name.  */
  #if defined(PATH_MAX)
  #  define KWSYS_SYSTEMTOOLS_MAXPATH PATH_MAX
  #elif defined(MAXPATHLEN)
  #  define KWSYS_SYSTEMTOOLS_MAXPATH MAXPATHLEN
  #else
  #  define KWSYS_SYSTEMTOOLS_MAXPATH 16384
  #endif
  #if defined(__WATCOMC__)
  #  include <direct.h>
  #  define _mkdir mkdir
  #  define _rmdir rmdir
  #  define _getcwd getcwd
  #  define _chdir chdir
  #endif
  
  #if defined(__BEOS__) && !defined(__ZETA__)
  #  include <be/kernel/OS.h>
  #  include <be/storage/Path.h>
  
  // BeOS 5 doesn't have usleep(), but it has snooze(), which is identical.
  static inline void usleep(unsigned int msec)
  {
    ::snooze(msec);
  }
  
  // BeOS 5 also doesn't have realpath(), but its C++ API offers something close.
  static inline char* realpath(const char* path, char* resolved_path)
  {
    const size_t maxlen = KWSYS_SYSTEMTOOLS_MAXPATH;
    snprintf(resolved_path, maxlen, "%s", path);
    BPath normalized(resolved_path, nullptr, true);
    const char* resolved = normalized.Path();
    if (resolved != nullptr) // nullptr == No such file.
    {
      if (snprintf(resolved_path, maxlen, "%s", resolved) < maxlen) {
        return resolved_path;
      }
    }
    return nullptr; // something went wrong.
  }
  #endif
  
  #ifdef _WIN32
  static time_t windows_filetime_to_posix_time(const FILETIME& ft)
  {
    LARGE_INTEGER date;
    date.HighPart = ft.dwHighDateTime;
    date.LowPart = ft.dwLowDateTime;
  
    // removes the diff between 1970 and 1601
    date.QuadPart -= ((LONGLONG)(369 * 365 + 89) * 24 * 3600 * 10000000);
  
    // converts back from 100-nanoseconds to seconds
    return date.QuadPart / 10000000;
  }
  #endif
  
  #ifdef KWSYS_WINDOWS_DIRS
  #  include <wctype.h>
  
  inline int Mkdir(const std::string& dir)
  {
    return _wmkdir(
      KWSYS_NAMESPACE::Encoding::ToWindowsExtendedPath(dir).c_str());
  }
  inline int Rmdir(const std::string& dir)
  {
    return _wrmdir(
      KWSYS_NAMESPACE::Encoding::ToWindowsExtendedPath(dir).c_str());
  }
  inline const char* Getcwd(char* buf, unsigned int len)
  {
    std::vector<wchar_t> w_buf(len);
    if (_wgetcwd(&w_buf[0], len)) {
      size_t nlen = kwsysEncoding_wcstombs(buf, &w_buf[0], len);
      if (nlen == static_cast<size_t>(-1)) {
        return 0;
      }
      if (nlen < len) {
        // make sure the drive letter is capital
        if (nlen > 1 && buf[1] == ':') {
          buf[0] = toupper(buf[0]);
        }
        return buf;
      }
    }
    return 0;
  }
  inline int Chdir(const std::string& dir)
  {
  #  if defined(__BORLANDC__)
    return chdir(dir.c_str());
  #  else
    return _wchdir(KWSYS_NAMESPACE::Encoding::ToWide(dir).c_str());
  #  endif
  }
  inline void Realpath(const std::string& path, std::string& resolved_path,
                       std::string* errorMessage = 0)
  {
    std::wstring tmp = KWSYS_NAMESPACE::Encoding::ToWide(path);
    wchar_t* ptemp;
    wchar_t fullpath[MAX_PATH];
    DWORD bufferLen = GetFullPathNameW(
      tmp.c_str(), sizeof(fullpath) / sizeof(fullpath[0]), fullpath, &ptemp);
    if (bufferLen < sizeof(fullpath) / sizeof(fullpath[0])) {
      resolved_path = KWSYS_NAMESPACE::Encoding::ToNarrow(fullpath);
      KWSYS_NAMESPACE::SystemTools::ConvertToUnixSlashes(resolved_path);
    } else if (errorMessage) {
      if (bufferLen) {
        *errorMessage = "Destination path buffer size too small.";
      } else if (unsigned int errorId = GetLastError()) {
        LPSTR message = nullptr;
        DWORD size = FormatMessageA(
          FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM |
            FORMAT_MESSAGE_IGNORE_INSERTS,
          nullptr, errorId, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
          (LPSTR)&message, 0, nullptr);
        *errorMessage = std::string(message, size);
        LocalFree(message);
      } else {
        *errorMessage = "Unknown error.";
      }
  
      resolved_path = "";
    } else {
      resolved_path = path;
    }
  }
  #else
  #  include <sys/types.h>
  
  #  include <fcntl.h>
  #  include <unistd.h>
  inline int Mkdir(const std::string& dir)
  {
    return mkdir(dir.c_str(), 00777);
  }
  inline int Rmdir(const std::string& dir)
  {
    return rmdir(dir.c_str());
  }
  inline const char* Getcwd(char* buf, unsigned int len)
  {
    return getcwd(buf, len);
  }
  
  inline int Chdir(const std::string& dir)
  {
    return chdir(dir.c_str());
  }
  inline void Realpath(const std::string& path, std::string& resolved_path,
                       std::string* errorMessage = nullptr)
  {
    char resolved_name[KWSYS_SYSTEMTOOLS_MAXPATH];
  
    errno = 0;
    char* ret = realpath(path.c_str(), resolved_name);
    if (ret) {
      resolved_path = ret;
    } else if (errorMessage) {
      if (errno) {
        *errorMessage = strerror(errno);
      } else {
        *errorMessage = "Unknown error.";
      }
  
      resolved_path = "";
    } else {
      // if path resolution fails, return what was passed in
      resolved_path = path;
    }
  }
  #endif
  
  #if !defined(_WIN32) && defined(__COMO__)
  // Hack for como strict mode to avoid defining _SVID_SOURCE or _BSD_SOURCE.
  extern "C" {
  extern FILE* popen(__const char* __command, __const char* __modes) __THROW;
  extern int pclose(FILE* __stream) __THROW;
  extern char* realpath(__const char* __restrict __name,
                        char* __restrict __resolved) __THROW;
  extern char* strdup(__const char* __s) __THROW;
  extern int putenv(char* __string) __THROW;
  }
  #endif
  
  namespace KWSYS_NAMESPACE {
  
  double SystemTools::GetTime(void)
  {
  #if defined(_WIN32) && !defined(__CYGWIN__)
    FILETIME ft;
    GetSystemTimeAsFileTime(&ft);
    return (429.4967296 * ft.dwHighDateTime + 0.0000001 * ft.dwLowDateTime -
            11644473600.0);
  #else
    struct timeval t;
    gettimeofday(&t, nullptr);
    return 1.0 * double(t.tv_sec) + 0.000001 * double(t.tv_usec);
  #endif
  }
  
  /* Type of character storing the environment.  */
  #if defined(_WIN32)
  typedef wchar_t envchar;
  #else
  typedef char envchar;
  #endif
  
  /* Order by environment key only (VAR from VAR=VALUE).  */
  struct kwsysEnvCompare
  {
    bool operator()(const envchar* l, const envchar* r) const
    {
  #if defined(_WIN32)
      const wchar_t* leq = wcschr(l, L'=');
      const wchar_t* req = wcschr(r, L'=');
      size_t llen = leq ? (leq - l) : wcslen(l);
      size_t rlen = req ? (req - r) : wcslen(r);
      if (llen == rlen) {
        return wcsncmp(l, r, llen) < 0;
      } else {
        return wcscmp(l, r) < 0;
      }
  #else
      const char* leq = strchr(l, '=');
      const char* req = strchr(r, '=');
      size_t llen = leq ? static_cast<size_t>(leq - l) : strlen(l);
      size_t rlen = req ? static_cast<size_t>(req - r) : strlen(r);
      if (llen == rlen) {
        return strncmp(l, r, llen) < 0;
      } else {
        return strcmp(l, r) < 0;
      }
  #endif
    }
  };
  
  class kwsysEnvSet : public std::set<const envchar*, kwsysEnvCompare>
  {
  public:
    class Free
    {
      const envchar* Env;
  
    public:
      Free(const envchar* env)
        : Env(env)
      {
      }
      ~Free() { free(const_cast<envchar*>(this->Env)); }
  
      Free(const Free&) = delete;
      Free& operator=(const Free&) = delete;
    };
  
    const envchar* Release(const envchar* env)
    {
      const envchar* old = nullptr;
      iterator i = this->find(env);
      if (i != this->end()) {
        old = *i;
        this->erase(i);
      }
      return old;
    }
  };
  
  #ifdef _WIN32
  struct SystemToolsPathCaseCmp
  {
    bool operator()(std::string const& l, std::string const& r) const
    {
  #  ifdef _MSC_VER
      return _stricmp(l.c_str(), r.c_str()) < 0;
  #  elif defined(__GNUC__)
      return strcasecmp(l.c_str(), r.c_str()) < 0;
  #  else
      return SystemTools::Strucmp(l.c_str(), r.c_str()) < 0;
  #  endif
    }
  };
  #endif
  
  /**
   * SystemTools static variables singleton class.
   */
  class SystemToolsStatic
  {
  public:
    typedef std::map<std::string, std::string> StringMap;
  #if KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP
    /**
     * Path translation table from dir to refdir
     * Each time 'dir' will be found it will be replace by 'refdir'
     */
    StringMap TranslationMap;
  #endif
  #ifdef _WIN32
    static std::string GetCasePathName(std::string const& pathIn);
    static std::string GetActualCaseForPathCached(std::string const& path);
    static const char* GetEnvBuffered(const char* key);
    std::map<std::string, std::string, SystemToolsPathCaseCmp> PathCaseMap;
    std::map<std::string, std::string> EnvMap;
  #endif
  #ifdef __CYGWIN__
    StringMap Cyg2Win32Map;
  #endif
  
    /**
     * Actual implementation of ReplaceString.
     */
    static void ReplaceString(std::string& source, const char* replace,
                              size_t replaceSize, const std::string& with);
  
    /**
     * Actual implementation of FileIsFullPath.
     */
    static bool FileIsFullPath(const char*, size_t);
  
    /**
     * Find a filename (file or directory) in the system PATH, with
     * optional extra paths.
     */
    static std::string FindName(
      const std::string& name,
      const std::vector<std::string>& path = std::vector<std::string>(),
      bool no_system_path = false);
  };
  
  #ifdef _WIN32
  std::string SystemToolsStatic::GetCasePathName(std::string const& pathIn)
  {
    std::string casePath;
  
    // First check if the file is relative. We don't fix relative paths since the
    // real case depends on the root directory and the given path fragment may
    // have meaning elsewhere in the project.
    if (!SystemTools::FileIsFullPath(pathIn)) {
      // This looks unnecessary, but it allows for the return value optimization
      // since all return paths return the same local variable.
      casePath = pathIn;
      return casePath;
    }
  
    std::vector<std::string> path_components;
    SystemTools::SplitPath(pathIn, path_components);
  
    // Start with root component.
    std::vector<std::string>::size_type idx = 0;
    casePath = path_components[idx++];
    // make sure drive letter is always upper case
    if (casePath.size() > 1 && casePath[1] == ':') {
      casePath[0] = toupper(casePath[0]);
    }
    const char* sep = "";
  
    // If network path, fill casePath with server/share so FindFirstFile
    // will work after that.  Maybe someday call other APIs to get
    // actual case of servers and shares.
    if (path_components.size() > 2 && path_components[0] == "//") {
      casePath += path_components[idx++];
      casePath += "/";
      casePath += path_components[idx++];
      sep = "/";
    }
  
    // Convert case of all components that exist.
    bool converting = true;
    for (; idx < path_components.size(); idx++) {
      casePath += sep;
      sep = "/";
  
      if (converting) {
        // If path component contains wildcards, we skip matching
        // because these filenames are not allowed on windows,
        // and we do not want to match a different file.
        if (path_components[idx].find('*') != std::string::npos ||
            path_components[idx].find('?') != std::string::npos) {
          converting = false;
        } else {
          std::string test_str = casePath;
          test_str += path_components[idx];
          WIN32_FIND_DATAW findData;
          HANDLE hFind =
            ::FindFirstFileW(Encoding::ToWide(test_str).c_str(), &findData);
          if (INVALID_HANDLE_VALUE != hFind) {
            path_components[idx] = Encoding::ToNarrow(findData.cFileName);
            ::FindClose(hFind);
          } else {
            converting = false;
          }
        }
      }
  
      casePath += path_components[idx];
    }
    return casePath;
  }
  
  std::string SystemToolsStatic::GetActualCaseForPathCached(std::string const& p)
  {
    // Check to see if actual case has already been called
    // for this path, and the result is stored in the PathCaseMap
    auto& pcm = SystemTools::Statics->PathCaseMap;
    {
      auto itr = pcm.find(p);
      if (itr != pcm.end()) {
        return itr->second;
      }
    }
    std::string casePath = SystemToolsStatic::GetCasePathName(p);
    if (casePath.size() <= MAX_PATH) {
      pcm[p] = casePath;
    }
    return casePath;
  }
  #endif
  
  // adds the elements of the env variable path to the arg passed in
  void SystemTools::GetPath(std::vector<std::string>& path, const char* env)
  {
    size_t const old_size = path.size();
  #if defined(_WIN32) && !defined(__CYGWIN__)
    const char pathSep = ';';
  #else
    const char pathSep = ':';
  #endif
    if (!env) {
      env = "PATH";
    }
    std::string pathEnv;
    if (!SystemTools::GetEnv(env, pathEnv)) {
      return;
    }
  
    // A hack to make the below algorithm work.
    if (!pathEnv.empty() && pathEnv.back() != pathSep) {
      pathEnv += pathSep;
    }
    std::string::size_type start = 0;
    bool done = false;
    while (!done) {
      std::string::size_type endpos = pathEnv.find(pathSep, start);
      if (endpos != std::string::npos) {
        path.push_back(pathEnv.substr(start, endpos - start));
        start = endpos + 1;
      } else {
        done = true;
      }
    }
    for (std::vector<std::string>::iterator i = path.begin() + old_size;
         i != path.end(); ++i) {
      SystemTools::ConvertToUnixSlashes(*i);
    }
  }
  
  #if defined(_WIN32)
  const char* SystemToolsStatic::GetEnvBuffered(const char* key)
  {
    std::string env;
    if (SystemTools::GetEnv(key, env)) {
      std::string& menv = SystemTools::Statics->EnvMap[key];
      if (menv != env) {
        menv = std::move(env);
      }
      return menv.c_str();
    }
    return nullptr;
  }
  #endif
  
  const char* SystemTools::GetEnv(const char* key)
  {
  #if defined(_WIN32)
    return SystemToolsStatic::GetEnvBuffered(key);
  #else
    return getenv(key);
  #endif
  }
  
  const char* SystemTools::GetEnv(const std::string& key)
  {
  #if defined(_WIN32)
    return SystemToolsStatic::GetEnvBuffered(key.c_str());
  #else
    return getenv(key.c_str());
  #endif
  }
  
  bool SystemTools::GetEnv(const char* key, std::string& result)
  {
  #if defined(_WIN32)
    const std::wstring wkey = Encoding::ToWide(key);
    const wchar_t* wv = _wgetenv(wkey.c_str());
    if (wv) {
      result = Encoding::ToNarrow(wv);
      return true;
    }
  #else
    const char* v = getenv(key);
    if (v) {
      result = v;
      return true;
    }
  #endif
    return false;
  }
  
  bool SystemTools::GetEnv(const std::string& key, std::string& result)
  {
    return SystemTools::GetEnv(key.c_str(), result);
  }
  
  bool SystemTools::HasEnv(const char* key)
  {
  #if defined(_WIN32)
    const std::wstring wkey = Encoding::ToWide(key);
    const wchar_t* v = _wgetenv(wkey.c_str());
  #else
    const char* v = getenv(key);
  #endif
    return v != nullptr;
  }
  
  bool SystemTools::HasEnv(const std::string& key)
  {
    return SystemTools::HasEnv(key.c_str());
  }
  
  #if KWSYS_CXX_HAS_UNSETENV
  /* unsetenv("A") removes A from the environment.
     On older platforms it returns void instead of int.  */
  static int kwsysUnPutEnv(const std::string& env)
  {
    size_t pos = env.find('=');
    if (pos != std::string::npos) {
      std::string name = env.substr(0, pos);
      unsetenv(name.c_str());
    } else {
      unsetenv(env.c_str());
    }
    return 0;
  }
  
  #elif defined(__CYGWIN__) || defined(__GLIBC__)
  /* putenv("A") removes A from the environment.  It must not put the
     memory in the environment because it does not have any "=" syntax.  */
  static int kwsysUnPutEnv(const std::string& env)
  {
    int err = 0;
    size_t pos = env.find('=');
    size_t const len = pos == std::string::npos ? env.size() : pos;
    size_t const sz = len + 1;
    char local_buf[256];
    char* buf = sz > sizeof(local_buf) ? (char*)malloc(sz) : local_buf;
    if (!buf) {
      return -1;
    }
    strncpy(buf, env.c_str(), len);
    buf[len] = 0;
    if (putenv(buf) < 0 && errno != EINVAL) {
      err = errno;
    }
    if (buf != local_buf) {
      free(buf);
    }
    if (err) {
      errno = err;
      return -1;
    }
    return 0;
  }
  
  #elif defined(_WIN32)
  /* putenv("A=") places "A=" in the environment, which is as close to
     removal as we can get with the putenv API.  We have to leak the
     most recent value placed in the environment for each variable name
     on program exit in case exit routines access it.  */
  
  static kwsysEnvSet kwsysUnPutEnvSet;
  
  static int kwsysUnPutEnv(std::string const& env)
  {
    std::wstring wEnv = Encoding::ToWide(env);
    size_t const pos = wEnv.find('=');
    size_t const len = pos == std::string::npos ? wEnv.size() : pos;
    wEnv.resize(len + 1, L'=');
    wchar_t* newEnv = _wcsdup(wEnv.c_str());
    if (!newEnv) {
      return -1;
    }
    kwsysEnvSet::Free oldEnv(kwsysUnPutEnvSet.Release(newEnv));
    kwsysUnPutEnvSet.insert(newEnv);
    return _wputenv(newEnv);
  }
  
  #else
  /* Manipulate the "environ" global directly.  */
  static int kwsysUnPutEnv(const std::string& env)
  {
    size_t pos = env.find('=');
    size_t const len = pos == std::string::npos ? env.size() : pos;
    int in = 0;
    int out = 0;
    while (environ[in]) {
      if (strlen(environ[in]) > len && environ[in][len] == '=' &&
          strncmp(env.c_str(), environ[in], len) == 0) {
        ++in;
      } else {
        environ[out++] = environ[in++];
      }
    }
    while (out < in) {
      environ[out++] = 0;
    }
    return 0;
  }
  #endif
  
  #if KWSYS_CXX_HAS_SETENV
  
  /* setenv("A", "B", 1) will set A=B in the environment and makes its
     own copies of the strings.  */
  bool SystemTools::PutEnv(const std::string& env)
  {
    size_t pos = env.find('=');
    if (pos != std::string::npos) {
      std::string name = env.substr(0, pos);
      return setenv(name.c_str(), env.c_str() + pos + 1, 1) == 0;
    } else {
      return kwsysUnPutEnv(env) == 0;
    }
  }
  
  bool SystemTools::UnPutEnv(const std::string& env)
  {
    return kwsysUnPutEnv(env) == 0;
  }
  
  #else
  
  /* putenv("A=B") will set A=B in the environment.  Most putenv implementations
     put their argument directly in the environment.  They never free the memory
     on program exit.  Keep an active set of pointers to memory we allocate and
     pass to putenv, one per environment key.  At program exit remove any
     environment values that may still reference memory we allocated.  Then free
     the memory.  This will not affect any environment values we never set.  */
  
  #  ifdef __INTEL_COMPILER
  #    pragma warning disable 444 /* base has non-virtual destructor */
  #  endif
  
  class kwsysEnv : public kwsysEnvSet
  {
  public:
    ~kwsysEnv()
    {
      for (iterator i = this->begin(); i != this->end(); ++i) {
  #  if defined(_WIN32)
        const std::string s = Encoding::ToNarrow(*i);
        kwsysUnPutEnv(s);
  #  else
        kwsysUnPutEnv(*i);
  #  endif
        free(const_cast<envchar*>(*i));
      }
    }
    bool Put(const char* env)
    {
  #  if defined(_WIN32)
      const std::wstring wEnv = Encoding::ToWide(env);
      wchar_t* newEnv = _wcsdup(wEnv.c_str());
  #  else
      char* newEnv = strdup(env);
  #  endif
      Free oldEnv(this->Release(newEnv));
      this->insert(newEnv);
  #  if defined(_WIN32)
      return _wputenv(newEnv) == 0;
  #  else
      return putenv(newEnv) == 0;
  #  endif
    }
    bool UnPut(const char* env)
    {
  #  if defined(_WIN32)
      const std::wstring wEnv = Encoding::ToWide(env);
      Free oldEnv(this->Release(wEnv.c_str()));
  #  else
      Free oldEnv(this->Release(env));
  #  endif
      return kwsysUnPutEnv(env) == 0;
    }
  };
  
  static kwsysEnv kwsysEnvInstance;
  
  bool SystemTools::PutEnv(const std::string& env)
  {
    return kwsysEnvInstance.Put(env.c_str());
  }
  
  bool SystemTools::UnPutEnv(const std::string& env)
  {
    return kwsysEnvInstance.UnPut(env.c_str());
  }
  
  #endif
  
  const char* SystemTools::GetExecutableExtension()
  {
  #if defined(_WIN32) || defined(__CYGWIN__) || defined(__VMS)
    return ".exe";
  #else
    return "";
  #endif
  }
  
  FILE* SystemTools::Fopen(const std::string& file, const char* mode)
  {
  #ifdef _WIN32
    return _wfopen(Encoding::ToWindowsExtendedPath(file).c_str(),
                   Encoding::ToWide(mode).c_str());
  #else
    return fopen(file.c_str(), mode);
  #endif
  }
  
  bool SystemTools::MakeDirectory(const char* path, const mode_t* mode)
  {
    if (!path) {
      return false;
    }
    return SystemTools::MakeDirectory(std::string(path), mode);
  }
  
  bool SystemTools::MakeDirectory(const std::string& path, const mode_t* mode)
  {
    if (SystemTools::PathExists(path)) {
      return SystemTools::FileIsDirectory(path);
    }
    if (path.empty()) {
      return false;
    }
    std::string dir = path;
    SystemTools::ConvertToUnixSlashes(dir);
  
    std::string::size_type pos = 0;
    std::string topdir;
    while ((pos = dir.find('/', pos)) != std::string::npos) {
      topdir = dir.substr(0, pos);
  
      if (Mkdir(topdir) == 0 && mode != nullptr) {
        SystemTools::SetPermissions(topdir, *mode);
      }
  
      ++pos;
    }
    topdir = dir;
    if (Mkdir(topdir) != 0) {
      // There is a bug in the Borland Run time library which makes MKDIR
      // return EACCES when it should return EEXISTS
      // if it is some other error besides directory exists
      // then return false
      if ((errno != EEXIST)
  #ifdef __BORLANDC__
          && (errno != EACCES)
  #endif
      ) {
        return false;
      }
    } else if (mode != nullptr) {
      SystemTools::SetPermissions(topdir, *mode);
    }
  
    return true;
  }
  
  // replace replace with with as many times as it shows up in source.
  // write the result into source.
  void SystemTools::ReplaceString(std::string& source,
                                  const std::string& replace,
                                  const std::string& with)
  {
    // do while hangs if replaceSize is 0
    if (replace.empty()) {
      return;
    }
  
    SystemToolsStatic::ReplaceString(source, replace.c_str(), replace.size(),
                                     with);
  }
  
  void SystemTools::ReplaceString(std::string& source, const char* replace,
                                  const char* with)
  {
    // do while hangs if replaceSize is 0
    if (!*replace) {
      return;
    }
  
    SystemToolsStatic::ReplaceString(source, replace, strlen(replace),
                                     with ? with : "");
  }
  
  void SystemToolsStatic::ReplaceString(std::string& source, const char* replace,
                                        size_t replaceSize,
                                        const std::string& with)
  {
    const char* src = source.c_str();
    char* searchPos = const_cast<char*>(strstr(src, replace));
  
    // get out quick if string is not found
    if (!searchPos) {
      return;
    }
  
    // perform replacements until done
    char* orig = strdup(src);
    char* currentPos = orig;
    searchPos = searchPos - src + orig;
  
    // initialize the result
    source.erase(source.begin(), source.end());
    do {
      *searchPos = '\0';
      source += currentPos;
      currentPos = searchPos + replaceSize;
      // replace
      source += with;
      searchPos = strstr(currentPos, replace);
    } while (searchPos);
  
    // copy any trailing text
    source += currentPos;
    free(orig);
  }
  
  #if defined(_WIN32) && !defined(__CYGWIN__)
  
  #  if defined(KEY_WOW64_32KEY) && defined(KEY_WOW64_64KEY)
  #    define KWSYS_ST_KEY_WOW64_32KEY KEY_WOW64_32KEY
  #    define KWSYS_ST_KEY_WOW64_64KEY KEY_WOW64_64KEY
  #  else
  #    define KWSYS_ST_KEY_WOW64_32KEY 0x0200
  #    define KWSYS_ST_KEY_WOW64_64KEY 0x0100
  #  endif
  
  static bool SystemToolsParseRegistryKey(const std::string& key,
                                          HKEY& primaryKey, std::string& second,
                                          std::string& valuename)
  {
    std::string primary = key;
  
    size_t start = primary.find('\\');
    if (start == std::string::npos) {
      return false;
    }
  
    size_t valuenamepos = primary.find(';');
    if (valuenamepos != std::string::npos) {
      valuename = primary.substr(valuenamepos + 1);
    }
  
    second = primary.substr(start + 1, valuenamepos - start - 1);
    primary = primary.substr(0, start);
  
    if (primary == "HKEY_CURRENT_USER") {
      primaryKey = HKEY_CURRENT_USER;
    }
    if (primary == "HKEY_CURRENT_CONFIG") {
      primaryKey = HKEY_CURRENT_CONFIG;
    }
    if (primary == "HKEY_CLASSES_ROOT") {
      primaryKey = HKEY_CLASSES_ROOT;
    }
    if (primary == "HKEY_LOCAL_MACHINE") {
      primaryKey = HKEY_LOCAL_MACHINE;
    }
    if (primary == "HKEY_USERS") {
      primaryKey = HKEY_USERS;
    }
  
    return true;
  }
  
  static DWORD SystemToolsMakeRegistryMode(DWORD mode,
                                           SystemTools::KeyWOW64 view)
  {
    // only add the modes when on a system that supports Wow64.
    static FARPROC wow64p =
      GetProcAddress(GetModuleHandleW(L"kernel32"), "IsWow64Process");
    if (wow64p == nullptr) {
      return mode;
    }
  
    if (view == SystemTools::KeyWOW64_32) {
      return mode | KWSYS_ST_KEY_WOW64_32KEY;
    } else if (view == SystemTools::KeyWOW64_64) {
      return mode | KWSYS_ST_KEY_WOW64_64KEY;
    }
    return mode;
  }
  #endif
  
  #if defined(_WIN32) && !defined(__CYGWIN__)
  bool SystemTools::GetRegistrySubKeys(const std::string& key,
                                       std::vector<std::string>& subkeys,
                                       KeyWOW64 view)
  {
    HKEY primaryKey = HKEY_CURRENT_USER;
    std::string second;
    std::string valuename;
    if (!SystemToolsParseRegistryKey(key, primaryKey, second, valuename)) {
      return false;
    }
  
    HKEY hKey;
    if (RegOpenKeyExW(primaryKey, Encoding::ToWide(second).c_str(), 0,
                      SystemToolsMakeRegistryMode(KEY_READ, view),
                      &hKey) != ERROR_SUCCESS) {
      return false;
    } else {
      wchar_t name[1024];
      DWORD dwNameSize = sizeof(name) / sizeof(name[0]);
  
      DWORD i = 0;
      while (RegEnumKeyW(hKey, i, name, dwNameSize) == ERROR_SUCCESS) {
        subkeys.push_back(Encoding::ToNarrow(name));
        ++i;
      }
  
      RegCloseKey(hKey);
    }
  
    return true;
  }
  #else
  bool SystemTools::GetRegistrySubKeys(const std::string&,
                                       std::vector<std::string>&, KeyWOW64)
  {
    return false;
  }
  #endif
  
  // Read a registry value.
  // Example :
  //      HKEY_LOCAL_MACHINE\SOFTWARE\Python\PythonCore\2.1\InstallPath
  //      =>  will return the data of the "default" value of the key
  //      HKEY_LOCAL_MACHINE\SOFTWARE\Scriptics\Tcl\8.4;Root
  //      =>  will return the data of the "Root" value of the key
  
  #if defined(_WIN32) && !defined(__CYGWIN__)
  bool SystemTools::ReadRegistryValue(const std::string& key, std::string& value,
                                      KeyWOW64 view)
  {
    bool valueset = false;
    HKEY primaryKey = HKEY_CURRENT_USER;
    std::string second;
    std::string valuename;
    if (!SystemToolsParseRegistryKey(key, primaryKey, second, valuename)) {
      return false;
    }
  
    HKEY hKey;
    if (RegOpenKeyExW(primaryKey, Encoding::ToWide(second).c_str(), 0,
                      SystemToolsMakeRegistryMode(KEY_READ, view),
                      &hKey) != ERROR_SUCCESS) {
      return false;
    } else {
      DWORD dwType, dwSize;
      dwSize = 1023;
      wchar_t data[1024];
      if (RegQueryValueExW(hKey, Encoding::ToWide(valuename).c_str(), nullptr,
                           &dwType, (BYTE*)data, &dwSize) == ERROR_SUCCESS) {
        if (dwType == REG_SZ) {
          value = Encoding::ToNarrow(data);
          valueset = true;
        } else if (dwType == REG_EXPAND_SZ) {
          wchar_t expanded[1024];
          DWORD dwExpandedSize = sizeof(expanded) / sizeof(expanded[0]);
          if (ExpandEnvironmentStringsW(data, expanded, dwExpandedSize)) {
            value = Encoding::ToNarrow(expanded);
            valueset = true;
          }
        }
      }
  
      RegCloseKey(hKey);
    }
  
    return valueset;
  }
  #else
  bool SystemTools::ReadRegistryValue(const std::string&, std::string&, KeyWOW64)
  {
    return false;
  }
  #endif
  
  // Write a registry value.
  // Example :
  //      HKEY_LOCAL_MACHINE\SOFTWARE\Python\PythonCore\2.1\InstallPath
  //      =>  will set the data of the "default" value of the key
  //      HKEY_LOCAL_MACHINE\SOFTWARE\Scriptics\Tcl\8.4;Root
  //      =>  will set the data of the "Root" value of the key
  
  #if defined(_WIN32) && !defined(__CYGWIN__)
  bool SystemTools::WriteRegistryValue(const std::string& key,
                                       const std::string& value, KeyWOW64 view)
  {
    HKEY primaryKey = HKEY_CURRENT_USER;
    std::string second;
    std::string valuename;
    if (!SystemToolsParseRegistryKey(key, primaryKey, second, valuename)) {
      return false;
    }
  
    HKEY hKey;
    DWORD dwDummy;
    wchar_t lpClass[] = L"";
    if (RegCreateKeyExW(primaryKey, Encoding::ToWide(second).c_str(), 0, lpClass,
                        REG_OPTION_NON_VOLATILE,
                        SystemToolsMakeRegistryMode(KEY_WRITE, view), nullptr,
                        &hKey, &dwDummy) != ERROR_SUCCESS) {
      return false;
    }
  
    std::wstring wvalue = Encoding::ToWide(value);
    if (RegSetValueExW(hKey, Encoding::ToWide(valuename).c_str(), 0, REG_SZ,
                       (CONST BYTE*)wvalue.c_str(),
                       (DWORD)(sizeof(wchar_t) * (wvalue.size() + 1))) ==
        ERROR_SUCCESS) {
      return true;
    }
    return false;
  }
  #else
  bool SystemTools::WriteRegistryValue(const std::string&, const std::string&,
                                       KeyWOW64)
  {
    return false;
  }
  #endif
  
  // Delete a registry value.
  // Example :
  //      HKEY_LOCAL_MACHINE\SOFTWARE\Python\PythonCore\2.1\InstallPath
  //      =>  will delete the data of the "default" value of the key
  //      HKEY_LOCAL_MACHINE\SOFTWARE\Scriptics\Tcl\8.4;Root
  //      =>  will delete the data of the "Root" value of the key
  
  #if defined(_WIN32) && !defined(__CYGWIN__)
  bool SystemTools::DeleteRegistryValue(const std::string& key, KeyWOW64 view)
  {
    HKEY primaryKey = HKEY_CURRENT_USER;
    std::string second;
    std::string valuename;
    if (!SystemToolsParseRegistryKey(key, primaryKey, second, valuename)) {
      return false;
    }
  
    HKEY hKey;
    if (RegOpenKeyExW(primaryKey, Encoding::ToWide(second).c_str(), 0,
                      SystemToolsMakeRegistryMode(KEY_WRITE, view),
                      &hKey) != ERROR_SUCCESS) {
      return false;
    } else {
      if (RegDeleteValue(hKey, (LPTSTR)valuename.c_str()) == ERROR_SUCCESS) {
        RegCloseKey(hKey);
        return true;
      }
    }
    return false;
  }
  #else
  bool SystemTools::DeleteRegistryValue(const std::string&, KeyWOW64)
  {
    return false;
  }
  #endif
  
  bool SystemTools::SameFile(const std::string& file1, const std::string& file2)
  {
  #ifdef _WIN32
    HANDLE hFile1, hFile2;
  
    hFile1 =
      CreateFileW(Encoding::ToWide(file1).c_str(), GENERIC_READ, FILE_SHARE_READ,
                  nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr);
    hFile2 =
      CreateFileW(Encoding::ToWide(file2).c_str(), GENERIC_READ, FILE_SHARE_READ,
                  nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr);
    if (hFile1 == INVALID_HANDLE_VALUE || hFile2 == INVALID_HANDLE_VALUE) {
      if (hFile1 != INVALID_HANDLE_VALUE) {
        CloseHandle(hFile1);
      }
      if (hFile2 != INVALID_HANDLE_VALUE) {
        CloseHandle(hFile2);
      }
      return false;
    }
  
    BY_HANDLE_FILE_INFORMATION fiBuf1;
    BY_HANDLE_FILE_INFORMATION fiBuf2;
    GetFileInformationByHandle(hFile1, &fiBuf1);
    GetFileInformationByHandle(hFile2, &fiBuf2);
    CloseHandle(hFile1);
    CloseHandle(hFile2);
    return (fiBuf1.dwVolumeSerialNumber == fiBuf2.dwVolumeSerialNumber &&
            fiBuf1.nFileIndexHigh == fiBuf2.nFileIndexHigh &&
            fiBuf1.nFileIndexLow == fiBuf2.nFileIndexLow);
  #else
    struct stat fileStat1, fileStat2;
    if (stat(file1.c_str(), &fileStat1) == 0 &&
        stat(file2.c_str(), &fileStat2) == 0) {
      // see if the files are the same file
      // check the device inode and size
      if (memcmp(&fileStat2.st_dev, &fileStat1.st_dev,
                 sizeof(fileStat1.st_dev)) == 0 &&
          memcmp(&fileStat2.st_ino, &fileStat1.st_ino,
                 sizeof(fileStat1.st_ino)) == 0 &&
          fileStat2.st_size == fileStat1.st_size) {
        return true;
      }
    }
    return false;
  #endif
  }
  
  bool SystemTools::PathExists(const std::string& path)
  {
    if (path.empty()) {
      return false;
    }
  #if defined(__CYGWIN__)
    // Convert path to native windows path if possible.
    char winpath[MAX_PATH];
    if (SystemTools::PathCygwinToWin32(path.c_str(), winpath)) {
      return (GetFileAttributesA(winpath) != INVALID_FILE_ATTRIBUTES);
    }
    struct stat st;
    return lstat(path.c_str(), &st) == 0;
  #elif defined(_WIN32)
    return (GetFileAttributesW(Encoding::ToWindowsExtendedPath(path).c_str()) !=
            INVALID_FILE_ATTRIBUTES);
  #else
    struct stat st;
    return lstat(path.c_str(), &st) == 0;
  #endif
  }
  
  bool SystemTools::FileExists(const char* filename)
  {
    if (!filename) {
      return false;
    }
    return SystemTools::FileExists(std::string(filename));
  }
  
  bool SystemTools::FileExists(const std::string& filename)
  {
    if (filename.empty()) {
      return false;
    }
  #if defined(__CYGWIN__)
    // Convert filename to native windows path if possible.
    char winpath[MAX_PATH];
    if (SystemTools::PathCygwinToWin32(filename.c_str(), winpath)) {
      return (GetFileAttributesA(winpath) != INVALID_FILE_ATTRIBUTES);
    }
    return access(filename.c_str(), R_OK) == 0;
  #elif defined(_WIN32)
    DWORD attr =
      GetFileAttributesW(Encoding::ToWindowsExtendedPath(filename).c_str());
    if (attr == INVALID_FILE_ATTRIBUTES) {
      return false;
    }
  
    if (attr & FILE_ATTRIBUTE_REPARSE_POINT) {
      // Using 0 instead of GENERIC_READ as it allows reading of file attributes
      // even if we do not have permission to read the file itself
      HANDLE handle =
        CreateFileW(Encoding::ToWindowsExtendedPath(filename).c_str(), 0, 0,
                    nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr);
  
      if (handle == INVALID_HANDLE_VALUE) {
        return false;
      }
  
      CloseHandle(handle);
    }
  
    return true;
  #else
  // SCO OpenServer 5.0.7/3.2's command has 711 permission.
  #  if defined(_SCO_DS)
    return access(filename.c_str(), F_OK) == 0;
  #  else
    return access(filename.c_str(), R_OK) == 0;
  #  endif
  #endif
  }
  
  bool SystemTools::FileExists(const char* filename, bool isFile)
  {
    if (!filename) {
      return false;
    }
    return SystemTools::FileExists(std::string(filename), isFile);
  }
  
  bool SystemTools::FileExists(const std::string& filename, bool isFile)
  {
    if (SystemTools::FileExists(filename)) {
      // If isFile is set return not FileIsDirectory,
      // so this will only be true if it is a file
      return !isFile || !SystemTools::FileIsDirectory(filename);
    }
    return false;
  }
  
  bool SystemTools::TestFileAccess(const char* filename,
                                   TestFilePermissions permissions)
  {
    if (!filename) {
      return false;
    }
    return SystemTools::TestFileAccess(std::string(filename), permissions);
  }
  
  bool SystemTools::TestFileAccess(const std::string& filename,
                                   TestFilePermissions permissions)
  {
    if (filename.empty()) {
      return false;
    }
  #if defined(_WIN32) && !defined(__CYGWIN__)
    // If execute set, change to read permission (all files on Windows
    // are executable if they are readable).  The CRT will always fail
    // if you pass an execute bit.
    if (permissions & TEST_FILE_EXECUTE) {
      permissions &= ~TEST_FILE_EXECUTE;
      permissions |= TEST_FILE_READ;
    }
    return _waccess(Encoding::ToWindowsExtendedPath(filename).c_str(),
                    permissions) == 0;
  #else
    return access(filename.c_str(), permissions) == 0;
  #endif
  }
  
  int SystemTools::Stat(const char* path, SystemTools::Stat_t* buf)
  {
    if (!path) {
      errno = EFAULT;
      return -1;
    }
    return SystemTools::Stat(std::string(path), buf);
  }
  
  int SystemTools::Stat(const std::string& path, SystemTools::Stat_t* buf)
  {
    if (path.empty()) {
      errno = ENOENT;
      return -1;
    }
  #if defined(_WIN32) && !defined(__CYGWIN__)
    // Ideally we should use Encoding::ToWindowsExtendedPath to support
    // long paths, but _wstat64 rejects paths with '?' in them, thinking
    // they are wildcards.
    std::wstring const& wpath = Encoding::ToWide(path);
  #  if defined(__BORLANDC__)
    return _wstati64(wpath.c_str(), buf);
  #  else
    return _wstat64(wpath.c_str(), buf);
  #  endif
  #else
    return stat(path.c_str(), buf);
  #endif
  }
  
  #ifdef __CYGWIN__
  bool SystemTools::PathCygwinToWin32(const char* path, char* win32_path)
  {
    auto itr = SystemTools::Statics->Cyg2Win32Map.find(path);
    if (itr != SystemTools::Statics->Cyg2Win32Map.end()) {
      strncpy(win32_path, itr->second.c_str(), MAX_PATH);
    } else {
      if (cygwin_conv_path(CCP_POSIX_TO_WIN_A, path, win32_path, MAX_PATH) !=
          0) {
        win32_path[0] = 0;
      }
      SystemTools::Statics->Cyg2Win32Map.insert(
        SystemToolsStatic::StringMap::value_type(path, win32_path));
    }
    return win32_path[0] != 0;
  }
  #endif
  
  bool SystemTools::Touch(const std::string& filename, bool create)
  {
    if (!SystemTools::PathExists(filename)) {
      if (create) {
        FILE* file = Fopen(filename, "a+b");
        if (file) {
          fclose(file);
          return true;
        }
        return false;
      } else {
        return true;
      }
    }
  #if defined(_WIN32) && !defined(__CYGWIN__)
    HANDLE h = CreateFileW(Encoding::ToWindowsExtendedPath(filename).c_str(),
                           FILE_WRITE_ATTRIBUTES, FILE_SHARE_WRITE, 0,
                           OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0);
    if (!h) {
      return false;
    }
    FILETIME mtime;
    GetSystemTimeAsFileTime(&mtime);
    if (!SetFileTime(h, 0, 0, &mtime)) {
      CloseHandle(h);
      return false;
    }
    CloseHandle(h);
  #elif KWSYS_CXX_HAS_UTIMENSAT
    // utimensat is only available on newer Unixes and macOS 10.13+
    if (utimensat(AT_FDCWD, filename.c_str(), nullptr, 0) < 0) {
      return false;
    }
  #else
    // fall back to utimes
    if (utimes(filename.c_str(), nullptr) < 0) {
      return false;
    }
  #endif
    return true;
  }
  
  bool SystemTools::FileTimeCompare(const std::string& f1, const std::string& f2,
                                    int* result)
  {
    // Default to same time.
    *result = 0;
  #if !defined(_WIN32) || defined(__CYGWIN__)
    // POSIX version.  Use stat function to get file modification time.
    struct stat s1;
    if (stat(f1.c_str(), &s1) != 0) {
      return false;
    }
    struct stat s2;
    if (stat(f2.c_str(), &s2) != 0) {
      return false;
    }
  #  if KWSYS_CXX_STAT_HAS_ST_MTIM
    // Compare using nanosecond resolution.
    if (s1.st_mtim.tv_sec < s2.st_mtim.tv_sec) {
      *result = -1;
    } else if (s1.st_mtim.tv_sec > s2.st_mtim.tv_sec) {
      *result = 1;
    } else if (s1.st_mtim.tv_nsec < s2.st_mtim.tv_nsec) {
      *result = -1;
    } else if (s1.st_mtim.tv_nsec > s2.st_mtim.tv_nsec) {
      *result = 1;
    }
  #  elif KWSYS_CXX_STAT_HAS_ST_MTIMESPEC
    // Compare using nanosecond resolution.
    if (s1.st_mtimespec.tv_sec < s2.st_mtimespec.tv_sec) {
      *result = -1;
    } else if (s1.st_mtimespec.tv_sec > s2.st_mtimespec.tv_sec) {
      *result = 1;
    } else if (s1.st_mtimespec.tv_nsec < s2.st_mtimespec.tv_nsec) {
      *result = -1;
    } else if (s1.st_mtimespec.tv_nsec > s2.st_mtimespec.tv_nsec) {
      *result = 1;
    }
  #  else
    // Compare using 1 second resolution.
    if (s1.st_mtime < s2.st_mtime) {
      *result = -1;
    } else if (s1.st_mtime > s2.st_mtime) {
      *result = 1;
    }
  #  endif
  #else
    // Windows version.  Get the modification time from extended file attributes.
    WIN32_FILE_ATTRIBUTE_DATA f1d;
    WIN32_FILE_ATTRIBUTE_DATA f2d;
    if (!GetFileAttributesExW(Encoding::ToWindowsExtendedPath(f1).c_str(),
                              GetFileExInfoStandard, &f1d)) {
      return false;
    }
    if (!GetFileAttributesExW(Encoding::ToWindowsExtendedPath(f2).c_str(),
                              GetFileExInfoStandard, &f2d)) {
      return false;
    }
  
    // Compare the file times using resolution provided by system call.
    *result = (int)CompareFileTime(&f1d.ftLastWriteTime, &f2d.ftLastWriteTime);
  #endif
    return true;
  }
  
  // Return a capitalized string (i.e the first letter is uppercased, all other
  // are lowercased)
  std::string SystemTools::Capitalized(const std::string& s)
  {
    std::string n;
    if (s.empty()) {
      return n;
    }
    n.resize(s.size());
    n[0] = static_cast<std::string::value_type>(toupper(s[0]));
    for (size_t i = 1; i < s.size(); i++) {
      n[i] = static_cast<std::string::value_type>(tolower(s[i]));
    }
    return n;
  }
  
  // Return capitalized words
  std::string SystemTools::CapitalizedWords(const std::string& s)
  {
    std::string n(s);
    for (size_t i = 0; i < s.size(); i++) {
  #if defined(_MSC_VER) && defined(_MT) && defined(_DEBUG)
      // MS has an assert that will fail if s[i] < 0; setting
      // LC_CTYPE using setlocale() does *not* help. Painful.
      if ((int)s[i] >= 0 && isalpha(s[i]) &&
          (i == 0 || ((int)s[i - 1] >= 0 && isspace(s[i - 1]))))
  #else
      if (isalpha(s[i]) && (i == 0 || isspace(s[i - 1])))
  #endif
      {
        n[i] = static_cast<std::string::value_type>(toupper(s[i]));
      }
    }
    return n;
  }
  
  // Return uncapitalized words
  std::string SystemTools::UnCapitalizedWords(const std::string& s)
  {
    std::string n(s);
    for (size_t i = 0; i < s.size(); i++) {
  #if defined(_MSC_VER) && defined(_MT) && defined(_DEBUG)
      // MS has an assert that will fail if s[i] < 0; setting
      // LC_CTYPE using setlocale() does *not* help. Painful.
      if ((int)s[i] >= 0 && isalpha(s[i]) &&
          (i == 0 || ((int)s[i - 1] >= 0 && isspace(s[i - 1]))))
  #else
      if (isalpha(s[i]) && (i == 0 || isspace(s[i - 1])))
  #endif
      {
        n[i] = static_cast<std::string::value_type>(tolower(s[i]));
      }
    }
    return n;
  }
  
  // only works for words with at least two letters
  std::string SystemTools::AddSpaceBetweenCapitalizedWords(const std::string& s)
  {
    std::string n;
    if (!s.empty()) {
      n.reserve(s.size());
      n += s[0];
      for (size_t i = 1; i < s.size(); i++) {
        if (isupper(s[i]) && !isspace(s[i - 1]) && !isupper(s[i - 1])) {
          n += ' ';
        }
        n += s[i];
      }
    }
    return n;
  }
  
  char* SystemTools::AppendStrings(const char* str1, const char* str2)
  {
    if (!str1) {
      return SystemTools::DuplicateString(str2);
    }
    if (!str2) {
      return SystemTools::DuplicateString(str1);
    }
    size_t len1 = strlen(str1);
    char* newstr = new char[len1 + strlen(str2) + 1];
    if (!newstr) {
      return nullptr;
    }
    strcpy(newstr, str1);
    strcat(newstr + len1, str2);
    return newstr;
  }
  
  char* SystemTools::AppendStrings(const char* str1, const char* str2,
                                   const char* str3)
  {
    if (!str1) {
      return SystemTools::AppendStrings(str2, str3);
    }
    if (!str2) {
      return SystemTools::AppendStrings(str1, str3);
    }
    if (!str3) {
      return SystemTools::AppendStrings(str1, str2);
    }
  
    size_t len1 = strlen(str1), len2 = strlen(str2);
    char* newstr = new char[len1 + len2 + strlen(str3) + 1];
    if (!newstr) {
      return nullptr;
    }
    strcpy(newstr, str1);
    strcat(newstr + len1, str2);
    strcat(newstr + len1 + len2, str3);
    return newstr;
  }
  
  // Return a lower case string
  std::string SystemTools::LowerCase(const std::string& s)
  {
    std::string n;
    n.resize(s.size());
    for (size_t i = 0; i < s.size(); i++) {
      n[i] = static_cast<std::string::value_type>(tolower(s[i]));
    }
    return n;
  }
  
  // Return a lower case string
  std::string SystemTools::UpperCase(const std::string& s)
  {
    std::string n;
    n.resize(s.size());
    for (size_t i = 0; i < s.size(); i++) {
      n[i] = static_cast<std::string::value_type>(toupper(s[i]));
    }
    return n;
  }
  
  // Count char in string
  size_t SystemTools::CountChar(const char* str, char c)
  {
    size_t count = 0;
  
    if (str) {
      while (*str) {
        if (*str == c) {
          ++count;
        }
        ++str;
      }
    }
    return count;
  }
  
  // Remove chars in string
  char* SystemTools::RemoveChars(const char* str, const char* toremove)
  {
    if (!str) {
      return nullptr;
    }
    char* clean_str = new char[strlen(str) + 1];
    char* ptr = clean_str;
    while (*str) {
      const char* str2 = toremove;
      while (*str2 && *str != *str2) {
        ++str2;
      }
      if (!*str2) {
        *ptr++ = *str;
      }
      ++str;
    }
    *ptr = '\0';
    return clean_str;
  }
  
  // Remove chars in string
  char* SystemTools::RemoveCharsButUpperHex(const char* str)
  {
    if (!str) {
      return nullptr;
    }
    char* clean_str = new char[strlen(str) + 1];
    char* ptr = clean_str;
    while (*str) {
      if ((*str >= '0' && *str <= '9') || (*str >= 'A' && *str <= 'F')) {
        *ptr++ = *str;
      }
      ++str;
    }
    *ptr = '\0';
    return clean_str;
  }
  
  // Replace chars in string
  char* SystemTools::ReplaceChars(char* str, const char* toreplace,
                                  char replacement)
  {
    if (str) {
      char* ptr = str;
      while (*ptr) {
        const char* ptr2 = toreplace;
        while (*ptr2) {
          if (*ptr == *ptr2) {
            *ptr = replacement;
          }
          ++ptr2;
        }
        ++ptr;
      }
    }
    return str;
  }
  
  // Returns if string starts with another string
  bool SystemTools::StringStartsWith(const char* str1, const char* str2)
  {
    if (!str1 || !str2) {
      return false;
    }
    size_t len1 = strlen(str1), len2 = strlen(str2);
    return len1 >= len2 && !strncmp(str1, str2, len2) ? true : false;
  }
  
  // Returns if string starts with another string
  bool SystemTools::StringStartsWith(const std::string& str1, const char* str2)
  {
    if (!str2) {
      return false;
    }
    size_t len1 = str1.size(), len2 = strlen(str2);
    return len1 >= len2 && !strncmp(str1.c_str(), str2, len2) ? true : false;
  }
  
  // Returns if string ends with another string
  bool SystemTools::StringEndsWith(const char* str1, const char* str2)
  {
    if (!str1 || !str2) {
      return false;
    }
    size_t len1 = strlen(str1), len2 = strlen(str2);
    return len1 >= len2 && !strncmp(str1 + (len1 - len2), str2, len2) ? true
                                                                      : false;
  }
  
  // Returns if string ends with another string
  bool SystemTools::StringEndsWith(const std::string& str1, const char* str2)
  {
    if (!str2) {
      return false;
    }
    size_t len1 = str1.size(), len2 = strlen(str2);
    return len1 >= len2 && !strncmp(str1.c_str() + (len1 - len2), str2, len2)
      ? true
      : false;
  }
  
  // Returns a pointer to the last occurrence of str2 in str1
  const char* SystemTools::FindLastString(const char* str1, const char* str2)
  {
    if (!str1 || !str2) {
      return nullptr;
    }
  
    size_t len1 = strlen(str1), len2 = strlen(str2);
    if (len1 >= len2) {
      const char* ptr = str1 + len1 - len2;
      do {
        if (!strncmp(ptr, str2, len2)) {
          return ptr;
        }
      } while (ptr-- != str1);
    }
  
    return nullptr;
  }
  
  // Duplicate string
  char* SystemTools::DuplicateString(const char* str)
  {
    if (str) {
      char* newstr = new char[strlen(str) + 1];
      return strcpy(newstr, str);
    }
    return nullptr;
  }
  
  // Return a cropped string
  std::string SystemTools::CropString(const std::string& s, size_t max_len)
  {
    if (!s.size() || max_len == 0 || max_len >= s.size()) {
      return s;
    }
  
    std::string n;
    n.reserve(max_len);
  
    size_t middle = max_len / 2;
  
    n += s.substr(0, middle);
    n += s.substr(s.size() - (max_len - middle));
  
    if (max_len > 2) {
      n[middle] = '.';
      if (max_len > 3) {
        n[middle - 1] = '.';
        if (max_len > 4) {
          n[middle + 1] = '.';
        }
      }
    }
  
    return n;
  }
  
  std::vector<std::string> SystemTools::SplitString(const std::string& p,
                                                    char sep, bool isPath)
  {
    std::string path = p;
    std::vector<std::string> paths;
    if (path.empty()) {
      return paths;
    }
    if (isPath && path[0] == '/') {
      path.erase(path.begin());
      paths.push_back("/");
    }
    std::string::size_type pos1 = 0;
    std::string::size_type pos2 = path.find(sep, pos1 + 1);
    while (pos2 != std::string::npos) {
      paths.push_back(path.substr(pos1, pos2 - pos1));
      pos1 = pos2 + 1;
      pos2 = path.find(sep, pos1 + 1);
    }
    paths.push_back(path.substr(pos1, pos2 - pos1));
  
    return paths;
  }
  
  int SystemTools::EstimateFormatLength(const char* format, va_list ap)
  {
    if (!format) {
      return 0;
    }
  
    // Quick-hack attempt at estimating the length of the string.
    // Should never under-estimate.
  
    // Start with the length of the format string itself.
  
    size_t length = strlen(format);
  
    // Increase the length for every argument in the format.
  
    const char* cur = format;
    while (*cur) {
      if (*cur++ == '%') {
        // Skip "%%" since it doesn't correspond to a va_arg.
        if (*cur != '%') {
          while (!int(isalpha(*cur))) {
            ++cur;
          }
          switch (*cur) {
            case 's': {
              // Check the length of the string.
              char* s = va_arg(ap, char*);
              if (s) {
                length += strlen(s);
              }
            } break;
            case 'e':
            case 'f':
            case 'g': {
              // Assume the argument contributes no more than 64 characters.
              length += 64;
  
              // Eat the argument.
              static_cast<void>(va_arg(ap, double));
            } break;
            default: {
              // Assume the argument contributes no more than 64 characters.
              length += 64;
  
              // Eat the argument.
              static_cast<void>(va_arg(ap, int));
            } break;
          }
        }
  
        // Move past the characters just tested.
        ++cur;
      }
    }
  
    return static_cast<int>(length);
  }
  
  std::string SystemTools::EscapeChars(const char* str,
                                       const char* chars_to_escape,
                                       char escape_char)
  {
    std::string n;
    if (str) {
      if (!chars_to_escape || !*chars_to_escape) {
        n.append(str);
      } else {
        n.reserve(strlen(str));
        while (*str) {
          const char* ptr = chars_to_escape;
          while (*ptr) {
            if (*str == *ptr) {
              n += escape_char;
              break;
            }
            ++ptr;
          }
          n += *str;
          ++str;
        }
      }
    }
    return n;
  }
  
  #ifdef __VMS
  static void ConvertVMSToUnix(std::string& path)
  {
    std::string::size_type rootEnd = path.find(":[");
    std::string::size_type pathEnd = path.find("]");
    if (rootEnd != std::string::npos) {
      std::string root = path.substr(0, rootEnd);
      std::string pathPart = path.substr(rootEnd + 2, pathEnd - rootEnd - 2);
      const char* pathCString = pathPart.c_str();
      const char* pos0 = pathCString;
      for (std::string::size_type pos = 0; *pos0; ++pos) {
        if (*pos0 == '.') {
          pathPart[pos] = '/';
        }
        pos0++;
      }
      path = "/" + root + "/" + pathPart;
    }
  }
  #endif
  
  // convert windows slashes to unix slashes
  void SystemTools::ConvertToUnixSlashes(std::string& path)
  {
    if (path.empty()) {
      return;
    }
  
    const char* pathCString = path.c_str();
    bool hasDoubleSlash = false;
  #ifdef __VMS
    ConvertVMSToUnix(path);
  #else
    const char* pos0 = pathCString;
    for (std::string::size_type pos = 0; *pos0; ++pos) {
      if (*pos0 == '\\') {
        path[pos] = '/';
      }
  
      // Also, reuse the loop to check for slash followed by another slash
      if (!hasDoubleSlash && *(pos0 + 1) == '/' && *(pos0 + 2) == '/') {
  #  ifdef _WIN32
        // However, on windows if the first characters are both slashes,
        // then keep them that way, so that network paths can be handled.
        if (pos > 0) {
          hasDoubleSlash = true;
        }
  #  else
        hasDoubleSlash = true;
  #  endif
      }
  
      pos0++;
    }
  
    if (hasDoubleSlash) {
      SystemTools::ReplaceString(path, "//", "/");
    }
  #endif
  
    // remove any trailing slash
    // if there is a tilda ~ then replace it with HOME
    pathCString = path.c_str();
    if (pathCString[0] == '~' &&
        (pathCString[1] == '/' || pathCString[1] == '\0')) {
      std::string homeEnv;
      if (SystemTools::GetEnv("HOME", homeEnv)) {
        path.replace(0, 1, homeEnv);
      }
    }
  #ifdef HAVE_GETPWNAM
    else if (pathCString[0] == '~') {
      std::string::size_type idx = path.find_first_of("/\0");
      std::string user = path.substr(1, idx - 1);
      passwd* pw = getpwnam(user.c_str());
      if (pw) {
        path.replace(0, idx, pw->pw_dir);
      }
    }
  #endif
    // remove trailing slash if the path is more than
    // a single /
    pathCString = path.c_str();
    size_t size = path.size();
    if (size > 1 && path.back() == '/') {
      // if it is c:/ then do not remove the trailing slash
      if (!((size == 3 && pathCString[1] == ':'))) {
        path.resize(size - 1);
      }
    }
  }
  
  #ifdef _WIN32
  std::wstring SystemTools::ConvertToWindowsExtendedPath(
    const std::string& source)
  {
    return Encoding::ToWindowsExtendedPath(source);
  }
  #endif
  
  // change // to /, and escape any spaces in the path
  std::string SystemTools::ConvertToUnixOutputPath(const std::string& path)
  {
    std::string ret = path;
  
    // remove // except at the beginning might be a cygwin drive
    std::string::size_type pos = 1;
    while ((pos = ret.find("//", pos)) != std::string::npos) {
      ret.erase(pos, 1);
    }
    // escape spaces and () in the path
    if (ret.find_first_of(" ") != std::string::npos) {
      std::string result;
      char lastch = 1;
      for (const char* ch = ret.c_str(); *ch != '\0'; ++ch) {
        // if it is already escaped then don't try to escape it again
        if ((*ch == ' ') && lastch != '\\') {
          result += '\\';
        }
        result += *ch;
        lastch = *ch;
      }
      ret = result;
    }
    return ret;
  }
  
  std::string SystemTools::ConvertToOutputPath(const std::string& path)
  {
  #if defined(_WIN32) && !defined(__CYGWIN__)
    return SystemTools::ConvertToWindowsOutputPath(path);
  #else
    return SystemTools::ConvertToUnixOutputPath(path);
  #endif
  }
  
  // remove double slashes not at the start
  std::string SystemTools::ConvertToWindowsOutputPath(const std::string& path)
  {
    std::string ret;
    // make it big enough for all of path and double quotes
    ret.reserve(path.size() + 3);
    // put path into the string
    ret = path;
    std::string::size_type pos = 0;
    // first convert all of the slashes
    while ((pos = ret.find('/', pos)) != std::string::npos) {
      ret[pos] = '\\';
      pos++;
    }
    // check for really small paths
    if (ret.size() < 2) {
      return ret;
    }
    // now clean up a bit and remove double slashes
    // Only if it is not the first position in the path which is a network
    // path on windows
    pos = 1; // start at position 1
    if (ret[0] == '\"') {
      pos = 2; // if the string is already quoted then start at 2
      if (ret.size() < 3) {
        return ret;
      }
    }
    while ((pos = ret.find("\\\\", pos)) != std::string::npos) {
      ret.erase(pos, 1);
    }
    // now double quote the path if it has spaces in it
    // and is not already double quoted
    if (ret.find(' ') != std::string::npos && ret[0] != '\"') {
      ret.insert(static_cast<std::string::size_type>(0),
                 static_cast<std::string::size_type>(1), '\"');
      ret.append(1, '\"');
    }
    return ret;
  }
  
  /**
   * Append the filename from the path source to the directory name dir.
   */
  static std::string FileInDir(const std::string& source, const std::string& dir)
  {
    std::string new_destination = dir;
    SystemTools::ConvertToUnixSlashes(new_destination);
    return new_destination + '/' + SystemTools::GetFilenameName(source);
  }
  
  bool SystemTools::CopyFileIfDifferent(const std::string& source,
                                        const std::string& destination)
  {
    // special check for a destination that is a directory
    // FilesDiffer does not handle file to directory compare
    if (SystemTools::FileIsDirectory(destination)) {
      const std::string new_destination = FileInDir(source, destination);
      if (!SystemTools::ComparePath(new_destination, destination)) {
        return SystemTools::CopyFileIfDifferent(source, new_destination);
      }
    } else {
      // source and destination are files so do a copy if they
      // are different
      if (SystemTools::FilesDiffer(source, destination)) {
        return SystemTools::CopyFileAlways(source, destination);
      }
    }
    // at this point the files must be the same so return true
    return true;
  }
  
  #define KWSYS_ST_BUFFER 4096
  
  bool SystemTools::FilesDiffer(const std::string& source,
                                const std::string& destination)
  {
  
  #if defined(_WIN32)
    WIN32_FILE_ATTRIBUTE_DATA statSource;
    if (GetFileAttributesExW(Encoding::ToWindowsExtendedPath(source).c_str(),
                             GetFileExInfoStandard, &statSource) == 0) {
      return true;
    }
  
    WIN32_FILE_ATTRIBUTE_DATA statDestination;
    if (GetFileAttributesExW(
          Encoding::ToWindowsExtendedPath(destination).c_str(),
          GetFileExInfoStandard, &statDestination) == 0) {
      return true;
    }
  
    if (statSource.nFileSizeHigh != statDestination.nFileSizeHigh ||
        statSource.nFileSizeLow != statDestination.nFileSizeLow) {
      return true;
    }
  
    if (statSource.nFileSizeHigh == 0 && statSource.nFileSizeLow == 0) {
      return false;
    }
    off_t nleft =
      ((__int64)statSource.nFileSizeHigh << 32) + statSource.nFileSizeLow;
  
  #else
  
    struct stat statSource;
    if (stat(source.c_str(), &statSource) != 0) {
      return true;
    }
  
    struct stat statDestination;
    if (stat(destination.c_str(), &statDestination) != 0) {
      return true;
    }
  
    if (statSource.st_size != statDestination.st_size) {
      return true;
    }
  
    if (statSource.st_size == 0) {
      return false;
    }
    off_t nleft = statSource.st_size;
  #endif
  
  #if defined(_WIN32)
    kwsys::ifstream finSource(source.c_str(), (std::ios::binary | std::ios::in));
    kwsys::ifstream finDestination(destination.c_str(),
                                   (std::ios::binary | std::ios::in));
  #else
    kwsys::ifstream finSource(source.c_str());
    kwsys::ifstream finDestination(destination.c_str());
  #endif
    if (!finSource || !finDestination) {
      return true;
    }
  
    // Compare the files a block at a time.
    char source_buf[KWSYS_ST_BUFFER];
    char dest_buf[KWSYS_ST_BUFFER];
    while (nleft > 0) {
      // Read a block from each file.
      std::streamsize nnext = (nleft > KWSYS_ST_BUFFER)
        ? KWSYS_ST_BUFFER
        : static_cast<std::streamsize>(nleft);
      finSource.read(source_buf, nnext);
      finDestination.read(dest_buf, nnext);
  
      // If either failed to read assume they are different.
      if (static_cast<std::streamsize>(finSource.gcount()) != nnext ||
          static_cast<std::streamsize>(finDestination.gcount()) != nnext) {
        return true;
      }
  
      // If this block differs the file differs.
      if (memcmp(static_cast<const void*>(source_buf),
                 static_cast<const void*>(dest_buf),
                 static_cast<size_t>(nnext)) != 0) {
        return true;
      }
  
      // Update the byte count remaining.
      nleft -= nnext;
    }
  
    // No differences found.
    return false;
  }
  
  bool SystemTools::TextFilesDiffer(const std::string& path1,
                                    const std::string& path2)
  {
    kwsys::ifstream if1(path1.c_str());
    kwsys::ifstream if2(path2.c_str());
    if (!if1 || !if2) {
      return true;
    }
  
    for (;;) {
      std::string line1, line2;
      bool hasData1 = GetLineFromStream(if1, line1);
      bool hasData2 = GetLineFromStream(if2, line2);
      if (hasData1 != hasData2) {
        return true;
      }
      if (!hasData1) {
        break;
      }
      if (line1 != line2) {
        return true;
      }
    }
    return false;
  }
  
  /**
   * Blockwise copy source to destination file
   */
  static bool CopyFileContentBlockwise(const std::string& source,
                                       const std::string& destination)
  {
    // Open files
    kwsys::ifstream fin(source.c_str(), std::ios::in | std::ios::binary);
    if (!fin) {
      return false;
    }
  
    // try and remove the destination file so that read only destination files
    // can be written to.
    // If the remove fails continue so that files in read only directories
    // that do not allow file removal can be modified.
    SystemTools::RemoveFile(destination);
  
    kwsys::ofstream fout(destination.c_str(),
                         std::ios::out | std::ios::trunc | std::ios::binary);
    if (!fout) {
      return false;
    }
  
    // This copy loop is very sensitive on certain platforms with
    // slightly broken stream libraries (like HPUX).  Normally, it is
    // incorrect to not check the error condition on the fin.read()
    // before using the data, but the fin.gcount() will be zero if an
    // error occurred.  Therefore, the loop should be safe everywhere.
    while (fin) {
      const int bufferSize = 4096;
      char buffer[bufferSize];
  
      fin.read(buffer, bufferSize);
      if (fin.gcount()) {
        fout.write(buffer, fin.gcount());
      } else {
        break;
      }
    }
  
    // Make sure the operating system has finished writing the file
    // before closing it.  This will ensure the file is finished before
    // the check below.
    fout.flush();
  
    fin.close();
    fout.close();
  
    if (!fout) {
      return false;
    }
  
    return true;
  }
  
  /**
   * Clone the source file to the destination file
   *
   * If available, the Linux FICLONE ioctl is used to create a check
   * copy-on-write clone of the source file.
   *
   * The method returns false for the following cases:
   * - The code has not been compiled on Linux or the ioctl was unknown
   * - The source and destination is on different file systems
   * - The underlying filesystem does not support file cloning
   * - An unspecified error occurred
   */
  static bool CloneFileContent(const std::string& source,
                               const std::string& destination)
  {
  #if defined(__linux) && defined(FICLONE)
    int in = open(source.c_str(), O_RDONLY);
    if (in < 0) {
      return false;
    }
  
    SystemTools::RemoveFile(destination);
  
    int out =
      open(destination.c_str(), O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
    if (out < 0) {
      close(in);
      return false;
    }
  
    int result = ioctl(out, FICLONE, in);
    close(in);
    close(out);
  
    if (result < 0) {
      return false;
    }
  
    return true;
  #else
    (void)source;
    (void)destination;
    return false;
  #endif
  }
  
  /**
   * Copy a file named by "source" to the file named by "destination".
   */
  bool SystemTools::CopyFileAlways(const std::string& source,
                                   const std::string& destination)
  {
    mode_t perm = 0;
    bool perms = SystemTools::GetPermissions(source, perm);
    std::string real_destination = destination;
  
    if (SystemTools::FileIsDirectory(source)) {
      SystemTools::MakeDirectory(destination);
    } else {
      // If destination is a directory, try to create a file with the same
      // name as the source in that directory.
  
      std::string destination_dir;
      if (SystemTools::FileIsDirectory(destination)) {
        destination_dir = real_destination;
        SystemTools::ConvertToUnixSlashes(real_destination);
        real_destination += '/';
        std::string source_name = source;
        real_destination += SystemTools::GetFilenameName(source_name);
      } else {
        destination_dir = SystemTools::GetFilenamePath(destination);
      }
      // If files are the same do not copy
      if (SystemTools::SameFile(source, real_destination)) {
        return true;
      }
  
      // Create destination directory
  
      SystemTools::MakeDirectory(destination_dir);
  
      if (!CloneFileContent(source, real_destination)) {
        // if cloning did not succeed, fall back to blockwise copy
        if (!CopyFileContentBlockwise(source, real_destination)) {
          return false;
        }
      }
    }
    if (perms) {
      if (!SystemTools::SetPermissions(real_destination, perm)) {
        return false;
      }
    }
    return true;
  }
  
  bool SystemTools::CopyAFile(const std::string& source,
                              const std::string& destination, bool always)
  {
    if (always) {
      return SystemTools::CopyFileAlways(source, destination);
    } else {
      return SystemTools::CopyFileIfDifferent(source, destination);
    }
  }
  
  /**
   * Copy a directory content from "source" directory to the directory named by
   * "destination".
   */
  bool SystemTools::CopyADirectory(const std::string& source,
                                   const std::string& destination, bool always)
  {
    Directory dir;
    if (dir.Load(source) == 0) {
      return false;
    }
    size_t fileNum;
    if (!SystemTools::MakeDirectory(destination)) {
      return false;
    }
    for (fileNum = 0; fileNum < dir.GetNumberOfFiles(); ++fileNum) {
      if (strcmp(dir.GetFile(static_cast<unsigned long>(fileNum)), ".") &&
          strcmp(dir.GetFile(static_cast<unsigned long>(fileNum)), "..")) {
        std::string fullPath = source;
        fullPath += "/";
        fullPath += dir.GetFile(static_cast<unsigned long>(fileNum));
        if (SystemTools::FileIsDirectory(fullPath)) {
          std::string fullDestPath = destination;
          fullDestPath += "/";
          fullDestPath += dir.GetFile(static_cast<unsigned long>(fileNum));
          if (!SystemTools::CopyADirectory(fullPath, fullDestPath, always)) {
            return false;
          }
        } else {
          if (!SystemTools::CopyAFile(fullPath, destination, always)) {
            return false;
          }
        }
      }
    }
  
    return true;
  }
  
  // return size of file; also returns zero if no file exists
  unsigned long SystemTools::FileLength(const std::string& filename)
  {
    unsigned long length = 0;
  #ifdef _WIN32
    WIN32_FILE_ATTRIBUTE_DATA fs;
    if (GetFileAttributesExW(Encoding::ToWindowsExtendedPath(filename).c_str(),
                             GetFileExInfoStandard, &fs) != 0) {
      /* To support the full 64-bit file size, use fs.nFileSizeHigh
       * and fs.nFileSizeLow to construct the 64 bit size
  
      length = ((__int64)fs.nFileSizeHigh << 32) + fs.nFileSizeLow;
       */
      length = static_cast<unsigned long>(fs.nFileSizeLow);
    }
  #else
    struct stat fs;
    if (stat(filename.c_str(), &fs) == 0) {
      length = static_cast<unsigned long>(fs.st_size);
    }
  #endif
    return length;
  }
  
  int SystemTools::Strucmp(const char* l, const char* r)
  {
    int lc;
    int rc;
    do {
      lc = tolower(*l++);
      rc = tolower(*r++);
    } while (lc == rc && lc);
    return lc - rc;
  }
  
  // return file's modified time
  long int SystemTools::ModifiedTime(const std::string& filename)
  {
    long int mt = 0;
  #ifdef _WIN32
    WIN32_FILE_ATTRIBUTE_DATA fs;
    if (GetFileAttributesExW(Encoding::ToWindowsExtendedPath(filename).c_str(),
                             GetFileExInfoStandard, &fs) != 0) {
      mt = windows_filetime_to_posix_time(fs.ftLastWriteTime);
    }
  #else
    struct stat fs;
    if (stat(filename.c_str(), &fs) == 0) {
      mt = static_cast<long int>(fs.st_mtime);
    }
  #endif
    return mt;
  }
  
  // return file's creation time
  long int SystemTools::CreationTime(const std::string& filename)
  {
    long int ct = 0;
  #ifdef _WIN32
    WIN32_FILE_ATTRIBUTE_DATA fs;
    if (GetFileAttributesExW(Encoding::ToWindowsExtendedPath(filename).c_str(),
                             GetFileExInfoStandard, &fs) != 0) {
      ct = windows_filetime_to_posix_time(fs.ftCreationTime);
    }
  #else
    struct stat fs;
    if (stat(filename.c_str(), &fs) == 0) {
      ct = fs.st_ctime >= 0 ? static_cast<long int>(fs.st_ctime) : 0;
    }
  #endif
    return ct;
  }
  
  std::string SystemTools::GetLastSystemError()
  {
    int e = errno;
    return strerror(e);
  }
  
  bool SystemTools::RemoveFile(const std::string& source)
  {
  #ifdef _WIN32
    std::wstring const& ws = Encoding::ToWindowsExtendedPath(source);
    if (DeleteFileW(ws.c_str())) {
      return true;
    }
    DWORD err = GetLastError();
    if (err == ERROR_FILE_NOT_FOUND || err == ERROR_PATH_NOT_FOUND) {
      return true;
    }
    if (err != ERROR_ACCESS_DENIED) {
      return false;
    }
    /* The file may be read-only.  Try adding write permission.  */
    mode_t mode;
    if (!SystemTools::GetPermissions(source, mode) ||
        !SystemTools::SetPermissions(source, S_IWRITE)) {
      SetLastError(err);
      return false;
    }
  
    const DWORD DIRECTORY_SOFT_LINK_ATTRS =
      FILE_ATTRIBUTE_DIRECTORY | FILE_ATTRIBUTE_REPARSE_POINT;
    DWORD attrs = GetFileAttributesW(ws.c_str());
    if (attrs != INVALID_FILE_ATTRIBUTES &&
        (attrs & DIRECTORY_SOFT_LINK_ATTRS) == DIRECTORY_SOFT_LINK_ATTRS &&
        RemoveDirectoryW(ws.c_str())) {
      return true;
    }
    if (DeleteFileW(ws.c_str()) || GetLastError() == ERROR_FILE_NOT_FOUND ||
        GetLastError() == ERROR_PATH_NOT_FOUND) {
      return true;
    }
    /* Try to restore the original permissions.  */
    SystemTools::SetPermissions(source, mode);
    SetLastError(err);
    return false;
  #else
    return unlink(source.c_str()) == 0 || errno == ENOENT;
  #endif
  }
  
  bool SystemTools::RemoveADirectory(const std::string& source)
  {
    // Add write permission to the directory so we can modify its
    // content to remove files and directories from it.
    mode_t mode;
    if (SystemTools::GetPermissions(source, mode)) {
  #if defined(_WIN32) && !defined(__CYGWIN__)
      mode |= S_IWRITE;
  #else
      mode |= S_IWUSR;
  #endif
      SystemTools::SetPermissions(source, mode);
    }
  
    Directory dir;
    dir.Load(source);
    size_t fileNum;
    for (fileNum = 0; fileNum < dir.GetNumberOfFiles(); ++fileNum) {
      if (strcmp(dir.GetFile(static_cast<unsigned long>(fileNum)), ".") &&
          strcmp(dir.GetFile(static_cast<unsigned long>(fileNum)), "..")) {
        std::string fullPath = source;
        fullPath += "/";
        fullPath += dir.GetFile(static_cast<unsigned long>(fileNum));
        if (SystemTools::FileIsDirectory(fullPath) &&
            !SystemTools::FileIsSymlink(fullPath)) {
          if (!SystemTools::RemoveADirectory(fullPath)) {
            return false;
          }
        } else {
          if (!SystemTools::RemoveFile(fullPath)) {
            return false;
          }
        }
      }
    }
  
    return (Rmdir(source) == 0);
  }
  
  /**
   */
  size_t SystemTools::GetMaximumFilePathLength()
  {
    return KWSYS_SYSTEMTOOLS_MAXPATH;
  }
  
  /**
   * Find the file the given name.  Searches the given path and then
   * the system search path.  Returns the full path to the file if it is
   * found.  Otherwise, the empty string is returned.
   */
  std::string SystemToolsStatic::FindName(
    const std::string& name, const std::vector<std::string>& userPaths,
    bool no_system_path)
  {
    // Add the system search path to our path first
    std::vector<std::string> path;
    if (!no_system_path) {
      SystemTools::GetPath(path, "CMAKE_FILE_PATH");
      SystemTools::GetPath(path);
    }
    // now add the additional paths
    path.reserve(path.size() + userPaths.size());
    path.insert(path.end(), userPaths.begin(), userPaths.end());
    // now look for the file
    std::string tryPath;
    for (std::string const& p : path) {
      tryPath = p;
      if (tryPath.empty() || tryPath.back() != '/') {
        tryPath += '/';
      }
      tryPath += name;
      if (SystemTools::FileExists(tryPath)) {
        return tryPath;
      }
    }
    // Couldn't find the file.
    return "";
  }
  
  /**
   * Find the file the given name.  Searches the given path and then
   * the system search path.  Returns the full path to the file if it is
   * found.  Otherwise, the empty string is returned.
   */
  std::string SystemTools::FindFile(const std::string& name,
                                    const std::vector<std::string>& userPaths,
                                    bool no_system_path)
  {
    std::string tryPath =
      SystemToolsStatic::FindName(name, userPaths, no_system_path);
    if (!tryPath.empty() && !SystemTools::FileIsDirectory(tryPath)) {
      return SystemTools::CollapseFullPath(tryPath);
    }
    // Couldn't find the file.
    return "";
  }
  
  /**
   * Find the directory the given name.  Searches the given path and then
   * the system search path.  Returns the full path to the directory if it is
   * found.  Otherwise, the empty string is returned.
   */
  std::string SystemTools::FindDirectory(
    const std::string& name, const std::vector<std::string>& userPaths,
    bool no_system_path)
  {
    std::string tryPath =
      SystemToolsStatic::FindName(name, userPaths, no_system_path);
    if (!tryPath.empty() && SystemTools::FileIsDirectory(tryPath)) {
      return SystemTools::CollapseFullPath(tryPath);
    }
    // Couldn't find the file.
    return "";
  }
  
  /**
   * Find the executable with the given name.  Searches the given path and then
   * the system search path.  Returns the full path to the executable if it is
   * found.  Otherwise, the empty string is returned.
   */
  std::string SystemTools::FindProgram(const char* nameIn,
                                       const std::vector<std::string>& userPaths,
                                       bool no_system_path)
  {
    if (!nameIn || !*nameIn) {
      return "";
    }
    return SystemTools::FindProgram(std::string(nameIn), userPaths,
                                    no_system_path);
  }
  
  std::string SystemTools::FindProgram(const std::string& name,
                                       const std::vector<std::string>& userPaths,
                                       bool no_system_path)
  {
    std::string tryPath;
  
  #if defined(_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__)
    std::vector<std::string> extensions;
    // check to see if the name already has a .xxx at
    // the end of it
    // on windows try .com then .exe
    if (name.size() <= 3 || name[name.size() - 4] != '.') {
      extensions.emplace_back(".com");
      extensions.emplace_back(".exe");
  
      // first try with extensions if the os supports them
      for (std::string const& ext : extensions) {
        tryPath = name;
        tryPath += ext;
        if (SystemTools::FileExists(tryPath, true)) {
          return SystemTools::CollapseFullPath(tryPath);
        }
      }
    }
  #endif
  
    // now try just the name
    if (SystemTools::FileExists(name, true)) {
      return SystemTools::CollapseFullPath(name);
    }
    // now construct the path
    std::vector<std::string> path;
    // Add the system search path to our path.
    if (!no_system_path) {
      SystemTools::GetPath(path);
    }
    // now add the additional paths
    path.reserve(path.size() + userPaths.size());
    path.insert(path.end(), userPaths.begin(), userPaths.end());
    // Add a trailing slash to all paths to aid the search process.
    for (std::string& p : path) {
      if (p.empty() || p.back() != '/') {
        p += '/';
      }
    }
    // Try each path
    for (std::string& p : path) {
  #ifdef _WIN32
      // Remove double quotes from the path on windows
      SystemTools::ReplaceString(p, "\"", "");
  #endif
  #if defined(_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__)
      // first try with extensions
      for (std::string const& ext : extensions) {
        tryPath = p;
        tryPath += name;
        tryPath += ext;
        if (SystemTools::FileExists(tryPath, true)) {
          return SystemTools::CollapseFullPath(tryPath);
        }
      }
  #endif
      // now try it without them
      tryPath = p;
      tryPath += name;
      if (SystemTools::FileExists(tryPath, true)) {
        return SystemTools::CollapseFullPath(tryPath);
      }
    }
    // Couldn't find the program.
    return "";
  }
  
  std::string SystemTools::FindProgram(const std::vector<std::string>& names,
                                       const std::vector<std::string>& path,
                                       bool noSystemPath)
  {
    for (std::string const& name : names) {
      // Try to find the program.
      std::string result = SystemTools::FindProgram(name, path, noSystemPath);
      if (!result.empty()) {
        return result;
      }
    }
    return "";
  }
  
  /**
   * Find the library with the given name.  Searches the given path and then
   * the system search path.  Returns the full path to the library if it is
   * found.  Otherwise, the empty string is returned.
   */
  std::string SystemTools::FindLibrary(const std::string& name,
                                       const std::vector<std::string>& userPaths)
  {
    // See if the executable exists as written.
    if (SystemTools::FileExists(name, true)) {
      return SystemTools::CollapseFullPath(name);
    }
  
    // Add the system search path to our path.
    std::vector<std::string> path;
    SystemTools::GetPath(path);
    // now add the additional paths
    path.reserve(path.size() + userPaths.size());
    path.insert(path.end(), userPaths.begin(), userPaths.end());
    // Add a trailing slash to all paths to aid the search process.
    for (std::string& p : path) {
      if (p.empty() || p.back() != '/') {
        p += '/';
      }
    }
    std::string tryPath;
    for (std::string const& p : path) {
  #if defined(__APPLE__)
      tryPath = p;
      tryPath += name;
      tryPath += ".framework";
      if (SystemTools::FileIsDirectory(tryPath)) {
        return SystemTools::CollapseFullPath(tryPath);
      }
  #endif
  #if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__MINGW32__)
      tryPath = p;
      tryPath += name;
      tryPath += ".lib";
      if (SystemTools::FileExists(tryPath, true)) {
        return SystemTools::CollapseFullPath(tryPath);
      }
  #else
      tryPath = p;
      tryPath += "lib";
      tryPath += name;
      tryPath += ".so";
      if (SystemTools::FileExists(tryPath, true)) {
        return SystemTools::CollapseFullPath(tryPath);
      }
      tryPath = p;
      tryPath += "lib";
      tryPath += name;
      tryPath += ".a";
      if (SystemTools::FileExists(tryPath, true)) {
        return SystemTools::CollapseFullPath(tryPath);
      }
      tryPath = p;
      tryPath += "lib";
      tryPath += name;
      tryPath += ".sl";
      if (SystemTools::FileExists(tryPath, true)) {
        return SystemTools::CollapseFullPath(tryPath);
      }
      tryPath = p;
      tryPath += "lib";
      tryPath += name;
      tryPath += ".dylib";
      if (SystemTools::FileExists(tryPath, true)) {
        return SystemTools::CollapseFullPath(tryPath);
      }
      tryPath = p;
      tryPath += "lib";
      tryPath += name;
      tryPath += ".dll";
      if (SystemTools::FileExists(tryPath, true)) {
        return SystemTools::CollapseFullPath(tryPath);
      }
  #endif
    }
  
    // Couldn't find the library.
    return "";
  }
  
  std::string SystemTools::GetRealPath(const std::string& path,
                                       std::string* errorMessage)
  {
    std::string ret;
    Realpath(path, ret, errorMessage);
    return ret;
  }
  
  bool SystemTools::FileIsDirectory(const std::string& inName)
  {
    if (inName.empty()) {
      return false;
    }
    size_t length = inName.size();
    const char* name = inName.c_str();
  
    // Remove any trailing slash from the name except in a root component.
    char local_buffer[KWSYS_SYSTEMTOOLS_MAXPATH];
    std::string string_buffer;
    size_t last = length - 1;
    if (last > 0 && (name[last] == '/' || name[last] == '\\') &&
        strcmp(name, "/") != 0 && name[last - 1] != ':') {
      if (last < sizeof(local_buffer)) {
        memcpy(local_buffer, name, last);
        local_buffer[last] = '\0';
        name = local_buffer;
      } else {
        string_buffer.append(name, last);
        name = string_buffer.c_str();
      }
    }
  
  // Now check the file node type.
  #if defined(_WIN32)
    DWORD attr =
      GetFileAttributesW(Encoding::ToWindowsExtendedPath(name).c_str());
    if (attr != INVALID_FILE_ATTRIBUTES) {
      return (attr & FILE_ATTRIBUTE_DIRECTORY) != 0;
  #else
    struct stat fs;
    if (stat(name, &fs) == 0) {
      return S_ISDIR(fs.st_mode);
  #endif
    } else {
      return false;
    }
  }
  
  bool SystemTools::FileIsSymlink(const std::string& name)
  {
  #if defined(_WIN32)
    std::wstring path = Encoding::ToWindowsExtendedPath(name);
    DWORD attr = GetFileAttributesW(path.c_str());
    if (attr != INVALID_FILE_ATTRIBUTES) {
      if ((attr & FILE_ATTRIBUTE_REPARSE_POINT) != 0) {
        // FILE_ATTRIBUTE_REPARSE_POINT means:
        // * a file or directory that has an associated reparse point, or
        // * a file that is a symbolic link.
        HANDLE hFile = CreateFileW(
          path.c_str(), GENERIC_READ, FILE_SHARE_READ, nullptr, OPEN_EXISTING,
          FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS, nullptr);
        if (hFile == INVALID_HANDLE_VALUE) {
          return false;
        }
        byte buffer[MAXIMUM_REPARSE_DATA_BUFFER_SIZE];
        DWORD bytesReturned = 0;
        if (!DeviceIoControl(hFile, FSCTL_GET_REPARSE_POINT, nullptr, 0, buffer,
                             MAXIMUM_REPARSE_DATA_BUFFER_SIZE, &bytesReturned,
                             nullptr)) {
          CloseHandle(hFile);
          // Since FILE_ATTRIBUTE_REPARSE_POINT is set this file must be
          // a symbolic link if it is not a reparse point.
          return GetLastError() == ERROR_NOT_A_REPARSE_POINT;
        }
        CloseHandle(hFile);
        ULONG reparseTag =
          reinterpret_cast<PREPARSE_GUID_DATA_BUFFER>(&buffer[0])->ReparseTag;
        return (reparseTag == IO_REPARSE_TAG_SYMLINK) ||
          (reparseTag == IO_REPARSE_TAG_MOUNT_POINT);
      }
      return false;
    } else {
      return false;
    }
  #else
    struct stat fs;
    if (lstat(name.c_str(), &fs) == 0) {
      return S_ISLNK(fs.st_mode);
    } else {
      return false;
    }
  #endif
  }
  
  bool SystemTools::FileIsFIFO(const std::string& name)
  {
  #if defined(_WIN32)
    HANDLE hFile =
      CreateFileW(Encoding::ToWide(name).c_str(), GENERIC_READ, FILE_SHARE_READ,
                  nullptr, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, nullptr);
    if (hFile == INVALID_HANDLE_VALUE) {
      return false;
    }
    const DWORD type = GetFileType(hFile);
    CloseHandle(hFile);
    return type == FILE_TYPE_PIPE;
  #else
    struct stat fs;
    if (lstat(name.c_str(), &fs) == 0) {
      return S_ISFIFO(fs.st_mode);
    } else {
      return false;
    }
  #endif
  }
  
  #if defined(_WIN32) && !defined(__CYGWIN__)
  bool SystemTools::CreateSymlink(const std::string&, const std::string&)
  {
    return false;
  }
  #else
  bool SystemTools::CreateSymlink(const std::string& origName,
                                  const std::string& newName)
  {
    return symlink(origName.c_str(), newName.c_str()) >= 0;
  }
  #endif
  
  #if defined(_WIN32) && !defined(__CYGWIN__)
  bool SystemTools::ReadSymlink(const std::string&, std::string&)
  {
    return false;
  }
  #else
  bool SystemTools::ReadSymlink(const std::string& newName,
                                std::string& origName)
  {
    char buf[KWSYS_SYSTEMTOOLS_MAXPATH + 1];
    int count = static_cast<int>(
      readlink(newName.c_str(), buf, KWSYS_SYSTEMTOOLS_MAXPATH));
    if (count >= 0) {
      // Add null-terminator.
      buf[count] = 0;
      origName = buf;
      return true;
    } else {
      return false;
    }
  }
  #endif
  
  int SystemTools::ChangeDirectory(const std::string& dir)
  {
    return Chdir(dir);
  }
  
  std::string SystemTools::GetCurrentWorkingDirectory(bool collapse)
  {
    char buf[2048];
    const char* cwd = Getcwd(buf, 2048);
    std::string path;
    if (cwd) {
      path = cwd;
    }
    if (collapse) {
      return SystemTools::CollapseFullPath(path);
    }
    return path;
  }
  
  std::string SystemTools::GetProgramPath(const std::string& in_name)
  {
    std::string dir, file;
    SystemTools::SplitProgramPath(in_name, dir, file);
    return dir;
  }
  
  bool SystemTools::SplitProgramPath(const std::string& in_name,
                                     std::string& dir, std::string& file, bool)
  {
    dir = in_name;
    file = "";
    SystemTools::ConvertToUnixSlashes(dir);
  
    if (!SystemTools::FileIsDirectory(dir)) {
      std::string::size_type slashPos = dir.rfind("/");
      if (slashPos != std::string::npos) {
        file = dir.substr(slashPos + 1);
        dir = dir.substr(0, slashPos);
      } else {
        file = dir;
        dir = "";
      }
    }
    if (!(dir.empty()) && !SystemTools::FileIsDirectory(dir)) {
      std::string oldDir = in_name;
      SystemTools::ConvertToUnixSlashes(oldDir);
      dir = in_name;
      return false;
    }
    return true;
  }
  
  bool SystemTools::FindProgramPath(const char* argv0, std::string& pathOut,
                                    std::string& errorMsg, const char* exeName,
                                    const char* buildDir,
                                    const char* installPrefix)
  {
    std::vector<std::string> failures;
    std::string self = argv0 ? argv0 : "";
    failures.push_back(self);
    SystemTools::ConvertToUnixSlashes(self);
    self = SystemTools::FindProgram(self);
    if (!SystemTools::FileExists(self)) {
      if (buildDir) {
        std::string intdir = ".";
  #ifdef CMAKE_INTDIR
        intdir = CMAKE_INTDIR;
  #endif
        self = buildDir;
        self += "/bin/";
        self += intdir;
        self += "/";
        self += exeName;
        self += SystemTools::GetExecutableExtension();
      }
    }
    if (installPrefix) {
      if (!SystemTools::FileExists(self)) {
        failures.push_back(self);
        self = installPrefix;
        self += "/bin/";
        self += exeName;
      }
    }
    if (!SystemTools::FileExists(self)) {
      failures.push_back(self);
      std::ostringstream msg;
      msg << "Can not find the command line program ";
      if (exeName) {
        msg << exeName;
      }
      msg << "\n";
      if (argv0) {
        msg << "  argv[0] = \"" << argv0 << "\"\n";
      }
      msg << "  Attempted paths:\n";
      for (std::string const& ff : failures) {
        msg << "    \"" << ff << "\"\n";
      }
      errorMsg = msg.str();
      return false;
    }
    pathOut = self;
    return true;
  }
  
  std::string SystemTools::CollapseFullPath(const std::string& in_relative)
  {
    return SystemTools::CollapseFullPath(in_relative, nullptr);
  }
  
  #if KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP
  void SystemTools::AddTranslationPath(const std::string& a,
                                       const std::string& b)
  {
    std::string path_a = a;
    std::string path_b = b;
    SystemTools::ConvertToUnixSlashes(path_a);
    SystemTools::ConvertToUnixSlashes(path_b);
    // First check this is a directory path, since we don't want the table to
    // grow too fat
    if (SystemTools::FileIsDirectory(path_a)) {
      // Make sure the path is a full path and does not contain no '..'
      // Ken--the following code is incorrect. .. can be in a valid path
      // for example  /home/martink/MyHubba...Hubba/Src
      if (SystemTools::FileIsFullPath(path_b) &&
          path_b.find("..") == std::string::npos) {
        // Before inserting make sure path ends with '/'
        if (!path_a.empty() && path_a.back() != '/') {
          path_a += '/';
        }
        if (!path_b.empty() && path_b.back() != '/') {
          path_b += '/';
        }
        if (!(path_a == path_b)) {
          SystemTools::Statics->TranslationMap.insert(
            SystemToolsStatic::StringMap::value_type(std::move(path_a),
                                                     std::move(path_b)));
        }
      }
    }
  }
  
  void SystemTools::AddKeepPath(const std::string& dir)
  {
    std::string cdir;
    Realpath(SystemTools::CollapseFullPath(dir), cdir);
    SystemTools::AddTranslationPath(cdir, dir);
  }
  
  void SystemTools::CheckTranslationPath(std::string& path)
  {
    // Do not translate paths that are too short to have meaningful
    // translations.
    if (path.size() < 2) {
      return;
    }
  
    // Always add a trailing slash before translation.  It does not
    // matter if this adds an extra slash, but we do not want to
    // translate part of a directory (like the foo part of foo-dir).
    path += '/';
  
    // In case a file was specified we still have to go through this:
    // Now convert any path found in the table back to the one desired:
    for (auto const& pair : SystemTools::Statics->TranslationMap) {
      // We need to check of the path is a substring of the other path
      if (path.find(pair.first) == 0) {
        path = path.replace(0, pair.first.size(), pair.second);
      }
    }
  
    // Remove the trailing slash we added before.
    path.pop_back();
  }
  #endif
  
  static void SystemToolsAppendComponents(
    std::vector<std::string>& out_components,
    std::vector<std::string>::iterator first,
    std::vector<std::string>::iterator last)
  {
    static const std::string up = "..";
    static const std::string cur = ".";
    for (std::vector<std::string>::const_iterator i = first; i != last; ++i) {
      if (*i == up) {
        // Remove the previous component if possible.  Ignore ../ components
        // that try to go above the root.  Keep ../ components if they are
        // at the beginning of a relative path (base path is relative).
        if (out_components.size() > 1 && out_components.back() != up) {
          out_components.resize(out_components.size() - 1);
        } else if (!out_components.empty() && out_components[0].empty()) {
          out_components.emplace_back(std::move(*i));
        }
      } else if (!i->empty() && *i != cur) {
        out_components.emplace_back(std::move(*i));
      }
    }
  }
  
  std::string SystemTools::CollapseFullPath(const std::string& in_path,
                                            const char* in_base)
  {
    // Use the current working directory as a base path.
    char buf[2048];
    const char* res_in_base = in_base;
    if (!res_in_base) {
      if (const char* cwd = Getcwd(buf, 2048)) {
        res_in_base = cwd;
      } else {
        res_in_base = "";
      }
    }
  
    return SystemTools::CollapseFullPath(in_path, std::string(res_in_base));
  }
  
  std::string SystemTools::CollapseFullPath(const std::string& in_path,
                                            const std::string& in_base)
  {
    // Collect the output path components.
    std::vector<std::string> out_components;
  
    // Split the input path components.
    std::vector<std::string> path_components;
    SystemTools::SplitPath(in_path, path_components);
    out_components.reserve(path_components.size());
  
    // If the input path is relative, start with a base path.
    if (path_components[0].empty()) {
      std::vector<std::string> base_components;
      // Use the given base path.
      SystemTools::SplitPath(in_base, base_components);
  
      // Append base path components to the output path.
      out_components.push_back(base_components[0]);
      SystemToolsAppendComponents(out_components, base_components.begin() + 1,
                                  base_components.end());
    }
  
    // Append input path components to the output path.
    SystemToolsAppendComponents(out_components, path_components.begin(),
                                path_components.end());
  
    // Transform the path back to a string.
    std::string newPath = SystemTools::JoinPath(out_components);
  
  #if KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP
    // Update the translation table with this potentially new path.  I am not
    // sure why this line is here, it seems really questionable, but yet I
    // would put good money that if I remove it something will break, basically
    // from what I can see it created a mapping from the collapsed path, to be
    // replaced by the input path, which almost completely does the opposite of
    // this function, the only thing preventing this from happening a lot is
    // that if the in_path has a .. in it, then it is not added to the
    // translation table. So for most calls this either does nothing due to the
    // ..  or it adds a translation between identical paths as nothing was
    // collapsed, so I am going to try to comment it out, and see what hits the
    // fan, hopefully quickly.
    // Commented out line below:
    // SystemTools::AddTranslationPath(newPath, in_path);
  
    SystemTools::CheckTranslationPath(newPath);
  #endif
  #ifdef _WIN32
    newPath = SystemTools::Statics->GetActualCaseForPathCached(newPath);
    SystemTools::ConvertToUnixSlashes(newPath);
  #endif
    // Return the reconstructed path.
    return newPath;
  }
  
  // compute the relative path from here to there
  std::string SystemTools::RelativePath(const std::string& local,
                                        const std::string& remote)
  {
    if (!SystemTools::FileIsFullPath(local)) {
      return "";
    }
    if (!SystemTools::FileIsFullPath(remote)) {
      return "";
    }
  
    std::string l = SystemTools::CollapseFullPath(local);
    std::string r = SystemTools::CollapseFullPath(remote);
  
    // split up both paths into arrays of strings using / as a separator
    std::vector<std::string> localSplit = SystemTools::SplitString(l, '/', true);
    std::vector<std::string> remoteSplit =
      SystemTools::SplitString(r, '/', true);
    std::vector<std::string>
      commonPath; // store shared parts of path in this array
    std::vector<std::string> finalPath; // store the final relative path here
    // count up how many matching directory names there are from the start
    unsigned int sameCount = 0;
    while (((sameCount <= (localSplit.size() - 1)) &&
            (sameCount <= (remoteSplit.size() - 1))) &&
  // for Windows and Apple do a case insensitive string compare
  #if defined(_WIN32) || defined(__APPLE__)
           SystemTools::Strucmp(localSplit[sameCount].c_str(),
                                remoteSplit[sameCount].c_str()) == 0
  #else
           localSplit[sameCount] == remoteSplit[sameCount]
  #endif
    ) {
      // put the common parts of the path into the commonPath array
      commonPath.push_back(localSplit[sameCount]);
      // erase the common parts of the path from the original path arrays
      localSplit[sameCount] = "";
      remoteSplit[sameCount] = "";
      sameCount++;
    }
  
    // If there is nothing in common at all then just return the full
    // path.  This is the case only on windows when the paths have
    // different drive letters.  On unix two full paths always at least
    // have the root "/" in common so we will return a relative path
    // that passes through the root directory.
    if (sameCount == 0) {
      return remote;
    }
  
    // for each entry that is not common in the local path
    // add a ../ to the finalpath array, this gets us out of the local
    // path into the remote dir
    for (std::string const& lp : localSplit) {
      if (!lp.empty()) {
        finalPath.emplace_back("../");
      }
    }
    // for each entry that is not common in the remote path add it
    // to the final path.
    for (std::string const& rp : remoteSplit) {
      if (!rp.empty()) {
        finalPath.push_back(rp);
      }
    }
    std::string relativePath; // result string
    // now turn the array of directories into a unix path by puttint /
    // between each entry that does not already have one
    for (std::string const& fp : finalPath) {
      if (!relativePath.empty() && relativePath.back() != '/') {
        relativePath += '/';
      }
      relativePath += fp;
    }
    return relativePath;
  }
  
  std::string SystemTools::GetActualCaseForPath(const std::string& p)
  {
  #ifdef _WIN32
    return SystemToolsStatic::GetCasePathName(p);
  #else
    return p;
  #endif
  }
  
  const char* SystemTools::SplitPathRootComponent(const std::string& p,
                                                  std::string* root)
  {
    // Identify the root component.
    const char* c = p.c_str();
    if ((c[0] == '/' && c[1] == '/') || (c[0] == '\\' && c[1] == '\\')) {
      // Network path.
      if (root) {
        *root = "//";
      }
      c += 2;
    } else if (c[0] == '/' || c[0] == '\\') {
      // Unix path (or Windows path w/out drive letter).
      if (root) {
        *root = "/";
      }
      c += 1;
    } else if (c[0] && c[1] == ':' && (c[2] == '/' || c[2] == '\\')) {
      // Windows path.
      if (root) {
        (*root) = "_:/";
        (*root)[0] = c[0];
      }
      c += 3;
    } else if (c[0] && c[1] == ':') {
      // Path relative to a windows drive working directory.
      if (root) {
        (*root) = "_:";
        (*root)[0] = c[0];
      }
      c += 2;
    } else if (c[0] == '~') {
      // Home directory.  The returned root should always have a
      // trailing slash so that appending components as
      // c[0]c[1]/c[2]/... works.  The remaining path returned should
      // skip the first slash if it exists:
      //
      //   "~"    : root = "~/" , return ""
      //   "~/    : root = "~/" , return ""
      //   "~/x   : root = "~/" , return "x"
      //   "~u"   : root = "~u/", return ""
      //   "~u/"  : root = "~u/", return ""
      //   "~u/x" : root = "~u/", return "x"
      size_t n = 1;
      while (c[n] && c[n] != '/') {
        ++n;
      }
      if (root) {
        root->assign(c, n);
        *root += '/';
      }
      if (c[n] == '/') {
        ++n;
      }
      c += n;
    } else {
      // Relative path.
      if (root) {
        *root = "";
      }
    }
  
    // Return the remaining path.
    return c;
  }
  
  void SystemTools::SplitPath(const std::string& p,
                              std::vector<std::string>& components,
                              bool expand_home_dir)
  {
    const char* c;
    components.clear();
  
    // Identify the root component.
    {
      std::string root;
      c = SystemTools::SplitPathRootComponent(p, &root);
  
      // Expand home directory references if requested.
      if (expand_home_dir && !root.empty() && root[0] == '~') {
        std::string homedir;
        root = root.substr(0, root.size() - 1);
        if (root.size() == 1) {
  #if defined(_WIN32) && !defined(__CYGWIN__)
          if (!SystemTools::GetEnv("USERPROFILE", homedir))
  #endif
            SystemTools::GetEnv("HOME", homedir);
        }
  #ifdef HAVE_GETPWNAM
        else if (passwd* pw = getpwnam(root.c_str() + 1)) {
          if (pw->pw_dir) {
            homedir = pw->pw_dir;
          }
        }
  #endif
        if (!homedir.empty() &&
            (homedir.back() == '/' || homedir.back() == '\\')) {
          homedir.resize(homedir.size() - 1);
        }
        SystemTools::SplitPath(homedir, components);
      } else {
        components.push_back(root);
      }
    }
  
    // Parse the remaining components.
    const char* first = c;
    const char* last = first;
    for (; *last; ++last) {
      if (*last == '/' || *last == '\\') {
        // End of a component.  Save it.
        components.push_back(std::string(first, last));
        first = last + 1;
      }
    }
  
    // Save the last component unless there were no components.
    if (last != c) {
      components.push_back(std::string(first, last));
    }
  }
  
  std::string SystemTools::JoinPath(const std::vector<std::string>& components)
  {
    return SystemTools::JoinPath(components.begin(), components.end());
  }
  
  std::string SystemTools::JoinPath(
    std::vector<std::string>::const_iterator first,
    std::vector<std::string>::const_iterator last)
  {
    // Construct result in a single string.
    std::string result;
    size_t len = 0;
    for (std::vector<std::string>::const_iterator i = first; i != last; ++i) {
      len += 1 + i->size();
    }
    result.reserve(len);
  
    // The first two components do not add a slash.
    if (first != last) {
      result.append(*first++);
    }
    if (first != last) {
      result.append(*first++);
    }
  
    // All remaining components are always separated with a slash.
    while (first != last) {
      result.push_back('/');
      result.append((*first++));
    }
  
    // Return the concatenated result.
    return result;
  }
  
  bool SystemTools::ComparePath(const std::string& c1, const std::string& c2)
  {
  #if defined(_WIN32) || defined(__APPLE__)
  #  ifdef _MSC_VER
    return _stricmp(c1.c_str(), c2.c_str()) == 0;
  #  elif defined(__APPLE__) || defined(__GNUC__)
    return strcasecmp(c1.c_str(), c2.c_str()) == 0;
  #  else
    return SystemTools::Strucmp(c1.c_str(), c2.c_str()) == 0;
  #  endif
  #else
    return c1 == c2;
  #endif
  }
  
  bool SystemTools::Split(const std::string& str,
                          std::vector<std::string>& lines, char separator)
  {
    std::string data(str);
    std::string::size_type lpos = 0;
    while (lpos < data.length()) {
      std::string::size_type rpos = data.find_first_of(separator, lpos);
      if (rpos == std::string::npos) {
        // String ends at end of string without a separator.
        lines.push_back(data.substr(lpos));
        return false;
      } else {
        // String ends in a separator, remove the character.
        lines.push_back(data.substr(lpos, rpos - lpos));
      }
      lpos = rpos + 1;
    }
    return true;
  }
  
  bool SystemTools::Split(const std::string& str,
                          std::vector<std::string>& lines)
  {
    std::string data(str);
    std::string::size_type lpos = 0;
    while (lpos < data.length()) {
      std::string::size_type rpos = data.find_first_of('\n', lpos);
      if (rpos == std::string::npos) {
        // Line ends at end of string without a newline.
        lines.push_back(data.substr(lpos));
        return false;
      }
      if ((rpos > lpos) && (data[rpos - 1] == '\r')) {
        // Line ends in a "\r\n" pair, remove both characters.
        lines.push_back(data.substr(lpos, (rpos - 1) - lpos));
      } else {
        // Line ends in a "\n", remove the character.
        lines.push_back(data.substr(lpos, rpos - lpos));
      }
      lpos = rpos + 1;
    }
    return true;
  }
  
  /**
   * Return path of a full filename (no trailing slashes).
   * Warning: returned path is converted to Unix slashes format.
   */
  std::string SystemTools::GetFilenamePath(const std::string& filename)
  {
    std::string fn = filename;
    SystemTools::ConvertToUnixSlashes(fn);
  
    std::string::size_type slash_pos = fn.rfind("/");
    if (slash_pos != std::string::npos) {
      std::string ret = fn.substr(0, slash_pos);
      if (ret.size() == 2 && ret[1] == ':') {
        return ret + '/';
      }
      if (ret.empty()) {
        return "/";
      }
      return ret;
    } else {
      return "";
    }
  }
  
  /**
   * Return file name of a full filename (i.e. file name without path).
   */
  std::string SystemTools::GetFilenameName(const std::string& filename)
  {
  #if defined(_WIN32) || defined(KWSYS_SYSTEMTOOLS_SUPPORT_WINDOWS_SLASHES)
    const char* separators = "/\\";
  #else
    char separators = '/';
  #endif
    std::string::size_type slash_pos = filename.find_last_of(separators);
    if (slash_pos != std::string::npos) {
      return filename.substr(slash_pos + 1);
    } else {
      return filename;
    }
  }
  
  /**
   * Return file extension of a full filename (dot included).
   * Warning: this is the longest extension (for example: .tar.gz)
   */
  std::string SystemTools::GetFilenameExtension(const std::string& filename)
  {
    std::string name = SystemTools::GetFilenameName(filename);
    std::string::size_type dot_pos = name.find('.');
    if (dot_pos != std::string::npos) {
      return name.substr(dot_pos);
    } else {
      return "";
    }
  }
  
  /**
   * Return file extension of a full filename (dot included).
   * Warning: this is the shortest extension (for example: .gz of .tar.gz)
   */
  std::string SystemTools::GetFilenameLastExtension(const std::string& filename)
  {
    std::string name = SystemTools::GetFilenameName(filename);
    std::string::size_type dot_pos = name.rfind('.');
    if (dot_pos != std::string::npos) {
      return name.substr(dot_pos);
    } else {
      return "";
    }
  }
  
  /**
   * Return file name without extension of a full filename (i.e. without path).
   * Warning: it considers the longest extension (for example: .tar.gz)
   */
  std::string SystemTools::GetFilenameWithoutExtension(
    const std::string& filename)
  {
    std::string name = SystemTools::GetFilenameName(filename);
    std::string::size_type dot_pos = name.find('.');
    if (dot_pos != std::string::npos) {
      return name.substr(0, dot_pos);
    } else {
      return name;
    }
  }
  
  /**
   * Return file name without extension of a full filename (i.e. without path).
   * Warning: it considers the last extension (for example: removes .gz
   * from .tar.gz)
   */
  std::string SystemTools::GetFilenameWithoutLastExtension(
    const std::string& filename)
  {
    std::string name = SystemTools::GetFilenameName(filename);
    std::string::size_type dot_pos = name.rfind('.');
    if (dot_pos != std::string::npos) {
      return name.substr(0, dot_pos);
    } else {
      return name;
    }
  }
  
  bool SystemTools::FileHasSignature(const char* filename, const char* signature,
                                     long offset)
  {
    if (!filename || !signature) {
      return false;
    }
  
    FILE* fp = Fopen(filename, "rb");
    if (!fp) {
      return false;
    }
  
    fseek(fp, offset, SEEK_SET);
  
    bool res = false;
    size_t signature_len = strlen(signature);
    char* buffer = new char[signature_len];
  
    if (fread(buffer, 1, signature_len, fp) == signature_len) {
      res = (!strncmp(buffer, signature, signature_len) ? true : false);
    }
  
    delete[] buffer;
  
    fclose(fp);
    return res;
  }
  
  SystemTools::FileTypeEnum SystemTools::DetectFileType(const char* filename,
                                                        unsigned long length,
                                                        double percent_bin)
  {
    if (!filename || percent_bin < 0) {
      return SystemTools::FileTypeUnknown;
    }
  
    if (SystemTools::FileIsDirectory(filename)) {
      return SystemTools::FileTypeUnknown;
    }
  
    FILE* fp = Fopen(filename, "rb");
    if (!fp) {
      return SystemTools::FileTypeUnknown;
    }
  
    // Allocate buffer and read bytes
  
    unsigned char* buffer = new unsigned char[length];
    size_t read_length = fread(buffer, 1, length, fp);
    fclose(fp);
    if (read_length == 0) {
      delete[] buffer;
      return SystemTools::FileTypeUnknown;
    }
  
    // Loop over contents and count
  
    size_t text_count = 0;
  
    const unsigned char* ptr = buffer;
    const unsigned char* buffer_end = buffer + read_length;
  
    while (ptr != buffer_end) {
      if ((*ptr >= 0x20 && *ptr <= 0x7F) || *ptr == '\n' || *ptr == '\r' ||
          *ptr == '\t') {
        text_count++;
      }
      ptr++;
    }
  
    delete[] buffer;
  
    double current_percent_bin = (static_cast<double>(read_length - text_count) /
                                  static_cast<double>(read_length));
  
    if (current_percent_bin >= percent_bin) {
      return SystemTools::FileTypeBinary;
    }
  
    return SystemTools::FileTypeText;
  }
  
  bool SystemTools::LocateFileInDir(const char* filename, const char* dir,
                                    std::string& filename_found,
                                    int try_filename_dirs)
  {
    if (!filename || !dir) {
      return false;
    }
  
    // Get the basename of 'filename'
  
    std::string filename_base = SystemTools::GetFilenameName(filename);
  
    // Check if 'dir' is really a directory
    // If win32 and matches something like C:, accept it as a dir
  
    std::string real_dir;
    if (!SystemTools::FileIsDirectory(dir)) {
  #if defined(_WIN32)
      size_t dir_len = strlen(dir);
      if (dir_len < 2 || dir[dir_len - 1] != ':') {
  #endif
        real_dir = SystemTools::GetFilenamePath(dir);
        dir = real_dir.c_str();
  #if defined(_WIN32)
      }
  #endif
    }
  
    // Try to find the file in 'dir'
  
    bool res = false;
    if (!filename_base.empty() && dir) {
      size_t dir_len = strlen(dir);
      int need_slash =
        (dir_len && dir[dir_len - 1] != '/' && dir[dir_len - 1] != '\\');
  
      std::string temp = dir;
      if (need_slash) {
        temp += "/";
      }
      temp += filename_base;
  
      if (SystemTools::FileExists(temp)) {
        res = true;
        filename_found = temp;
      }
  
      // If not found, we can try harder by appending part of the file to
      // to the directory to look inside.
      // Example: if we were looking for /foo/bar/yo.txt in /d1/d2, then
      // try to find yo.txt in /d1/d2/bar, then /d1/d2/foo/bar, etc.
  
      else if (try_filename_dirs) {
        std::string filename_dir(filename);
        std::string filename_dir_base;
        std::string filename_dir_bases;
        do {
          filename_dir = SystemTools::GetFilenamePath(filename_dir);
          filename_dir_base = SystemTools::GetFilenameName(filename_dir);
  #if defined(_WIN32)
          if (filename_dir_base.empty() || filename_dir_base.back() == ':')
  #else
          if (filename_dir_base.empty())
  #endif
          {
            break;
          }
  
          filename_dir_bases = filename_dir_base + "/" + filename_dir_bases;
  
          temp = dir;
          if (need_slash) {
            temp += "/";
          }
          temp += filename_dir_bases;
  
          res = SystemTools::LocateFileInDir(filename_base.c_str(), temp.c_str(),
                                             filename_found, 0);
  
        } while (!res && !filename_dir_base.empty());
      }
    }
  
    return res;
  }
  
  bool SystemTools::FileIsFullPath(const std::string& in_name)
  {
    return SystemToolsStatic::FileIsFullPath(in_name.c_str(), in_name.size());
  }
  
  bool SystemTools::FileIsFullPath(const char* in_name)
  {
    return SystemToolsStatic::FileIsFullPath(
      in_name, in_name[0] ? (in_name[1] ? 2 : 1) : 0);
  }
  
  bool SystemToolsStatic::FileIsFullPath(const char* in_name, size_t len)
  {
  #if defined(_WIN32) || defined(__CYGWIN__)
    // On Windows, the name must be at least two characters long.
    if (len < 2) {
      return false;
    }
    if (in_name[1] == ':') {
      return true;
    }
    if (in_name[0] == '\\') {
      return true;
    }
  #else
    // On UNIX, the name must be at least one character long.
    if (len < 1) {
      return false;
    }
  #endif
  #if !defined(_WIN32)
    if (in_name[0] == '~') {
      return true;
    }
  #endif
    // On UNIX, the name must begin in a '/'.
    // On Windows, if the name begins in a '/', then it is a full
    // network path.
    if (in_name[0] == '/') {
      return true;
    }
    return false;
  }
  
  bool SystemTools::GetShortPath(const std::string& path, std::string& shortPath)
  {
  #if defined(_WIN32) && !defined(__CYGWIN__)
    std::string tempPath = path; // create a buffer
  
    // if the path passed in has quotes around it, first remove the quotes
    if (!path.empty() && path[0] == '"' && path.back() == '"') {
      tempPath = path.substr(1, path.length() - 2);
    }
  
    std::wstring wtempPath = Encoding::ToWide(tempPath);
    DWORD ret = GetShortPathNameW(wtempPath.c_str(), nullptr, 0);
    std::vector<wchar_t> buffer(ret);
    if (ret != 0) {
      ret = GetShortPathNameW(wtempPath.c_str(), &buffer[0],
                              static_cast<DWORD>(buffer.size()));
    }
  
    if (ret == 0) {
      return false;
    } else {
      shortPath = Encoding::ToNarrow(&buffer[0]);
      return true;
    }
  #else
    shortPath = path;
    return true;
  #endif
  }
  
  std::string SystemTools::GetCurrentDateTime(const char* format)
  {
    char buf[1024];
    time_t t;
    time(&t);
    strftime(buf, sizeof(buf), format, localtime(&t));
    return std::string(buf);
  }
  
  std::string SystemTools::MakeCidentifier(const std::string& s)
  {
    std::string str(s);
    if (str.find_first_of("0123456789") == 0) {
      str = "_" + str;
    }
  
    std::string permited_chars("_"
                               "abcdefghijklmnopqrstuvwxyz"
                               "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                               "0123456789");
    std::string::size_type pos = 0;
    while ((pos = str.find_first_not_of(permited_chars, pos)) !=
           std::string::npos) {
      str[pos] = '_';
    }
    return str;
  }
  
  // Convenience function around std::getline which removes a trailing carriage
  // return and can truncate the buffer as needed.  Returns true
  // if any data were read before the end-of-file was reached.
  bool SystemTools::GetLineFromStream(std::istream& is, std::string& line,
                                      bool* has_newline /* = 0 */,
                                      long sizeLimit /* = -1 */)
  {
    // Start with an empty line.
    line = "";
  
    // Early short circuit return if stream is no good. Just return
    // false and the empty line. (Probably means caller tried to
    // create a file stream with a non-existent file name...)
    //
    if (!is) {
      if (has_newline) {
        *has_newline = false;
      }
      return false;
    }
  
    std::getline(is, line);
    bool haveData = !line.empty() || !is.eof();
    if (!line.empty()) {
      // Avoid storing a carriage return character.
      if (line.back() == '\r') {
        line.resize(line.size() - 1);
      }
  
      // if we read too much then truncate the buffer
      if (sizeLimit >= 0 && line.size() >= static_cast<size_t>(sizeLimit)) {
        line.resize(sizeLimit);
      }
    }
  
    // Return the results.
    if (has_newline) {
      *has_newline = !is.eof();
    }
    return haveData;
  }
  
  int SystemTools::GetTerminalWidth()
  {
    int width = -1;
  #ifdef HAVE_TTY_INFO
    struct winsize ws;
    std::string columns; /* Unix98 environment variable */
    if (ioctl(1, TIOCGWINSZ, &ws) != -1 && ws.ws_col > 0 && ws.ws_row > 0) {
      width = ws.ws_col;
    }
    if (!isatty(STDOUT_FILENO)) {
      width = -1;
    }
    if (SystemTools::GetEnv("COLUMNS", columns) && !columns.empty()) {
      long t;
      char* endptr;
      t = strtol(columns.c_str(), &endptr, 0);
      if (endptr && !*endptr && (t > 0) && (t < 1000)) {
        width = static_cast<int>(t);
      }
    }
    if (width < 9) {
      width = -1;
    }
  #endif
    return width;
  }
  
  bool SystemTools::GetPermissions(const char* file, mode_t& mode)
  {
    if (!file) {
      return false;
    }
    return SystemTools::GetPermissions(std::string(file), mode);
  }
  
  bool SystemTools::GetPermissions(const std::string& file, mode_t& mode)
  {
  #if defined(_WIN32)
    DWORD attr =
      GetFileAttributesW(Encoding::ToWindowsExtendedPath(file).c_str());
    if (attr == INVALID_FILE_ATTRIBUTES) {
      return false;
    }
    if ((attr & FILE_ATTRIBUTE_READONLY) != 0) {
      mode = (_S_IREAD | (_S_IREAD >> 3) | (_S_IREAD >> 6));
    } else {
      mode = (_S_IWRITE | (_S_IWRITE >> 3) | (_S_IWRITE >> 6)) |
        (_S_IREAD | (_S_IREAD >> 3) | (_S_IREAD >> 6));
    }
    if ((attr & FILE_ATTRIBUTE_DIRECTORY) != 0) {
      mode |= S_IFDIR | (_S_IEXEC | (_S_IEXEC >> 3) | (_S_IEXEC >> 6));
    } else {
      mode |= S_IFREG;
    }
    size_t dotPos = file.rfind('.');
    const char* ext = dotPos == std::string::npos ? 0 : (file.c_str() + dotPos);
    if (ext &&
        (Strucmp(ext, ".exe") == 0 || Strucmp(ext, ".com") == 0 ||
         Strucmp(ext, ".cmd") == 0 || Strucmp(ext, ".bat") == 0)) {
      mode |= (_S_IEXEC | (_S_IEXEC >> 3) | (_S_IEXEC >> 6));
    }
  #else
    struct stat st;
    if (stat(file.c_str(), &st) < 0) {
      return false;
    }
    mode = st.st_mode;
  #endif
    return true;
  }
  
  bool SystemTools::SetPermissions(const char* file, mode_t mode,
                                   bool honor_umask)
  {
    if (!file) {
      return false;
    }
    return SystemTools::SetPermissions(std::string(file), mode, honor_umask);
  }
  
  bool SystemTools::SetPermissions(const std::string& file, mode_t mode,
                                   bool honor_umask)
  {
    if (!SystemTools::PathExists(file)) {
      return false;
    }
    if (honor_umask) {
      mode_t currentMask = umask(0);
      umask(currentMask);
      mode &= ~currentMask;
    }
  #ifdef _WIN32
    if (_wchmod(Encoding::ToWindowsExtendedPath(file).c_str(), mode) < 0)
  #else
    if (chmod(file.c_str(), mode) < 0)
  #endif
    {
      return false;
    }
  
    return true;
  }
  
  std::string SystemTools::GetParentDirectory(const std::string& fileOrDir)
  {
    return SystemTools::GetFilenamePath(fileOrDir);
  }
  
  bool SystemTools::IsSubDirectory(const std::string& cSubdir,
                                   const std::string& cDir)
  {
    if (cDir.empty()) {
      return false;
    }
    std::string subdir = cSubdir;
    std::string dir = cDir;
    SystemTools::ConvertToUnixSlashes(subdir);
    SystemTools::ConvertToUnixSlashes(dir);
    if (subdir.size() <= dir.size() || dir.empty()) {
      return false;
    }
    bool isRootPath = dir.back() == '/'; // like "/" or "C:/"
    size_t expectedSlashPosition = isRootPath ? dir.size() - 1u : dir.size();
    if (subdir[expectedSlashPosition] != '/') {
      return false;
    }
    std::string s = subdir.substr(0, dir.size());
    return SystemTools::ComparePath(s, dir);
  }
  
  void SystemTools::Delay(unsigned int msec)
  {
  #ifdef _WIN32
    Sleep(msec);
  #else
    // The sleep function gives 1 second resolution and the usleep
    // function gives 1e-6 second resolution but on some platforms has a
    // maximum sleep time of 1 second.  This could be re-implemented to
    // use select with masked signals or pselect to mask signals
    // atomically.  If select is given empty sets and zero as the max
    // file descriptor but a non-zero timeout it can be used to block
    // for a precise amount of time.
    if (msec >= 1000) {
      sleep(msec / 1000);
      usleep((msec % 1000) * 1000);
    } else {
      usleep(msec * 1000);
    }
  #endif
  }
  
  std::string SystemTools::GetOperatingSystemNameAndVersion()
  {
    std::string res;
  
  #ifdef _WIN32
    char buffer[256];
  
    OSVERSIONINFOEXA osvi;
    BOOL bOsVersionInfoEx;
  
    ZeroMemory(&osvi, sizeof(osvi));
    osvi.dwOSVersionInfoSize = sizeof(osvi);
  
  #  ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx
  #    pragma warning(push)
  #    ifdef __INTEL_COMPILER
  #      pragma warning(disable : 1478)
  #    elif defined __clang__
  #      pragma clang diagnostic push
  #      pragma clang diagnostic ignored "-Wdeprecated-declarations"
  #    else
  #      pragma warning(disable : 4996)
  #    endif
  #  endif
    bOsVersionInfoEx = GetVersionExA((OSVERSIONINFOA*)&osvi);
    if (!bOsVersionInfoEx) {
      return 0;
    }
  #  ifdef KWSYS_WINDOWS_DEPRECATED_GetVersionEx
  #    ifdef __clang__
  #      pragma clang diagnostic pop
  #    else
  #      pragma warning(pop)
  #    endif
  #  endif
  
    switch (osvi.dwPlatformId) {
        // Test for the Windows NT product family.
  
      case VER_PLATFORM_WIN32_NT:
  
        // Test for the specific product family.
        if (osvi.dwMajorVersion == 10 && osvi.dwMinorVersion == 0) {
          if (osvi.wProductType == VER_NT_WORKSTATION) {
            res += "Microsoft Windows 10";
          } else {
            res += "Microsoft Windows Server 2016 family";
          }
        }
  
        if (osvi.dwMajorVersion == 6 && osvi.dwMinorVersion == 3) {
          if (osvi.wProductType == VER_NT_WORKSTATION) {
            res += "Microsoft Windows 8.1";
          } else {
            res += "Microsoft Windows Server 2012 R2 family";
          }
        }
  
        if (osvi.dwMajorVersion == 6 && osvi.dwMinorVersion == 2) {
          if (osvi.wProductType == VER_NT_WORKSTATION) {
            res += "Microsoft Windows 8";
          } else {
            res += "Microsoft Windows Server 2012 family";
          }
        }
  
        if (osvi.dwMajorVersion == 6 && osvi.dwMinorVersion == 1) {
          if (osvi.wProductType == VER_NT_WORKSTATION) {
            res += "Microsoft Windows 7";
          } else {
            res += "Microsoft Windows Server 2008 R2 family";
          }
        }
  
        if (osvi.dwMajorVersion == 6 && osvi.dwMinorVersion == 0) {
          if (osvi.wProductType == VER_NT_WORKSTATION) {
            res += "Microsoft Windows Vista";
          } else {
            res += "Microsoft Windows Server 2008 family";
          }
        }
  
        if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2) {
          res += "Microsoft Windows Server 2003 family";
        }
  
        if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 1) {
          res += "Microsoft Windows XP";
        }
  
        if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0) {
          res += "Microsoft Windows 2000";
        }
  
        if (osvi.dwMajorVersion <= 4) {
          res += "Microsoft Windows NT";
        }
  
        // Test for specific product on Windows NT 4.0 SP6 and later.
  
        if (bOsVersionInfoEx) {
          // Test for the workstation type.
  
          if (osvi.wProductType == VER_NT_WORKSTATION) {
            if (osvi.dwMajorVersion == 4) {
              res += " Workstation 4.0";
            } else if (osvi.dwMajorVersion == 5) {
              if (osvi.wSuiteMask & VER_SUITE_PERSONAL) {
                res += " Home Edition";
              } else {
                res += " Professional";
              }
            }
          }
  
          // Test for the server type.
  
          else if (osvi.wProductType == VER_NT_SERVER) {
            if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 2) {
              if (osvi.wSuiteMask & VER_SUITE_DATACENTER) {
                res += " Datacenter Edition";
              } else if (osvi.wSuiteMask & VER_SUITE_ENTERPRISE) {
                res += " Enterprise Edition";
              } else if (osvi.wSuiteMask == VER_SUITE_BLADE) {
                res += " Web Edition";
              } else {
                res += " Standard Edition";
              }
            }
  
            else if (osvi.dwMajorVersion == 5 && osvi.dwMinorVersion == 0) {
              if (osvi.wSuiteMask & VER_SUITE_DATACENTER) {
                res += " Datacenter Server";
              } else if (osvi.wSuiteMask & VER_SUITE_ENTERPRISE) {
                res += " Advanced Server";
              } else {
                res += " Server";
              }
            }
  
            else if (osvi.dwMajorVersion <= 4) // Windows NT 4.0
            {
              if (osvi.wSuiteMask & VER_SUITE_ENTERPRISE) {
                res += " Server 4.0, Enterprise Edition";
              } else {
                res += " Server 4.0";
              }
            }
          }
        }
  
        // Test for specific product on Windows NT 4.0 SP5 and earlier
  
        else {
          HKEY hKey;
  #  define BUFSIZE 80
          wchar_t szProductType[BUFSIZE];
          DWORD dwBufLen = BUFSIZE;
          LONG lRet;
  
          lRet =
            RegOpenKeyExW(HKEY_LOCAL_MACHINE,
                          L"SYSTEM\\CurrentControlSet\\Control\\ProductOptions",
                          0, KEY_QUERY_VALUE, &hKey);
          if (lRet != ERROR_SUCCESS) {
            return 0;
          }
  
          lRet = RegQueryValueExW(hKey, L"ProductType", nullptr, nullptr,
                                  (LPBYTE)szProductType, &dwBufLen);
  
          if ((lRet != ERROR_SUCCESS) || (dwBufLen > BUFSIZE)) {
            return 0;
          }
  
          RegCloseKey(hKey);
  
          if (lstrcmpiW(L"WINNT", szProductType) == 0) {
            res += " Workstation";
          }
          if (lstrcmpiW(L"LANMANNT", szProductType) == 0) {
            res += " Server";
          }
          if (lstrcmpiW(L"SERVERNT", szProductType) == 0) {
            res += " Advanced Server";
          }
  
          res += " ";
          sprintf(buffer, "%ld", osvi.dwMajorVersion);
          res += buffer;
          res += ".";
          sprintf(buffer, "%ld", osvi.dwMinorVersion);
          res += buffer;
        }
  
        // Display service pack (if any) and build number.
  
        if (osvi.dwMajorVersion == 4 &&
            lstrcmpiA(osvi.szCSDVersion, "Service Pack 6") == 0) {
          HKEY hKey;
          LONG lRet;
  
          // Test for SP6 versus SP6a.
  
          lRet = RegOpenKeyExW(
            HKEY_LOCAL_MACHINE,
            L"SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Hotfix\\Q246009",
            0, KEY_QUERY_VALUE, &hKey);
  
          if (lRet == ERROR_SUCCESS) {
            res += " Service Pack 6a (Build ";
            sprintf(buffer, "%ld", osvi.dwBuildNumber & 0xFFFF);
            res += buffer;
            res += ")";
          } else // Windows NT 4.0 prior to SP6a
          {
            res += " ";
            res += osvi.szCSDVersion;
            res += " (Build ";
            sprintf(buffer, "%ld", osvi.dwBuildNumber & 0xFFFF);
            res += buffer;
            res += ")";
          }
  
          RegCloseKey(hKey);
        } else // Windows NT 3.51 and earlier or Windows 2000 and later
        {
          res += " ";
          res += osvi.szCSDVersion;
          res += " (Build ";
          sprintf(buffer, "%ld", osvi.dwBuildNumber & 0xFFFF);
          res += buffer;
          res += ")";
        }
  
        break;
  
        // Test for the Windows 95 product family.
  
      case VER_PLATFORM_WIN32_WINDOWS:
  
        if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 0) {
          res += "Microsoft Windows 95";
          if (osvi.szCSDVersion[1] == 'C' || osvi.szCSDVersion[1] == 'B') {
            res += " OSR2";
          }
        }
  
        if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 10) {
          res += "Microsoft Windows 98";
          if (osvi.szCSDVersion[1] == 'A') {
            res += " SE";
          }
        }
  
        if (osvi.dwMajorVersion == 4 && osvi.dwMinorVersion == 90) {
          res += "Microsoft Windows Millennium Edition";
        }
        break;
  
      case VER_PLATFORM_WIN32s:
  
        res += "Microsoft Win32s";
        break;
    }
  #endif
  
    return res;
  }
  
  bool SystemTools::ParseURLProtocol(const std::string& URL,
                                     std::string& protocol,
                                     std::string& dataglom)
  {
    // match 0 entire url
    // match 1 protocol
    // match 2 dataglom following protocol://
    kwsys::RegularExpression urlRe(VTK_URL_PROTOCOL_REGEX);
  
    if (!urlRe.find(URL))
      return false;
  
    protocol = urlRe.match(1);
    dataglom = urlRe.match(2);
  
    return true;
  }
  
  bool SystemTools::ParseURL(const std::string& URL, std::string& protocol,
                             std::string& username, std::string& password,
                             std::string& hostname, std::string& dataport,
                             std::string& database)
  {
    kwsys::RegularExpression urlRe(VTK_URL_REGEX);
    if (!urlRe.find(URL))
      return false;
  
    // match 0 URL
    // match 1 protocol
    // match 2 mangled user
    // match 3 username
    // match 4 mangled password
    // match 5 password
    // match 6 hostname
    // match 7 mangled port
    // match 8 dataport
    // match 9 database name
  
    protocol = urlRe.match(1);
    username = urlRe.match(3);
    password = urlRe.match(5);
    hostname = urlRe.match(6);
    dataport = urlRe.match(8);
    database = urlRe.match(9);
  
    return true;
  }
  
  // These must NOT be initialized.  Default initialization to zero is
  // necessary.
  static unsigned int SystemToolsManagerCount;
  SystemToolsStatic* SystemTools::Statics;
  
  // SystemToolsManager manages the SystemTools singleton.
  // SystemToolsManager should be included in any translation unit
  // that will use SystemTools or that implements the singleton
  // pattern. It makes sure that the SystemTools singleton is created
  // before and destroyed after all other singletons in CMake.
  
  SystemToolsManager::SystemToolsManager()
  {
    if (++SystemToolsManagerCount == 1) {
      SystemTools::ClassInitialize();
    }
  }
  
  SystemToolsManager::~SystemToolsManager()
  {
    if (--SystemToolsManagerCount == 0) {
      SystemTools::ClassFinalize();
    }
  }
  
  #if defined(__VMS)
  // On VMS we configure the run time C library to be more UNIX like.
  // http://h71000.www7.hp.com/doc/732final/5763/5763pro_004.html
  extern "C" int decc$feature_get_index(char* name);
  extern "C" int decc$feature_set_value(int index, int mode, int value);
  static int SetVMSFeature(char* name, int value)
  {
    int i;
    errno = 0;
    i = decc$feature_get_index(name);
    return i >= 0 && (decc$feature_set_value(i, 1, value) >= 0 || errno == 0);
  }
  #endif
  
  void SystemTools::ClassInitialize()
  {
  #ifdef __VMS
    SetVMSFeature("DECC$FILENAME_UNIX_ONLY", 1);
  #endif
  
    // Create statics singleton instance
    SystemTools::Statics = new SystemToolsStatic;
  
  #if KWSYS_SYSTEMTOOLS_USE_TRANSLATION_MAP
  // Add some special translation paths for unix.  These are not added
  // for windows because drive letters need to be maintained.  Also,
  // there are not sym-links and mount points on windows anyway.
  #  if !defined(_WIN32) || defined(__CYGWIN__)
    // The tmp path is frequently a logical path so always keep it:
    SystemTools::AddKeepPath("/tmp/");
  
    // If the current working directory is a logical path then keep the
    // logical name.
    std::string pwd_str;
    if (SystemTools::GetEnv("PWD", pwd_str)) {
      char buf[2048];
      if (const char* cwd = Getcwd(buf, 2048)) {
        // The current working directory may be a logical path.  Find
        // the shortest logical path that still produces the correct
        // physical path.
        std::string cwd_changed;
        std::string pwd_changed;
  
        // Test progressively shorter logical-to-physical mappings.
        std::string cwd_str = cwd;
        std::string pwd_path;
        Realpath(pwd_str, pwd_path);
        while (cwd_str == pwd_path && cwd_str != pwd_str) {
          // The current pair of paths is a working logical mapping.
          cwd_changed = cwd_str;
          pwd_changed = pwd_str;
  
          // Strip off one directory level and see if the logical
          // mapping still works.
          pwd_str = SystemTools::GetFilenamePath(pwd_str);
          cwd_str = SystemTools::GetFilenamePath(cwd_str);
          Realpath(pwd_str, pwd_path);
        }
  
        // Add the translation to keep the logical path name.
        if (!cwd_changed.empty() && !pwd_changed.empty()) {
          SystemTools::AddTranslationPath(cwd_changed, pwd_changed);
        }
      }
    }
  #  endif
  #endif
  }
  
  void SystemTools::ClassFinalize()
  {
    delete SystemTools::Statics;
  }
  
  } // namespace KWSYS_NAMESPACE
  
  #if defined(_MSC_VER) && defined(_DEBUG)
  #  include <crtdbg.h>
  #  include <stdio.h>
  #  include <stdlib.h>
  namespace KWSYS_NAMESPACE {
  
  static int SystemToolsDebugReport(int, char* message, int* ret)
  {
    if (ret) {
      // Pretend user clicked on Retry button in popup.
      *ret = 1;
    }
    fprintf(stderr, "%s", message);
    fflush(stderr);
    return 1; // no further reporting required
  }
  
  void SystemTools::EnableMSVCDebugHook()
  {
    if (SystemTools::HasEnv("DART_TEST_FROM_DART") ||
        SystemTools::HasEnv("DASHBOARD_TEST_FROM_CTEST")) {
      _CrtSetReportHook(SystemToolsDebugReport);
    }
  }
  
  } // namespace KWSYS_NAMESPACE
  #else
  namespace KWSYS_NAMESPACE {
  void SystemTools::EnableMSVCDebugHook()
  {
  }
  } // namespace KWSYS_NAMESPACE
  #endif
  