275 lines
9.7 KiB
C++
275 lines
9.7 KiB
C++
/*=========================================================================
|
|
|
|
Program: KWSys - Kitware System Library
|
|
Module: $RCSfile$
|
|
Language: C++
|
|
Date: $Date$
|
|
Version: $Revision$
|
|
|
|
Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
|
|
See http://www.cmake.org/HTML/Copyright.html 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.
|
|
|
|
=========================================================================*/
|
|
#ifndef @KWSYS_NAMESPACE@_SystemTools_hxx
|
|
#define @KWSYS_NAMESPACE@_SystemTools_hxx
|
|
|
|
#include <@KWSYS_NAMESPACE@/std/iosfwd>
|
|
#include <@KWSYS_NAMESPACE@/std/string>
|
|
#include <@KWSYS_NAMESPACE@/std/vector>
|
|
|
|
/* Define this macro temporarily to keep the code readable. */
|
|
#if !defined (KWSYS_NAMESPACE) && !defined(@KWSYS_NAMESPACE@_NAME_IS_KWSYS)
|
|
# define kwsys_std @KWSYS_NAMESPACE@_std
|
|
#endif
|
|
|
|
namespace @KWSYS_NAMESPACE@
|
|
{
|
|
|
|
/** \class SystemTools
|
|
* \brief A collection of useful platform-independent system functions.
|
|
*/
|
|
class SystemTools
|
|
{
|
|
public:
|
|
/**
|
|
* Replace symbols in str that are not valid in C identifiers as
|
|
* defined by the 1999 standard, ie. anything except [A-Za-z0-9_].
|
|
* They are replaced with `_' and if the first character is a digit
|
|
* then an underscore is prepended. Note that this can produce
|
|
* identifiers that the standard reserves (_[A-Z].* and __.*).
|
|
*/
|
|
static kwsys_std::string MakeCindentifier(const char* s);
|
|
|
|
/**
|
|
* Make a new directory if it is not there. This function
|
|
* can make a full path even if none of the directories existed
|
|
* prior to calling this function.
|
|
*/
|
|
static bool MakeDirectory(const char* path);
|
|
|
|
/**
|
|
* Get current time as a double. On certain platforms this will
|
|
* return higher resolution than seconds:
|
|
* (1) gettimeofday() -- resolution in microseconds
|
|
* (2) ftime() -- resolution in milliseconds
|
|
* (3) time() -- resolution in seconds
|
|
*/
|
|
static double GetTime();
|
|
|
|
/**
|
|
* Replace replace all occurances of the string in
|
|
* the source string.
|
|
*/
|
|
static void ReplaceString(kwsys_std::string& source,
|
|
const char* replace,
|
|
const char* with);
|
|
|
|
/**
|
|
* Read a registry value
|
|
*/
|
|
static bool ReadRegistryValue(const char *key, kwsys_std::string &value);
|
|
|
|
/**
|
|
* Write a registry value
|
|
*/
|
|
static bool WriteRegistryValue(const char *key, const char *value);
|
|
|
|
/**
|
|
* Delete a registry value
|
|
*/
|
|
static bool DeleteRegistryValue(const char *key);
|
|
|
|
/**
|
|
* Return a capitalized string (i.e the first letter is uppercased,
|
|
* all other are lowercased).
|
|
*/
|
|
static kwsys_std::string Capitalized(const kwsys_std::string&);
|
|
|
|
/**
|
|
* Return a lower case string
|
|
*/
|
|
static kwsys_std::string LowerCase(const kwsys_std::string&);
|
|
|
|
/**
|
|
* Return a lower case string
|
|
*/
|
|
static kwsys_std::string UpperCase(const kwsys_std::string&);
|
|
|
|
/**
|
|
* do a case-independent string comparison
|
|
*/
|
|
static int Strucmp(const char *s1, const char *s2);
|
|
|
|
/**
|
|
* Replace Windows file system slashes with Unix-style slashes.
|
|
*/
|
|
static void ConvertToUnixSlashes(kwsys_std::string& path);
|
|
|
|
/**
|
|
* For windows this calles ConvertToWindowsOutputPath and for unix
|
|
* it calls ConvertToUnixOutputPath
|
|
*/
|
|
static kwsys_std::string ConvertToOutputPath(const char*);
|
|
|
|
/** Return true if a file exists in the current directory. */
|
|
static bool FileExists(const char* filename);
|
|
|
|
static unsigned long FileLength(const char *filename);
|
|
/**
|
|
* Add the paths from the environment variable PATH to the
|
|
* string vector passed in.
|
|
*/
|
|
static void GetPath(kwsys_std::vector<kwsys_std::string>& path);
|
|
|
|
/**
|
|
* Get the file extension (including ".") needed for an executable
|
|
* on the current platform ("" for unix, ".exe" for Windows).
|
|
*/
|
|
static const char* GetExecutableExtension();
|
|
|
|
/**
|
|
* Copy the source file to the destination file only
|
|
* if the two files differ.
|
|
*/
|
|
static bool CopyFileIfDifferent(const char* source,
|
|
const char* destination);
|
|
|
|
///! Compare the contents of two files. Return true if different.
|
|
static bool FilesDiffer(const char* source,
|
|
const char* destination);
|
|
|
|
///! return true if the two files are the same file
|
|
static bool SameFile(const char* file1, const char* file2);
|
|
|
|
///! Copy a file.
|
|
static bool CopyFileAlways(const char* source, const char* destination);
|
|
|
|
///! Remove a file.
|
|
static bool RemoveFile(const char* source);
|
|
|
|
///! Find a file in the system PATH, with optional extra paths.
|
|
static kwsys_std::string FindFile(const char* name,
|
|
const kwsys_std::vector<kwsys_std::string>& path= kwsys_std::vector<kwsys_std::string>());
|
|
|
|
///! Find an executable in the system PATH, with optional extra paths.
|
|
static kwsys_std::string FindProgram(const char* name,
|
|
const kwsys_std::vector<kwsys_std::string>& path = kwsys_std::vector<kwsys_std::string>(),
|
|
bool no_system_path = false);
|
|
|
|
///! Find a library in the system PATH, with optional extra paths.
|
|
static kwsys_std::string FindLibrary(const char* name,
|
|
const kwsys_std::vector<kwsys_std::string>& path);
|
|
|
|
///! return true if the file is a directory.
|
|
static bool FileIsDirectory(const char* name);
|
|
|
|
static kwsys_std::string GetCurrentWorkingDirectory();
|
|
|
|
/**
|
|
* Given the path to a program executable, get the directory part of
|
|
* the path with the file stripped off. If there is no directory
|
|
* part, the empty string is returned.
|
|
*/
|
|
static kwsys_std::string GetProgramPath(const char*);
|
|
static bool SplitProgramPath(const char* in_name,
|
|
kwsys_std::string& dir,
|
|
kwsys_std::string& file,
|
|
bool errorReport = true);
|
|
|
|
/**
|
|
* Given a path to a file or directory, convert it to a full path.
|
|
* This collapses away relative paths relative to the cwd argument
|
|
* (which defaults to the current working directory). The full path
|
|
* is returned.
|
|
*/
|
|
static kwsys_std::string CollapseFullPath(const char* in_relative);
|
|
static kwsys_std::string CollapseFullPath(const char* in_relative,
|
|
const char* in_base);
|
|
|
|
///! return path of a full filename (no trailing slashes).
|
|
static kwsys_std::string GetFilenamePath(const kwsys_std::string&);
|
|
|
|
|
|
///! return file name of a full filename (i.e. file name without path).
|
|
static kwsys_std::string GetFilenameName(const kwsys_std::string&);
|
|
|
|
///! Split a program from its arguments and handle spaces in the paths.
|
|
static void SplitProgramFromArgs(const char* path,
|
|
kwsys_std::string& program, kwsys_std::string& args);
|
|
|
|
///! return longest file extension of a full filename (dot included).
|
|
static kwsys_std::string GetFilenameExtension(const kwsys_std::string&);
|
|
|
|
///! return shortest file extension of a full filename (dot included).
|
|
static kwsys_std::string GetFilenameLastExtension(const kwsys_std::string& filename);
|
|
|
|
///! return file name without extension of a full filename.
|
|
static kwsys_std::string GetFilenameWithoutExtension(const kwsys_std::string&);
|
|
|
|
///! return file name without its last (shortest) extension.
|
|
static kwsys_std::string GetFilenameWithoutLastExtension(const kwsys_std::string&);
|
|
|
|
/** Return whether the path represents a full path (not relative). */
|
|
static bool FileIsFullPath(const char*);
|
|
|
|
static long int ModifiedTime(const char* filename);
|
|
|
|
///! for windows return the short path for the given path, unix just a pass through
|
|
static bool GetShortPath(const char* path, kwsys_std::string& result);
|
|
|
|
///! change directory the the directory specified
|
|
static int ChangeDirectory(const char* dir);
|
|
|
|
/** Split a string on its newlines into multiple lines. Returns
|
|
false only if the last line stored had no newline. */
|
|
static bool Split(const char* s, kwsys_std::vector<kwsys_std::string>& l);
|
|
|
|
static kwsys_std::string GetCurrentDateTime(const char* format);
|
|
|
|
/** Get the result of strerror(errno). */
|
|
static kwsys_std::string GetLastSystemError();
|
|
|
|
/** When building DEBUG with MSVC, this enables a hook that prevents
|
|
* error dialogs from popping up if the program is being run from
|
|
* DART.
|
|
*/
|
|
static void EnableMSVCDebugHook();
|
|
|
|
/**
|
|
* Read line from file. Make sure to get everything. 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.
|
|
*/
|
|
static bool GetLineFromStream(kwsys_std::istream& istr, kwsys_std::string& line);
|
|
|
|
protected:
|
|
// these two functions can be called from ConvertToOutputPath
|
|
/**
|
|
* Convert the path to a string that can be used in a unix makefile.
|
|
* double slashes are removed, and spaces are escaped.
|
|
*/
|
|
static kwsys_std::string ConvertToUnixOutputPath(const char*);
|
|
|
|
/**
|
|
* Convert the path to string that can be used in a windows project or
|
|
* makefile. Double slashes are removed if they are not at the start of
|
|
* the string, the slashes are converted to windows style backslashes, and
|
|
* if there are spaces in the string it is double quoted.
|
|
*/
|
|
static kwsys_std::string ConvertToWindowsOutputPath(const char*);
|
|
};
|
|
|
|
} // namespace @KWSYS_NAMESPACE@
|
|
|
|
/* Undefine temporary macro. */
|
|
#if !defined (KWSYS_NAMESPACE) && !defined(@KWSYS_NAMESPACE@_NAME_IS_KWSYS)
|
|
# undef kwsys_std
|
|
#endif
|
|
|
|
#endif
|