CMake/Source/kwsys/SystemTools.hxx.in

437 lines
15 KiB
C++
Raw Normal View History

/*=========================================================================
Program: KWSys - Kitware System Library
Module: $RCSfile$
2003-12-16 00:30:46 +03:00
Copyright (c) Kitware, Inc., Insight Consortium. All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
2003-12-16 00:30:46 +03:00
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@/ios/iosfwd>
#include <@KWSYS_NAMESPACE@/stl/string>
#include <@KWSYS_NAMESPACE@/stl/vector>
#include <@KWSYS_NAMESPACE@/stl/map>
2003-06-30 18:30:38 +04:00
#include <@KWSYS_NAMESPACE@/Configure.h>
#include <sys/types.h>
2004-09-29 21:21:21 +04:00
#if defined( _MSC_VER )
typedef unsigned short mode_t;
#endif
/* Define these macros temporarily to keep the code readable. */
#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
# define kwsys_stl @KWSYS_NAMESPACE@_stl
# define kwsys_ios @KWSYS_NAMESPACE@_ios
#endif
namespace @KWSYS_NAMESPACE@
{
class SystemToolsTranslationMap;
2004-10-26 16:45:27 +04:00
class @KWSYS_NAMESPACE@_EXPORT SystemToolsManager
{
public:
SystemToolsManager();
~SystemToolsManager();
};
// This instance will show up in any translation unit that uses
// SystemTools. It will make sure SystemTools is initialized
// before it is used and is the last static object destroyed.
static SystemToolsManager SystemToolsManagerInstance;
/** \class SystemTools
* \brief A collection of useful platform-independent system functions.
*/
2003-06-30 18:30:38 +04:00
class @KWSYS_NAMESPACE@_EXPORT 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_stl::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_stl::string& source,
const char* replace,
const char* with);
/**
* Read a registry value
*/
static bool ReadRegistryValue(const char *key, kwsys_stl::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_stl::string Capitalized(const kwsys_stl::string&);
/**
* Return a lower case string
*/
static kwsys_stl::string LowerCase(const kwsys_stl::string&);
/**
* Return a lower case string
*/
static kwsys_stl::string UpperCase(const kwsys_stl::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_stl::string& path);
/**
* For windows this calles ConvertToWindowsOutputPath and for unix
* it calls ConvertToUnixOutputPath
*/
static kwsys_stl::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);
/** Compare file modification times.
Returns true for successful comparison and false for error.
When true is returned, result has -1, 0, +1 for
f1 older, same, or newer than f2. */
static bool FileTimeCompare(const char* f1, const char* f2,
int* result);
/**
* Add the paths from the environment variable PATH to the
* string vector passed in. If env is set then the value
* of env will be used instead of PATH.
*/
static void GetPath(kwsys_stl::vector<kwsys_stl::string>& path, const char* env=0);
2003-12-16 23:55:18 +03:00
/** Read an environment variable. */
static const char* GetEnv(const char* key);
static bool GetEnv(const char* key, kwsys_stl::string& result);
2003-12-16 23:55:18 +03:00
/**
* 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);
///! Copy content directory to another directory with all files and subdirectories
static bool CopyADirectory(const char* source, const char* destination);
///! Remove a file.
static bool RemoveFile(const char* source);
///! Remove a directory
static bool RemoveADirectory(const char* source);
///! Find a file in the system PATH, with optional extra paths.
static kwsys_stl::string FindFile(const char* name,
const kwsys_stl::vector<kwsys_stl::string>& path= kwsys_stl::vector<kwsys_stl::string>());
///! Find an executable in the system PATH, with optional extra paths.
static kwsys_stl::string FindProgram(const char* name,
const kwsys_stl::vector<kwsys_stl::string>& path = kwsys_stl::vector<kwsys_stl::string>(),
bool no_system_path = false);
///! Find a library in the system PATH, with optional extra paths.
static kwsys_stl::string FindLibrary(const char* name,
const kwsys_stl::vector<kwsys_stl::string>& path);
///! return true if the file is a directory.
static bool FileIsDirectory(const char* name);
static kwsys_stl::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_stl::string GetProgramPath(const char*);
static bool SplitProgramPath(const char* in_name,
kwsys_stl::string& dir,
kwsys_stl::string& file,
bool errorReport = true);
/**
* Given argv[0] for a unix program find the full path to a running
* executable. argv0 can be null for windows WinMain programs
* in this case GetModuleFileName will be used to find the path
* to the running executable. If argv0 is not a full path,
* then this will try to find the full path. If the path is not
* found false is returned, if found true is returned. An error
* message of the attempted paths is stored in errorMsg.
* exeName is the name of the executable.
* buildDir is a possibly null path to the build directory.
* installPrefix is a possibly null pointer to the install directory.
*/
static bool FindProgramPath(const char* argv0,
kwsys_stl::string& pathOut,
kwsys_stl::string& errorMsg,
const char* exeName = 0,
const char* buildDir = 0,
const char* installPrefix = 0);
/**
* 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_stl::string CollapseFullPath(const char* in_relative);
static kwsys_stl::string CollapseFullPath(const char* in_relative,
const char* in_base);
/**
* Split a path name into its basic components. The first component
* is one of the following roots:
* "/" = UNIX
* "c:/" = Windows full path (can be any drive letter)
* "c:" = Windows drive-letter relative path (can be any drive letter)
* "//" = Network path
* "" = Relative path
* The remaining components form the path. If there is a trailing
* slash then the last component is the empty string. The
* components can be recombined as "c[0]c[1]/c[2]/.../c[n]" to
* produce the original path. The input is assumed to be formatted
* with forward slashes.
*/
static void SplitPath(const char* p,
kwsys_stl::vector<kwsys_stl::string>& components);
/**
* Join components of a path name into a single string. See
* SplitPath for the format of the components.
*/
static kwsys_stl::string
JoinPath(const kwsys_stl::vector<kwsys_stl::string>& components);
2005-02-24 22:47:45 +03:00
/**
* Compare a path or components of a path.
*/
static bool ComparePath(const char* c1, const char* c2);
///! return path of a full filename (no trailing slashes).
static kwsys_stl::string GetFilenamePath(const kwsys_stl::string&);
///! return file name of a full filename (i.e. file name without path).
static kwsys_stl::string GetFilenameName(const kwsys_stl::string&);
///! Split a program from its arguments and handle spaces in the paths.
static void SplitProgramFromArgs(const char* path,
kwsys_stl::string& program, kwsys_stl::string& args);
2003-06-23 16:56:22 +04:00
///! return longest file extension of a full filename (dot included).
static kwsys_stl::string GetFilenameExtension(const kwsys_stl::string&);
2003-06-23 16:56:22 +04:00
///! return shortest file extension of a full filename (dot included).
static kwsys_stl::string GetFilenameLastExtension(const kwsys_stl::string& filename);
2003-06-23 16:56:22 +04:00
///! return file name without extension of a full filename.
static kwsys_stl::string GetFilenameWithoutExtension(const kwsys_stl::string&);
///! return file name without its last (shortest) extension.
static kwsys_stl::string GetFilenameWithoutLastExtension(const kwsys_stl::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_stl::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_stl::vector<kwsys_stl::string>& l);
static kwsys_stl::string GetCurrentDateTime(const char* format);
/** Get the result of strerror(errno). */
static kwsys_stl::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. If the has_newline argument is specified, it will
* be true when the line read had a newline character.
*/
static bool GetLineFromStream(kwsys_ios::istream& istr, kwsys_stl::string& line,
bool* has_newline=0);
/**
* Get the width of the terminal window. The code may or may not work, so
* make sure you have some resonable defaults prepared if the code returns
* some bogus size.
*/
static int GetTerminalWidth();
/**
* Add an entry in the path translation table.
*/
static void AddTranslationPath(const char * dir, const char * refdir);
/**
* If dir is different after CollapseFullPath is called,
* Then insert it into the path translation table
*/
static void AddKeepPath(const char* dir);
/**
* Update path by going through the Path Translation table;
*/
static void CheckTranslationPath(kwsys_stl::string & path);
/**
* Get and set permissions of the file.
*/
static bool GetPermissions(const char* file, mode_t& mode);
static bool SetPermissions(const char* file, mode_t mode);
/** Get the parent directory of the directory or file */
static kwsys_stl::string GetParentDirectory(const char* fileOrDir);
/** Check if the given file or directory is in subdirectory of dir */
static bool IsSubDirectory(const char* fileOrDir, const char* dir);
/** Check if the given file exists in one of the parent directory of the
* given file or directory and if it does, return the name of the file.
* Toplevel specifies the top-most directory to where it will look.*/
static kwsys_stl::string FileExistsInParentDirectories(const char* fname,
const char* directory, const char* toplevel);
2005-01-04 18:55:01 +03:00
/** Delay the execution for a specified amount of time specified in miliseconds */
static void Delay(unsigned int msec);
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_stl::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_stl::string ConvertToWindowsOutputPath(const char*);
private:
/**
* Allocate the std::map that serve as the Path Translation table.
*/
static void ClassInitialize();
/**
* Deallocate the std::map that serve as the Path Translation table.
*/
static void ClassFinalize();
2004-10-26 16:45:27 +04:00
/**
* This method prevents warning on SGI
*/
SystemToolsManager* GetSystemToolsManager()
{
return &SystemToolsManagerInstance;
}
/**
* Path translation table from dir to refdir
* Each time 'dir' will be found it will be replace by 'refdir'
*/
static SystemToolsTranslationMap *TranslationMap;
friend class SystemToolsManager;
};
} // namespace @KWSYS_NAMESPACE@
/* Undefine temporary macros. */
#if !defined (KWSYS_NAMESPACE) && !@KWSYS_NAMESPACE@_NAME_IS_KWSYS
# undef kwsys_stl
# undef kwsys_ios
#endif
#endif