/*========================================================================= Program: KWSys - Kitware System Library Module: $RCSfile$ Copyright (c) Kitware, Inc., Insight Consortium. All rights reserved. See Copyright.txt or http://www.kitware.com/Copyright.htm for details. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the above copyright notices for more information. =========================================================================*/ #include "kwsysPrivate.h" #include KWSYS_HEADER(SystemTools.hxx) #include KWSYS_HEADER(Directory.hxx) #include KWSYS_HEADER(ios/iostream) #include KWSYS_HEADER(ios/fstream) #include KWSYS_HEADER(ios/sstream) #ifdef _MSC_VER # pragma warning (disable: 4786) #endif #include #include #include #include #include #include #include // support for realpath call #ifndef _WIN32 #include #include #include #include #include #include #endif #if defined(_WIN32) && (defined(_MSC_VER) || defined(__BORLANDC__) || defined(__MINGW32__)) #include #include #include #define _unlink unlink inline int Mkdir(const char* dir) { return _mkdir(dir); } inline int Rmdir(const char* dir) { return _rmdir(dir); } inline const char* Getcwd(char* buf, unsigned int len) { return _getcwd(buf, len); } inline int Chdir(const char* dir) { #if defined(__BORLANDC__) return chdir(dir); #else return _chdir(dir); #endif } inline void Realpath(const char *path, kwsys_stl::string & resolved_path) { char *ptemp; char fullpath[MAX_PATH]; if( GetFullPathName(path, sizeof(fullpath), fullpath, &ptemp) ) { resolved_path = fullpath; KWSYS_NAMESPACE::SystemTools::ConvertToUnixSlashes(resolved_path); } } #else #include #include #include inline int Mkdir(const char* dir) { return mkdir(dir, 00777); } inline int Rmdir(const char* dir) { return rmdir(dir); } inline const char* Getcwd(char* buf, unsigned int len) { return getcwd(buf, len); } inline int Chdir(const char* dir) { return chdir(dir); } inline void Realpath(const char *path, kwsys_stl::string & resolved_path) { # ifdef MAXPATHLEN char resolved_name[MAXPATHLEN]; # else # ifdef PATH_MAX char resolved_name[PATH_MAX]; # else char resolved_name[5024]; # endif //PATH_MAX # endif //MAXPATHLEN realpath(path, resolved_name); resolved_path = resolved_name; } #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 /* Implement floattime() for various platforms */ // Taken from Python 2.1.3 #if defined( _WIN32 ) && !defined( __CYGWIN__ ) # include # define HAVE_FTIME # if defined( __BORLANDC__) # define FTIME ftime # define TIMEB timeb # else // Visual studio? # define FTIME _ftime # define TIMEB _timeb # endif #elif defined( __CYGWIN__ ) || defined( __linux__ ) # include # include # define HAVE_GETTIMEOFDAY #endif namespace KWSYS_NAMESPACE { class SystemToolsTranslationMap : public kwsys_stl::map { }; double SystemTools::GetTime(void) { /* There are three ways to get the time: (1) gettimeofday() -- resolution in microseconds (2) ftime() -- resolution in milliseconds (3) time() -- resolution in seconds In all cases the return value is a float in seconds. Since on some systems (e.g. SCO ODT 3.0) gettimeofday() may fail, so we fall back on ftime() or time(). Note: clock resolution does not imply clock accuracy! */ #ifdef HAVE_GETTIMEOFDAY { struct timeval t; #ifdef GETTIMEOFDAY_NO_TZ if (gettimeofday(&t) == 0) return (double)t.tv_sec + t.tv_usec*0.000001; #else /* !GETTIMEOFDAY_NO_TZ */ if (gettimeofday(&t, (struct timezone *)NULL) == 0) return (double)t.tv_sec + t.tv_usec*0.000001; #endif /* !GETTIMEOFDAY_NO_TZ */ } #endif /* !HAVE_GETTIMEOFDAY */ { #if defined(HAVE_FTIME) struct TIMEB t; ::FTIME(&t); return (double)t.time + (double)t.millitm * (double)0.001; #else /* !HAVE_FTIME */ time_t secs; time(&secs); return (double)secs; #endif /* !HAVE_FTIME */ } } // adds the elements of the env variable path to the arg passed in void SystemTools::GetPath(kwsys_stl::vector& path, const char* env) { #if defined(_WIN32) && !defined(__CYGWIN__) const char* pathSep = ";"; #else const char* pathSep = ":"; #endif if(!env) { env = "PATH"; } const char* cpathEnv = SystemTools::GetEnv(env); if ( !cpathEnv ) { return; } kwsys_stl::string pathEnv = cpathEnv; // A hack to make the below algorithm work. if(pathEnv[pathEnv.length()-1] != ':') { pathEnv += pathSep; } kwsys_stl::string::size_type start =0; bool done = false; while(!done) { kwsys_stl::string::size_type endpos = pathEnv.find(pathSep, start); if(endpos != kwsys_stl::string::npos) { path.push_back(pathEnv.substr(start, endpos-start)); start = endpos+1; } else { done = true; } } for(kwsys_stl::vector::iterator i = path.begin(); i != path.end(); ++i) { SystemTools::ConvertToUnixSlashes(*i); } } const char* SystemTools::GetEnv(const char* key) { return getenv(key); } bool SystemTools::GetEnv(const char* key, kwsys_stl::string& result) { const char* v = getenv(key); if(v) { result = v; return true; } else { return false; } } const char* SystemTools::GetExecutableExtension() { #if defined(_WIN32) || defined(__CYGWIN__) return ".exe"; #else return ""; #endif } bool SystemTools::MakeDirectory(const char* path) { if(SystemTools::FileExists(path)) { return true; } kwsys_stl::string dir = path; if(dir.size() == 0) { return false; } SystemTools::ConvertToUnixSlashes(dir); kwsys_stl::string::size_type pos = dir.find(':'); if(pos == kwsys_stl::string::npos) { pos = 0; } kwsys_stl::string topdir; while((pos = dir.find('/', pos)) != kwsys_stl::string::npos) { topdir = dir.substr(0, pos); Mkdir(topdir.c_str()); pos++; } if(dir[dir.size()-1] == '/') { topdir = dir.substr(0, dir.size()); } else { topdir = dir; } if(Mkdir(topdir.c_str()) != 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; } } return true; } // replace replace with with as many times as it shows up in source. // write the result into source. void SystemTools::ReplaceString(kwsys_stl::string& source, const char* replace, const char* with) { const char *src = source.c_str(); char *searchPos = const_cast(strstr(src,replace)); // get out quick if string is not found if (!searchPos) { return; } // perform replacements until done size_t replaceSize = strlen(replace); 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); } // 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 char *key, kwsys_stl::string &value) { kwsys_stl::string primary = key; kwsys_stl::string second; kwsys_stl::string valuename; size_t start = primary.find("\\"); if (start == kwsys_stl::string::npos) { return false; } size_t valuenamepos = primary.find(";"); if (valuenamepos != kwsys_stl::string::npos) { valuename = primary.substr(valuenamepos+1); } second = primary.substr(start+1, valuenamepos-start-1); primary = primary.substr(0, start); HKEY primaryKey = HKEY_CURRENT_USER; 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; } HKEY hKey; if(RegOpenKeyEx(primaryKey, second.c_str(), 0, KEY_READ, &hKey) != ERROR_SUCCESS) { return false; } else { DWORD dwType, dwSize; dwSize = 1023; char data[1024]; if(RegQueryValueEx(hKey, (LPTSTR)valuename.c_str(), NULL, &dwType, (BYTE *)data, &dwSize) == ERROR_SUCCESS) { if (dwType == REG_SZ) { value = data; RegCloseKey(hKey); return true; } } } return false; } #else bool SystemTools::ReadRegistryValue(const char *, kwsys_stl::string &) { 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 char *key, const char *value) { kwsys_stl::string primary = key; kwsys_stl::string second; kwsys_stl::string valuename; size_t start = primary.find("\\"); if (start == kwsys_stl::string::npos) { return false; } size_t valuenamepos = primary.find(";"); if (valuenamepos != kwsys_stl::string::npos) { valuename = primary.substr(valuenamepos+1); } second = primary.substr(start+1, valuenamepos-start-1); primary = primary.substr(0, start); HKEY primaryKey = HKEY_CURRENT_USER; 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; } HKEY hKey; DWORD dwDummy; if(RegCreateKeyEx(primaryKey, second.c_str(), 0, "", REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hKey, &dwDummy) != ERROR_SUCCESS) { return false; } if(RegSetValueEx(hKey, (LPTSTR)valuename.c_str(), 0, REG_SZ, (CONST BYTE *)value, (DWORD)(strlen(value) + 1)) == ERROR_SUCCESS) { return true; } return false; } #else bool SystemTools::WriteRegistryValue(const char *, const char *) { 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 char *key) { kwsys_stl::string primary = key; kwsys_stl::string second; kwsys_stl::string valuename; size_t start = primary.find("\\"); if (start == kwsys_stl::string::npos) { return false; } size_t valuenamepos = primary.find(";"); if (valuenamepos != kwsys_stl::string::npos) { valuename = primary.substr(valuenamepos+1); } second = primary.substr(start+1, valuenamepos-start-1); primary = primary.substr(0, start); HKEY primaryKey = HKEY_CURRENT_USER; 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; } HKEY hKey; if(RegOpenKeyEx(primaryKey, second.c_str(), 0, KEY_WRITE, &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 char *) { return false; } #endif bool SystemTools::SameFile(const char* file1, const char* file2) { #ifdef _WIN32 HANDLE hFile1, hFile2; hFile1 = CreateFile( file1, GENERIC_READ, FILE_SHARE_READ , NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL ); hFile2 = CreateFile( file2, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL ); 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, &fileStat1) == 0 && stat(file2, &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 } // return true if the file exists bool SystemTools::FileExists(const char* filename) { #ifdef _MSC_VER # define access _access #endif #ifndef R_OK # define R_OK 04 #endif if ( access(filename, R_OK) != 0 ) { return false; } else { return true; } } bool SystemTools::FileTimeCompare(const char* f1, const char* 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, &s1) != 0) { return false; } struct stat s2; if(stat(f2, &s2) != 0) { return false; } # if KWSYS_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; } # 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. Create file handles and get the modification times. HANDLE hf1 = CreateFile(f1, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL); if(hf1 == INVALID_HANDLE_VALUE) { return false; } FILETIME tf1; if(!GetFileTime(hf1, 0, 0, &tf1)) { CloseHandle(hf1); return false; } CloseHandle(hf1); HANDLE hf2 = CreateFile(f2, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL); if(hf2 == INVALID_HANDLE_VALUE) { return false; } FILETIME tf2; if(!GetFileTime(hf2, 0, 0, &tf2)) { CloseHandle(hf2); return false; } CloseHandle(hf2); // Compare the file times using resolution provided by system call. *result = (int)CompareFileTime(&tf1, &tf2); #endif return true; } // Return a capitalized string (i.e the first letter is uppercased, all other // are lowercased) kwsys_stl::string SystemTools::Capitalized(const kwsys_stl::string& s) { kwsys_stl::string n; if(s.size() == 0) { return n; } n.resize(s.size()); n[0] = static_cast(toupper(s[0])); for (size_t i = 1; i < s.size(); i++) { n[i] = static_cast(tolower(s[i])); } return n; } // Return capitalized words kwsys_stl::string SystemTools::CapitalizedWords(const kwsys_stl::string& s) { kwsys_stl::string n(s); for (size_t i = 0; i < s.size(); i++) { if (isalpha(s[i]) && (i == 0 || isspace(s[i - 1]))) { n[i] = static_cast(toupper(s[i])); } } return n; } // Return uncapitalized words kwsys_stl::string SystemTools::UnCapitalizedWords(const kwsys_stl::string& s) { kwsys_stl::string n(s); for (size_t i = 0; i < s.size(); i++) { if (isalpha(s[i]) && (i == 0 || isspace(s[i - 1]))) { n[i] = static_cast(tolower(s[i])); } } return n; } kwsys_stl::string SystemTools::AddSpaceBetweenCapitalizedWords( const kwsys_stl::string& s) { kwsys_stl::string n; if (s.size()) { 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[0]; } } 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 0; } 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 0; } strcpy(newstr, str1); strcat(newstr + len1, str2); strcat(newstr + len1 + len2, str3); return newstr; } // Return a lower case string kwsys_stl::string SystemTools::LowerCase(const kwsys_stl::string& s) { kwsys_stl::string n; n.resize(s.size()); for (size_t i = 0; i < s.size(); i++) { n[i] = static_cast(tolower(s[i])); } return n; } // Return a lower case string kwsys_stl::string SystemTools::UpperCase(const kwsys_stl::string& s) { kwsys_stl::string n; n.resize(s.size()); for (size_t i = 0; i < s.size(); i++) { n[i] = static_cast(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 NULL; } 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 0; } char *clean_str = new char [strlen(str) + 1]; char *ptr = clean_str; while (*str) { if ((*str >= '0' && *str <= '9') || (*str >= 'A' && *str <= 'H')) { *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 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 a pointer to the last occurence of str2 in str1 const char* SystemTools::FindLastString(const char* str1, const char* str2) { if (!str1 || !str2) { return NULL; } 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 NULL; } // Duplicate string char* SystemTools::DuplicateString(const char* str) { if (str) { char *newstr = new char [strlen(str) + 1]; return strcpy(newstr, str); } return NULL; } // Return a cropped string kwsys_stl::string SystemTools::CropString(const kwsys_stl::string& s, size_t max_len) { if (!s.size() || max_len == 0 || max_len >= s.size()) { return s; } kwsys_stl::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), kwsys_stl::string::npos); if (max_len > 2) { n[middle] = '.'; if (max_len > 3) { n[middle - 1] = '.'; if (max_len > 4) { n[middle + 1] = '.'; } } } return n; } // convert windows slashes to unix slashes void SystemTools::ConvertToUnixSlashes(kwsys_stl::string& path) { kwsys_stl::string::size_type pos = 0; while((pos = path.find('\\', pos)) != kwsys_stl::string::npos) { // make sure we don't convert an escaped space to a unix slash if(pos < path.size()-1) { if(path[pos+1] != ' ') { path[pos] = '/'; } } pos++; } // Remove all // from the path just like most unix shells int start_find; #ifdef _WIN32 // However, on windows if the first characters are both slashes, // then keep them that way, so that network paths can be handled. start_find = 1; #else start_find = 0; #endif while((pos = path.find("//", start_find)) != kwsys_stl::string::npos) { SystemTools::ReplaceString(path, "//", "/"); } // remove any trailing slash if(path.size() > 1 && path[path.size()-1] == '/') { path = path.substr(0, path.size()-1); } // if there is a tilda ~ then replace it with HOME if(path.find("~") == 0) { if (getenv("HOME")) { path = kwsys_stl::string(getenv("HOME")) + path.substr(1); } } } // change // to /, and escape any spaces in the path kwsys_stl::string SystemTools::ConvertToUnixOutputPath(const char* path) { kwsys_stl::string ret = path; // remove // except at the beginning might be a cygwin drive kwsys_stl::string::size_type pos = 1; while((pos = ret.find("//", pos)) != kwsys_stl::string::npos) { ret.erase(pos, 1); } // now escape spaces if there is a space in the path if(ret.find(" ") != kwsys_stl::string::npos) { kwsys_stl::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; } kwsys_stl::string SystemTools::ConvertToOutputPath(const char* path) { #if defined(_WIN32) && !defined(__CYGWIN__) return SystemTools::ConvertToWindowsOutputPath(path); #else return SystemTools::ConvertToUnixOutputPath(path); #endif } // remove double slashes not at the start kwsys_stl::string SystemTools::ConvertToWindowsOutputPath(const char* path) { kwsys_stl::string ret = path; kwsys_stl::string::size_type pos = 0; // first convert all of the slashes while((pos = ret.find('/', pos)) != kwsys_stl::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)) != kwsys_stl::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(" ") != kwsys_stl::string::npos && ret[0] != '\"') { kwsys_stl::string result; result = "\"" + ret + "\""; ret = result; } return ret; } bool SystemTools::CopyFileIfDifferent(const char* source, const char* destination) { if(SystemTools::FilesDiffer(source, destination)) { return SystemTools::CopyFileAlways(source, destination); } return true; } bool SystemTools::FilesDiffer(const char* source, const char* destination) { struct stat statSource; if (stat(source, &statSource) != 0) { return true; } struct stat statDestination; if (stat(destination, &statDestination) != 0) { return true; } if(statSource.st_size != statDestination.st_size) { return true; } if(statSource.st_size == 0) { return false; } #if defined(_WIN32) || defined(__CYGWIN__) kwsys_ios::ifstream finSource(source, (kwsys_ios::ios::binary | kwsys_ios::ios::in)); kwsys_ios::ifstream finDestination(destination, (kwsys_ios::ios::binary | kwsys_ios::ios::in)); #else kwsys_ios::ifstream finSource(source); kwsys_ios::ifstream finDestination(destination); #endif if(!finSource || !finDestination) { return true; } char* source_buf = new char[statSource.st_size]; char* dest_buf = new char[statSource.st_size]; finSource.read(source_buf, statSource.st_size); finDestination.read(dest_buf, statSource.st_size); if(statSource.st_size != static_cast(finSource.gcount()) || statSource.st_size != static_cast(finDestination.gcount())) { // Failed to read files. delete [] source_buf; delete [] dest_buf; return true; } int ret = memcmp((const void*)source_buf, (const void*)dest_buf, statSource.st_size); delete [] dest_buf; delete [] source_buf; return ret != 0; } /** * Copy a file named by "source" to the file named by "destination". */ bool SystemTools::CopyFileAlways(const char* source, const char* destination) { // If files are the same do not copy if ( SystemTools::SameFile(source, destination) ) { return true; } mode_t perm = 0; bool perms = SystemTools::GetPermissions(source, perm); const int bufferSize = 4096; char buffer[bufferSize]; // If destination is a directory, try to create a file with the same // name as the source in that directory. kwsys_stl::string new_destination; if(SystemTools::FileExists(destination) && SystemTools::FileIsDirectory(destination)) { new_destination = destination; SystemTools::ConvertToUnixSlashes(new_destination); new_destination += '/'; kwsys_stl::string source_name = source; new_destination += SystemTools::GetFilenameName(source_name); destination = new_destination.c_str(); } // Create destination directory kwsys_stl::string destination_dir = destination; destination_dir = SystemTools::GetFilenamePath(destination_dir); SystemTools::MakeDirectory(destination_dir.c_str()); // Open files #if defined(_WIN32) || defined(__CYGWIN__) kwsys_ios::ifstream fin(source, kwsys_ios::ios::binary | kwsys_ios::ios::in); #else kwsys_ios::ifstream fin(source); #endif 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); #if defined(_WIN32) || defined(__CYGWIN__) kwsys_ios::ofstream fout(destination, kwsys_ios::ios::binary | kwsys_ios::ios::out | kwsys_ios::ios::trunc); #else kwsys_ios::ofstream fout(destination, kwsys_ios::ios::out | kwsys_ios::ios::trunc); #endif 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) { fin.read(buffer, bufferSize); if(fin.gcount()) { fout.write(buffer, fin.gcount()); } } // 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(); // More checks. struct stat statSource, statDestination; statSource.st_size = 12345; statDestination.st_size = 12345; if(stat(source, &statSource) != 0) { return false; } else if(stat(destination, &statDestination) != 0) { return false; } else if(statSource.st_size != statDestination.st_size) { return false; } if ( perms ) { if ( !SystemTools::SetPermissions(destination, perm) ) { return false; } } return true; } /** * Copy a directory content from "source" directory to the directory named by * "destination". */ bool SystemTools::CopyADirectory(const char* source, const char* destination) { Directory dir; dir.Load(source); size_t fileNum; if ( !SystemTools::MakeDirectory(destination) ) { return false; } for (fileNum = 0; fileNum < dir.GetNumberOfFiles(); ++fileNum) { if (strcmp(dir.GetFile(static_cast(fileNum)),".") && strcmp(dir.GetFile(static_cast(fileNum)),"..")) { kwsys_stl::string fullPath = source; fullPath += "/"; fullPath += dir.GetFile(static_cast(fileNum)); if(SystemTools::FileIsDirectory(fullPath.c_str())) { kwsys_stl::string fullDestPath = destination; fullDestPath += "/"; fullDestPath += dir.GetFile(static_cast(fileNum)); if (!SystemTools::CopyADirectory(fullPath.c_str(), fullDestPath.c_str())) { return false; } } else { if(!SystemTools::CopyFileAlways(fullPath.c_str(), destination)) { return false; } } } } return true; } // return size of file; also returns zero if no file exists unsigned long SystemTools::FileLength(const char* filename) { struct stat fs; if (stat(filename, &fs) != 0) { return 0; } else { return static_cast(fs.st_size); } } int SystemTools::Strucmp(const char *s1, const char *s2) { // lifted from Graphvis http://www.graphviz.org while ((*s1 != '\0') && (tolower(*s1) == tolower(*s2))) { s1++; s2++; } return tolower(*s1) - tolower(*s2); } // return file's modified time long int SystemTools::ModifiedTime(const char* filename) { struct stat fs; if (stat(filename, &fs) != 0) { return 0; } else { return (long int)fs.st_mtime; } } // return file's creation time long int SystemTools::CreationTime(const char* filename) { struct stat fs; if (stat(filename, &fs) != 0) { return 0; } else { return fs.st_ctime >= 0 ? (long int)fs.st_ctime : 0; } } bool SystemTools::ConvertDateMacroString(const char *str, time_t *tmt) { if (!str || !tmt || strlen(str) < 12) { return false; } struct tm tmt2; // __DATE__ // The compilation date of the current source file. The date is a string // literal of the form Mmm dd yyyy. The month name Mmm is the same as for // dates generated by the library function asctime declared in TIME.H. // index: 012345678901 // format: Mmm dd yyyy // example: Dec 19 2003 static char month_names[] = "JanFebMarAprMayJunJulAugSepOctNovDec"; char buffer[12]; strcpy(buffer, str); buffer[3] = 0; char *ptr = strstr(month_names, buffer); if (!ptr) { return false; } int month = (ptr - month_names) / 3; int day = atoi(buffer + 4); int year = atoi(buffer + 7); tmt2.tm_isdst = -1; tmt2.tm_hour = 0; tmt2.tm_min = 0; tmt2.tm_sec = 0; tmt2.tm_wday = 0; tmt2.tm_yday = 0; tmt2.tm_mday = day; tmt2.tm_mon = month; tmt2.tm_year = year - 1900; *tmt = mktime(&tmt2); return true; } bool SystemTools::ConvertTimeStampMacroString(const char *str, time_t *tmt) { if (!str || !tmt || strlen(str) < 27) { return false; } struct tm tmt2; // __TIMESTAMP__ // The date and time of the last modification of the current source file, // expressed as a string literal in the form Ddd Mmm Date hh:mm:ss yyyy, /// where Ddd is the abbreviated day of the week and Date is an integer // from 1 to 31. // index: 0123456789 // 0123456789 // 0123456789 // format: Ddd Mmm Date hh:mm:ss yyyy // example: Fri Dec 19 14:34:58 2003 static char month_names[] = "JanFebMarAprMayJunJulAugSepOctNovDec"; char buffer[27]; strcpy(buffer, str); buffer[7] = 0; char *ptr = strstr(month_names, buffer + 4); if (!ptr) { return false; } int month = (ptr - month_names) / 3; int day = atoi(buffer + 8); int hour = atoi(buffer + 11); int min = atoi(buffer + 14); int sec = atoi(buffer + 17); int year = atoi(buffer + 20); tmt2.tm_isdst = -1; tmt2.tm_hour = hour; tmt2.tm_min = min; tmt2.tm_sec = sec; tmt2.tm_wday = 0; tmt2.tm_yday = 0; tmt2.tm_mday = day; tmt2.tm_mon = month; tmt2.tm_year = year - 1900; *tmt = mktime(&tmt2); return true; } kwsys_stl::string SystemTools::GetLastSystemError() { int e = errno; return strerror(e); } bool SystemTools::RemoveFile(const char* source) { #ifdef _WIN32 mode_t mode; if ( !SystemTools::GetPermissions(source, mode) ) { return false; } /* Win32 unlink is stupid --- it fails if the file is read-only */ SystemTools::SetPermissions(source, S_IWRITE); #endif bool res = unlink(source) != 0 ? false : true; #ifdef _WIN32 if ( !res ) { SystemTools::SetPermissions(source, mode); } #endif return res; } bool SystemTools::RemoveADirectory(const char* source) { Directory dir; dir.Load(source); size_t fileNum; for (fileNum = 0; fileNum < dir.GetNumberOfFiles(); ++fileNum) { if (strcmp(dir.GetFile(static_cast(fileNum)),".") && strcmp(dir.GetFile(static_cast(fileNum)),"..")) { kwsys_stl::string fullPath = source; fullPath += "/"; fullPath += dir.GetFile(static_cast(fileNum)); if(SystemTools::FileIsDirectory(fullPath.c_str())) { if (!SystemTools::RemoveADirectory(fullPath.c_str())) { return false; } } else { if(!SystemTools::RemoveFile(fullPath.c_str())) { return false; } } } } return (Rmdir(source) == 0); } /** * 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. */ kwsys_stl::string SystemTools ::FindFile(const char* name, const kwsys_stl::vector& userPaths) { // Add the system search path to our path first kwsys_stl::vector path; SystemTools::GetPath(path, "CMAKE_FILE_PATH"); SystemTools::GetPath(path); // now add the additional paths path.insert(path.end(), userPaths.begin(), userPaths.end()); // now look for the file kwsys_stl::string tryPath; for(kwsys_stl::vector::const_iterator p = path.begin(); p != path.end(); ++p) { tryPath = *p; tryPath += "/"; tryPath += name; if(SystemTools::FileExists(tryPath.c_str()) && !SystemTools::FileIsDirectory(tryPath.c_str())) { return SystemTools::CollapseFullPath(tryPath.c_str()); } } // 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. */ kwsys_stl::string SystemTools::FindProgram( const char* name, const kwsys_stl::vector& userPaths, bool no_system_path) { if(!name) { return ""; } // See if the executable exists as written. if(SystemTools::FileExists(name) && !SystemTools::FileIsDirectory(name)) { return SystemTools::CollapseFullPath(name); } kwsys_stl::string tryPath = name; tryPath += SystemTools::GetExecutableExtension(); if(SystemTools::FileExists(tryPath.c_str()) && !SystemTools::FileIsDirectory(tryPath.c_str())) { return SystemTools::CollapseFullPath(tryPath.c_str()); } kwsys_stl::vector path; SystemTools::GetPath(path, "CMAKE_PROGRAM_PATH"); // Add the system search path to our path. if (!no_system_path) { SystemTools::GetPath(path); } // now add the additional paths path.insert(path.end(), userPaths.begin(), userPaths.end()); for(kwsys_stl::vector::const_iterator p = path.begin(); p != path.end(); ++p) { tryPath = *p; tryPath += "/"; tryPath += name; if(SystemTools::FileExists(tryPath.c_str()) && !SystemTools::FileIsDirectory(tryPath.c_str())) { return SystemTools::CollapseFullPath(tryPath.c_str()); } #ifdef _WIN32 tryPath += ".com"; if(SystemTools::FileExists(tryPath.c_str()) && !SystemTools::FileIsDirectory(tryPath.c_str())) { return SystemTools::CollapseFullPath(tryPath.c_str()); } tryPath = *p; tryPath += "/"; tryPath += name; #endif tryPath += SystemTools::GetExecutableExtension(); if(SystemTools::FileExists(tryPath.c_str()) && !SystemTools::FileIsDirectory(tryPath.c_str())) { return SystemTools::CollapseFullPath(tryPath.c_str()); } } // Couldn't find the program. 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. */ kwsys_stl::string SystemTools ::FindLibrary(const char* name, const kwsys_stl::vector& userPaths) { // See if the executable exists as written. if(SystemTools::FileExists(name) && !SystemTools::FileIsDirectory(name)) { return SystemTools::CollapseFullPath(name); } // Add the system search path to our path. kwsys_stl::vector path; SystemTools::GetPath(path); // now add the additional paths path.insert(path.end(), userPaths.begin(), userPaths.end()); kwsys_stl::string tryPath; for(kwsys_stl::vector::const_iterator p = path.begin(); p != path.end(); ++p) { #if defined(_WIN32) && !defined(__CYGWIN__) && !defined(__MINGW32__) tryPath = *p; tryPath += "/"; tryPath += name; tryPath += ".lib"; if(SystemTools::FileExists(tryPath.c_str()) && !SystemTools::FileIsDirectory(tryPath.c_str())) { return SystemTools::CollapseFullPath(tryPath.c_str()); } #else tryPath = *p; tryPath += "/lib"; tryPath += name; tryPath += ".so"; if(SystemTools::FileExists(tryPath.c_str()) && !SystemTools::FileIsDirectory(tryPath.c_str())) { return SystemTools::CollapseFullPath(tryPath.c_str()); } tryPath = *p; tryPath += "/lib"; tryPath += name; tryPath += ".a"; if(SystemTools::FileExists(tryPath.c_str()) && !SystemTools::FileIsDirectory(tryPath.c_str())) { return SystemTools::CollapseFullPath(tryPath.c_str()); } tryPath = *p; tryPath += "/lib"; tryPath += name; tryPath += ".sl"; if(SystemTools::FileExists(tryPath.c_str()) && !SystemTools::FileIsDirectory(tryPath.c_str())) { return SystemTools::CollapseFullPath(tryPath.c_str()); } tryPath = *p; tryPath += "/lib"; tryPath += name; tryPath += ".dylib"; if(SystemTools::FileExists(tryPath.c_str()) && !SystemTools::FileIsDirectory(tryPath.c_str())) { return SystemTools::CollapseFullPath(tryPath.c_str()); } tryPath = *p; tryPath += "/lib"; tryPath += name; tryPath += ".dll"; if(SystemTools::FileExists(tryPath.c_str()) && !SystemTools::FileIsDirectory(tryPath.c_str())) { return SystemTools::CollapseFullPath(tryPath.c_str()); } #endif } // Couldn't find the library. return ""; } bool SystemTools::FileIsDirectory(const char* name) { struct stat fs; if(stat(name, &fs) == 0) { #if _WIN32 return ((fs.st_mode & _S_IFDIR) != 0); #else return S_ISDIR(fs.st_mode); #endif } else { return false; } } int SystemTools::ChangeDirectory(const char *dir) { return Chdir(dir); } kwsys_stl::string SystemTools::GetCurrentWorkingDirectory() { char buf[2048]; const char* cwd = Getcwd(buf, 2048); kwsys_stl::string path; if ( cwd ) { path = cwd; } return SystemTools::CollapseFullPath(path.c_str()); } kwsys_stl::string SystemTools::GetProgramPath(const char* in_name) { kwsys_stl::string dir, file; SystemTools::SplitProgramPath(in_name, dir, file); return dir; } bool SystemTools::SplitProgramPath(const char* in_name, kwsys_stl::string& dir, kwsys_stl::string& file, bool) { dir = in_name; file = ""; SystemTools::ConvertToUnixSlashes(dir); if(!SystemTools::FileIsDirectory(dir.c_str())) { kwsys_stl::string::size_type slashPos = dir.rfind("/"); if(slashPos != kwsys_stl::string::npos) { file = dir.substr(slashPos+1); dir = dir.substr(0, slashPos); } else { file = dir; dir = ""; } } if(!(dir == "") && !SystemTools::FileIsDirectory(dir.c_str())) { kwsys_stl::string oldDir = in_name; SystemTools::ConvertToUnixSlashes(oldDir); dir = in_name; return false; } return true; } bool SystemTools::FindProgramPath(const char* argv0, kwsys_stl::string& pathOut, kwsys_stl::string& errorMsg, const char* exeName, const char* buildDir, const char* installPrefix ) { kwsys_stl::vector failures; kwsys_stl::string self = argv0; SystemTools::ConvertToUnixSlashes(self); failures.push_back(argv0); self = SystemTools::FindProgram(self.c_str()); if(!SystemTools::FileExists(self.c_str())) { if(buildDir) { kwsys_stl::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.c_str())) { failures.push_back(self); self = installPrefix; self += "/bin/"; self += exeName; } } if(!SystemTools::FileExists(self.c_str())) { failures.push_back(self); kwsys_ios::ostringstream msg; msg << "Can not find the command line program " << exeName << "\n"; msg << " argv[0] = \"" << argv0 << "\"\n"; msg << " Attempted paths:\n"; kwsys_stl::vector::iterator i; for(i=failures.begin(); i != failures.end(); ++i) { msg << " \"" << i->c_str() << "\"\n"; } errorMsg = msg.str(); return false; } pathOut = self; return true; } kwsys_stl::string SystemTools::CollapseFullPath(const char* in_relative) { return SystemTools::CollapseFullPath(in_relative, 0); } void SystemTools::AddTranslationPath(const char * a, const char * b) { kwsys_stl::string path_a = a; kwsys_stl::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.c_str() ) ) { // Make sure the path is a full path and does not contain no '..' if( SystemTools::FileIsFullPath(path_b.c_str()) && path_b.find("..") == kwsys_stl::string::npos ) { // Before inserting make sure path ends with '/' if(path_a.size() && path_a[path_a.size() -1] != '/') { path_a += '/'; } if(path_b.size() && path_b[path_b.size() -1] != '/') { path_b += '/'; } if( !(path_a == path_b) ) { SystemTools::TranslationMap->insert( SystemToolsTranslationMap::value_type(path_a, path_b)); } } } } void SystemTools::AddKeepPath(const char* dir) { kwsys_stl::string cdir = SystemTools::CollapseFullPath(dir); SystemTools::AddTranslationPath(cdir.c_str(), dir); } void SystemTools::CheckTranslationPath(kwsys_stl::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: kwsys_stl::map::const_iterator it; for(it = SystemTools::TranslationMap->begin(); it != SystemTools::TranslationMap->end(); ++it ) { // We need to check of the path is a substring of the other path if(path.find( it->first ) == 0) { path = path.replace( 0, it->first.size(), it->second); } } // Remove the trailing slash we added before. path.erase(path.end()-1, path.end()); } kwsys_stl::string SystemTools::CollapseFullPath(const char* in_relative, const char* in_base) { kwsys_stl::string orig; // Change to base of relative path. if(in_base) { // Save original working directory. orig = SystemTools::GetCurrentWorkingDirectory(); Chdir(in_base); } kwsys_stl::string dir, file; SystemTools::SplitProgramPath(in_relative, dir, file, false); if(dir.size() == 0 && in_relative && strlen(in_relative) > 0 && in_relative[0] == '/') { dir = "/"; } // Resolve relative path. kwsys_stl::string newDir; if(!(dir == "")) { Realpath(dir.c_str(), newDir); } else { newDir = SystemTools::GetCurrentWorkingDirectory(); } if(in_base) { // Restore original working directory. Chdir(orig.c_str()); } // Construct and return the full path. kwsys_stl::string newPath = newDir; if(!(file == "")) { if(!(newDir.size() == 1 && newDir[0] == '/')) { newPath += "/"; } newPath += file; } // Now we need to update the translation table with this potentially new path SystemTools::AddTranslationPath(newPath.c_str(), in_relative); SystemTools::CheckTranslationPath(newPath); return newPath; } //---------------------------------------------------------------------------- void SystemTools::SplitPath(const char* p, kwsys_stl::vector& components) { components.clear(); // Identify the root component. const char* c = p; if(c[0] == '/' && c[1] == '/') { // Network path. components.push_back("//"); c += 2; } else if(c[0] == '/') { // Unix path. components.push_back("/"); c += 1; } else if(c[0] && c[1] == ':' && c[2] == '/') { // Windows path. kwsys_stl::string root = "_:/"; root[0] = c[0]; components.push_back(root); c += 3; } else if(c[0] && c[1] == ':') { // Path relative to a windows drive working directory. kwsys_stl::string root = "_:"; root[0] = c[0]; components.push_back(root); c += 2; } else { // Relative path. components.push_back(""); } // Parse the remaining components. const char* first = c; const char* last = first; for(;*last; ++last) { if(*last == '/') { // End of a component. Save it. components.push_back(kwsys_stl::string(first, last-first)); first = last+1; } } // Save the last component unless there were no components. if(last != c) { components.push_back(kwsys_stl::string(first, last-first)); } } //---------------------------------------------------------------------------- kwsys_stl::string SystemTools::JoinPath(const kwsys_stl::vector& components) { kwsys_stl::string result; if(components.size() > 0) { result += components[0]; } if(components.size() > 1) { result += components[1]; } for(unsigned int i=2; i < components.size(); ++i) { result += "/"; result += components[i]; } return result; } //---------------------------------------------------------------------------- bool SystemTools::ComparePath(const char* c1, const char* c2) { #if defined(_WIN32) || defined(__APPLE__) return SystemTools::Strucmp(c1, c2) == 0; #else return strcmp(c1, c2) == 0; #endif } bool SystemTools::Split(const char* str, kwsys_stl::vector& lines) { kwsys_stl::string data(str); kwsys_stl::string::size_type lpos = 0; while(lpos < data.length()) { kwsys_stl::string::size_type rpos = data.find_first_of("\n", lpos); if(rpos == kwsys_stl::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. */ kwsys_stl::string SystemTools::GetFilenamePath(const kwsys_stl::string& filename) { kwsys_stl::string fn = filename; SystemTools::ConvertToUnixSlashes(fn); kwsys_stl::string::size_type slash_pos = fn.rfind("/"); if(slash_pos != kwsys_stl::string::npos) { return fn.substr(0, slash_pos); } else { return ""; } } /** * Return file name of a full filename (i.e. file name without path). */ kwsys_stl::string SystemTools::GetFilenameName(const kwsys_stl::string& filename) { kwsys_stl::string fn = filename; SystemTools::ConvertToUnixSlashes(fn); kwsys_stl::string::size_type slash_pos = fn.rfind("/"); if(slash_pos != kwsys_stl::string::npos) { return fn.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) */ kwsys_stl::string SystemTools::GetFilenameExtension(const kwsys_stl::string& filename) { kwsys_stl::string name = SystemTools::GetFilenameName(filename); kwsys_stl::string::size_type dot_pos = name.find("."); if(dot_pos != kwsys_stl::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: .tar.gz) */ kwsys_stl::string SystemTools::GetFilenameLastExtension(const kwsys_stl::string& filename) { kwsys_stl::string name = SystemTools::GetFilenameName(filename); kwsys_stl::string::size_type dot_pos = name.rfind("."); if(dot_pos != kwsys_stl::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) */ kwsys_stl::string SystemTools::GetFilenameWithoutExtension(const kwsys_stl::string& filename) { kwsys_stl::string name = SystemTools::GetFilenameName(filename); kwsys_stl::string::size_type dot_pos = name.find("."); if(dot_pos != kwsys_stl::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) */ kwsys_stl::string SystemTools::GetFilenameWithoutLastExtension(const kwsys_stl::string& filename) { kwsys_stl::string name = SystemTools::GetFilenameName(filename); kwsys_stl::string::size_type dot_pos = name.rfind("."); if(dot_pos != kwsys_stl::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; 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; } bool SystemTools::LocateFileInDir(const char *filename, const char *dir, kwsys_stl::string& filename_found, int try_filename_dirs) { if (!filename || !dir) { return false; } // Get the basename of 'filename' kwsys_stl::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 kwsys_stl::string real_dir; if (!SystemTools::FileIsDirectory(dir)) { #if _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 _WIN32 } #endif } // Try to find the file in 'dir' bool res = false; if (filename_base.size() && dir) { size_t dir_len = strlen(dir); int need_slash = (dir_len && dir[dir_len - 1] != '/' && dir[dir_len - 1] != '\\'); kwsys_stl::string temp = dir; if (need_slash) { temp += "/"; } temp += filename_base; if (SystemTools::FileExists(filename_found.c_str())) { 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) { kwsys_stl::string filename_dir(filename); kwsys_stl::string filename_dir_base; kwsys_stl::string filename_dir_bases; do { filename_dir = SystemTools::GetFilenamePath(filename_dir); filename_dir_base = SystemTools::GetFilenameName(filename_dir); #if _WIN32 if (!filename_dir_base.size() || filename_dir_base[filename_dir_base.size() - 1] == ':') #else if (!filename_dir_base.size()) #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.size()); } } return res; } bool SystemTools::FileIsFullPath(const char* in_name) { kwsys_stl::string name = in_name; #if defined(_WIN32) || defined(__CYGWIN__) // On Windows, the name must be at least two characters long. if(name.length() < 2) { return false; } if(name[1] == ':') { return true; } if(name[0] == '\\') { return true; } #else // On UNIX, the name must be at least one character long. if(name.length() < 1) { return false; } #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(name[0] == '/') { return true; } return false; } bool SystemTools::GetShortPath(const char* path, kwsys_stl::string& shortPath) { #if defined(WIN32) && !defined(__CYGWIN__) const int size = int(strlen(path)) +1; // size of return char *buffer = new char[size]; // create a buffer char *tempPath = new char[size]; // create a buffer int ret; // if the path passed in has quotes around it, first remove the quotes if (path[0] == '"' && path[strlen(path)-1] == '"') { strcpy(tempPath,path+1); tempPath[strlen(tempPath)-1] = '\0'; } else { strcpy(tempPath,path); } buffer[0] = 0; ret = GetShortPathName(tempPath, buffer, size); if(buffer[0] == 0 || ret > size) { delete [] buffer; delete [] tempPath; return false; } else { shortPath = buffer; delete [] buffer; delete [] tempPath; return true; } #else shortPath = path; return true; #endif } void SystemTools::SplitProgramFromArgs(const char* path, kwsys_stl::string& program, kwsys_stl::string& args) { // see if this is a full path to a program // if so then set program to path and args to nothing if(SystemTools::FileExists(path)) { program = path; args = ""; return; } // Try to find the program in the path, note the program // may have spaces in its name so we have to look for it kwsys_stl::vector e; kwsys_stl::string findProg = SystemTools::FindProgram(path, e); if(findProg.size()) { program = findProg; args = ""; return; } // Now try and peel off space separated chunks from the end of the string // so the largest path possible is found allowing for spaces in the path kwsys_stl::string dir = path; kwsys_stl::string::size_type spacePos = dir.rfind(' '); while(spacePos != kwsys_stl::string::npos) { kwsys_stl::string tryProg = dir.substr(0, spacePos); // See if the file exists if(SystemTools::FileExists(tryProg.c_str())) { program = tryProg; // remove trailing spaces from program kwsys_stl::string::size_type pos = program.size()-1; while(program[pos] == ' ') { program.erase(pos); pos--; } args = dir.substr(spacePos, dir.size()-spacePos); return; } // Now try and find the the program in the path findProg = SystemTools::FindProgram(tryProg.c_str(), e); if(findProg.size()) { program = findProg; // remove trailing spaces from program kwsys_stl::string::size_type pos = program.size()-1; while(program[pos] == ' ') { program.erase(pos); pos--; } args = dir.substr(spacePos, dir.size()-spacePos); return; } // move past the space for the next search spacePos--; spacePos = dir.rfind(' ', spacePos); } program = ""; args = ""; } kwsys_stl::string SystemTools::GetCurrentDateTime(const char* format) { char buf[1024]; time_t t; time(&t); strftime(buf, sizeof(buf), format, localtime(&t)); return buf; } kwsys_stl::string SystemTools::MakeCindentifier(const char* s) { kwsys_stl::string str(s); if (str.find_first_of("0123456789") == 0) { str = "_" + str; } kwsys_stl::string permited_chars("_" "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "0123456789"); kwsys_stl::string::size_type pos = 0; while ((pos = str.find_first_not_of(permited_chars, pos)) != kwsys_stl::string::npos) { str[pos] = '_'; } return str; } // Due to a buggy stream library on the HP and another on Mac OSX, we // need this very carefully written version of getline. Returns true // if any data were read before the end-of-file was reached. bool SystemTools::GetLineFromStream(kwsys_ios::istream& is, kwsys_stl::string& line, bool *has_newline /* = 0 */) { const int bufferSize = 1024; char buffer[bufferSize]; line = ""; bool haveData = false; if ( has_newline ) { *has_newline = false; } // If no characters are read from the stream, the end of file has // been reached. while((is.getline(buffer, bufferSize), is.gcount() > 0)) { haveData = true; line.append(buffer); // If newline character was read, the gcount includes the // character, but the buffer does not. The end of line has been // reached. if(strlen(buffer) < static_cast(is.gcount())) { if ( has_newline ) { *has_newline = true; } break; } // The fail bit may be set. Clear it. is.clear(is.rdstate() & ~kwsys_ios::ios::failbit); } return haveData; } int SystemTools::GetTerminalWidth() { int width = -1; #ifndef _WIN32 struct winsize ws; char *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; } columns = getenv("COLUMNS"); if(columns && *columns) { long t; char *endptr; t = strtol(columns, &endptr, 0); if(endptr && !*endptr && (t>0) && (t<1000)) { width = (int)t; } } if ( width < 9 ) { width = -1; } #endif return width; } bool SystemTools::GetPermissions(const char* file, mode_t& mode) { if ( !file ) { return false; } struct stat st; if ( stat(file, &st) < 0 ) { return false; } mode = st.st_mode; return true; } bool SystemTools::SetPermissions(const char* file, mode_t mode) { if ( !file ) { return false; } if ( !SystemTools::FileExists(file) ) { return false; } if ( chmod(file, mode) < 0 ) { return false; } return true; } kwsys_stl::string SystemTools::GetParentDirectory(const char* fileOrDir) { if ( !fileOrDir || !*fileOrDir ) { return ""; } kwsys_stl::string res = fileOrDir; SystemTools::ConvertToUnixSlashes(res); kwsys_stl::string::size_type cc = res.size()-1; if ( res[cc] == '/' ) { cc --; } for ( ; cc > 0; cc -- ) { if ( res[cc] == '/' ) { break; } } return res.substr(0, cc); } bool SystemTools::IsSubDirectory(const char* cSubdir, const char* cDir) { kwsys_stl::string subdir = cSubdir; kwsys_stl::string dir = cDir; SystemTools::ConvertToUnixSlashes(dir); kwsys_stl::string path = subdir; do { path = SystemTools::GetParentDirectory(path.c_str()); if ( dir == path ) { return true; } } while ( path.size() > dir.size() ); return false; } kwsys_stl::string SystemTools::FileExistsInParentDirectories(const char* fname, const char* directory, const char* toplevel) { kwsys_stl::string file = fname; SystemTools::ConvertToUnixSlashes(file); kwsys_stl::string dir = directory; SystemTools::ConvertToUnixSlashes(dir); while ( !dir.empty() ) { kwsys_stl::string path = dir + "/" + file; if ( SystemTools::FileExists(path.c_str()) ) { return path; } if ( dir.size() < strlen(toplevel) ) { break; } dir = SystemTools::GetParentDirectory(dir.c_str()); } return ""; } void SystemTools::Delay(unsigned int msec) { #ifdef _WIN32 Sleep(msec); #else usleep(msec * 1000); #endif } // These must NOT be initialized. Default initialization to zero is // necessary. unsigned int SystemToolsManagerCount; SystemToolsTranslationMap *SystemTools::TranslationMap; // 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(); } } void SystemTools::ClassInitialize() { // Allocate the translation map first. SystemTools::TranslationMap = new SystemToolsTranslationMap; // 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__) // Work-around an SGI problem by always adding this mapping: SystemTools::AddTranslationPath("/tmp_mnt/", "/"); // 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. if(const char* pwd = getenv("PWD")) { char buf[2048]; if(const char* cwd = Getcwd(buf, 2048)) { kwsys_stl::string pwd_path; Realpath(pwd, pwd_path); if(cwd == pwd_path && strcmp(cwd, pwd) != 0) { // The current working directory is a logical path. Split // both the logical and physical paths into their components. kwsys_stl::vector cwd_components; kwsys_stl::vector pwd_components; SystemTools::SplitPath(cwd, cwd_components); SystemTools::SplitPath(pwd, pwd_components); // Remove the common ending of the paths to leave only the // part that changes under the logical mapping. kwsys_stl::vector::iterator ic = cwd_components.end(); kwsys_stl::vector::iterator ip = pwd_components.end(); for(;ip != pwd_components.begin() && ic != cwd_components.begin() && *(ip-1) == *(ic-1); --ip,--ic); cwd_components.erase(ic, cwd_components.end()); pwd_components.erase(ip, pwd_components.end()); // Reconstruct the string versions of the part of the path // that changed. kwsys_stl::string cwd_changed = SystemTools::JoinPath(cwd_components); kwsys_stl::string pwd_changed = SystemTools::JoinPath(pwd_components); // Add the translation to keep the logical path name. if(!cwd_changed.empty() && !pwd_changed.empty()) { SystemTools::AddTranslationPath(cwd_changed.c_str(), pwd_changed.c_str()); } } } } #endif } void SystemTools::ClassFinalize() { delete SystemTools::TranslationMap; } } // namespace KWSYS_NAMESPACE #if defined(_MSC_VER) && defined(_DEBUG) # include # include # include namespace KWSYS_NAMESPACE { static int SystemToolsDebugReport(int, char* message, int*) { fprintf(stderr, message); exit(1); } void SystemTools::EnableMSVCDebugHook() { if(getenv("DART_TEST_FROM_DART")) { _CrtSetReportHook(SystemToolsDebugReport); } } } // namespace KWSYS_NAMESPACE #else namespace KWSYS_NAMESPACE { void SystemTools::EnableMSVCDebugHook() {} } // namespace KWSYS_NAMESPACE #endif