CMake/Source/cmSystemTools.h

301 lines
10 KiB
C
Raw Normal View History

/*=========================================================================
Program: CMake - Cross-Platform Makefile Generator
Module: $RCSfile$
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
2002-01-21 23:30:43 +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 cmSystemTools_h
#define cmSystemTools_h
#include "cmStandardIncludes.h"
2003-06-23 16:58:58 +04:00
#include <cmsys/SystemTools.hxx>
2004-01-27 17:05:01 +03:00
#include <sys/types.h>
2003-06-23 16:58:58 +04:00
2001-01-11 22:47:38 +03:00
/** \class cmSystemTools
* \brief A collection of useful functions for CMake.
*
* cmSystemTools is a class that provides helper functions
* for the CMake build system.
*/
2003-06-23 16:58:58 +04:00
class cmSystemTools: public cmsys::SystemTools
{
public:
typedef cmsys::SystemTools Superclass;
/** Expand out any arguements in the vector that have ; separated
* strings into multiple arguements. A new vector is created
* containing the expanded versions of all arguments in argsIn.
*/
static void ExpandList(std::vector<std::string> const& argsIn,
std::vector<std::string>& argsOut);
static void ExpandListArgument(const std::string& arg,
std::vector<std::string>& argsOut);
/**
* Look for and replace registry values in a string
*/
static void ExpandRegistryValues(std::string& source);
/**
* Platform independent escape spaces, unix uses backslash,
* windows double quotes the string.
*/
static std::string EscapeSpaces(const char* str);
///! Escape quotes in a string.
static std::string EscapeQuotes(const char* str);
/**
* Given a string, replace any escape sequences with the corresponding
* characters.
*/
static std::string RemoveEscapes(const char*);
typedef void (*ErrorCallback)(const char*, const char*, bool&, void*);
2001-10-29 18:19:34 +03:00
/**
* Set the function used by GUI's to display error messages
* Function gets passed: message as a const char*,
* title as a const char*, and a reference to bool that when
* set to false, will disable furthur messages (cancel).
*/
static void SetErrorCallback(ErrorCallback f, void* clientData=0);
2001-10-29 18:19:34 +03:00
/**
* Display an error message.
*/
static void Error(const char* m, const char* m2=0,
const char* m3=0, const char* m4=0);
2001-02-23 03:24:43 +03:00
2001-06-05 00:55:37 +04:00
/**
* Display a message.
*/
static void Message(const char* m, const char* title=0);
///! Send a string to stdout
static void Stdout(const char* s);
static void Stdout(const char* s, int length);
typedef void (*StdoutCallback)(const char*, int length, void*);
static void SetStdoutCallback(StdoutCallback, void* clientData=0);
2001-02-23 03:24:43 +03:00
///! Return true if there was an error at any point.
static bool GetErrorOccuredFlag()
{
return cmSystemTools::s_ErrorOccured || cmSystemTools::s_FatalErrorOccured;
}
///! If this is set to true, cmake stops processing commands.
static void SetFatalErrorOccured()
{
cmSystemTools::s_FatalErrorOccured = true;
}
static void SetErrorOccured()
{
cmSystemTools::s_ErrorOccured = true;
}
///! Return true if there was an error at any point.
static bool GetFatalErrorOccured()
{
return cmSystemTools::s_FatalErrorOccured;
2001-02-23 03:24:43 +03:00
}
///! Set the error occured flag and fatal error back to false
static void ResetErrorOccuredFlag()
{
cmSystemTools::s_FatalErrorOccured = false;
cmSystemTools::s_ErrorOccured = false;
}
2001-02-23 03:24:43 +03:00
2001-04-30 22:56:06 +04:00
/**
* does a string indicate a true or on value ? This is not the same
* as ifdef.
*/
2001-04-26 18:49:12 +04:00
static bool IsOn(const char* val);
2001-02-23 03:24:43 +03:00
2001-04-30 22:56:06 +04:00
/**
* does a string indicate a false or off value ? Note that this is
* not the same as !IsOn(...) because there are a number of
* ambiguous values such as "/usr/local/bin" a path will result in
* IsON and IsOff both returning false. Note that the special path
2003-01-31 21:50:42 +03:00
* NOTFOUND, *-NOTFOUND or IGNORE will cause IsOff to return true.
2001-04-30 22:56:06 +04:00
*/
static bool IsOff(const char* val);
2001-04-30 22:56:06 +04:00
2003-01-31 21:50:42 +03:00
///! Return true if value is NOTFOUND or ends in -NOTFOUND.
static bool IsNOTFOUND(const char* value);
2003-06-19 22:27:01 +04:00
static bool DoesFileExistWithExtensions(
const char *name,
const std::vector<std::string>& sourceExts);
2001-06-21 20:01:18 +04:00
static void Glob(const char *directory, const char *regexp,
std::vector<std::string>& files);
static void GlobDirs(const char *fullPath, std::vector<std::string>& files);
/**
* Try to find a list of files that match the "simple" globbing
* expression. At this point in time the globbing expressions have
* to be in form: /directory/partial_file_name*. The * character has
* to be at the end of the string and it does not support ?
* []... The optional argument type specifies what kind of files you
* want to find. 0 means all files, -1 means directories, 1 means
* files only. This method returns true if search was succesfull.
*/
static bool SimpleGlob(const cmStdString& glob, std::vector<cmStdString>& files,
int type = 0);
2001-06-21 20:01:18 +04:00
2003-06-23 16:58:58 +04:00
///! Copy a file.
static bool cmCopyFile(const char* source, const char* destination);
static bool CopyFileIfDifferent(const char* source,
const char* destination);
2001-02-23 03:24:43 +03:00
/**
* Run an executable command and put the stdout in output.
* A temporary file is created in the binaryDir for storing the
* output because windows does not have popen.
*
* If verbose is false, no user-viewable output from the program
* being run will be generated.
*
* If timeout is specified, the command will be terminated after
* timeout expires.
*/
static bool RunCommand(const char* command, std::string& output,
const char* directory = 0,
bool verbose = true, int timeout = 0);
2001-08-23 19:12:19 +04:00
static bool RunCommand(const char* command, std::string& output,
int &retVal, const char* directory = 0,
2003-06-23 16:58:58 +04:00
bool verbose = true, int timeout = 0);
/**
* Run a single executable command and put the stdout and stderr
* in output.
*
* If verbose is false, no user-viewable output from the program
* being run will be generated.
*
* If timeout is specified, the command will be terminated after
* timeout expires. Timeout is specified in seconds.
*
* Argument retVal should be a pointer to the location where the
* exit code will be stored. If the retVal is not specified and
* the program exits with a code other than 0, then the this
* function will return false.
*/
static bool RunSingleCommand(const char* command, std::string* output = 0,
int* retVal = 0, const char* dir = 0, bool verbose = true, double timeout = 0.0);
/**
* Parse arguments out of a single string command
*/
static std::vector<cmStdString> ParseArguments(const char* command);
2001-06-22 01:53:15 +04:00
static void EnableMessages() { s_DisableMessages = false; }
static void DisableMessages() { s_DisableMessages = true; }
static void DisableRunCommandOutput() {s_DisableRunCommandOutput = true; }
static void EnableRunCommandOutput() {s_DisableRunCommandOutput = false; }
static bool GetRunCommandOutput() { return s_DisableRunCommandOutput; }
/**
* Come constants for different file formats.
*/
enum FileFormat {
NO_FILE_FORMAT = 0,
C_FILE_FORMAT,
CXX_FILE_FORMAT,
2004-08-06 22:51:41 +04:00
FORTRAN_FILE_FORMAT,
JAVA_FILE_FORMAT,
HEADER_FILE_FORMAT,
RESOURCE_FILE_FORMAT,
DEFINITION_FILE_FORMAT,
STATIC_LIBRARY_FILE_FORMAT,
SHARED_LIBRARY_FILE_FORMAT,
MODULE_FILE_FORMAT,
OBJECT_FILE_FORMAT,
UNKNOWN_FILE_FORMAT
};
/**
* Determine the file type based on the extension
*/
static FileFormat GetFileFormat(const char* ext);
/**
* On Windows 9x we need a comspec (command.com) substitute to run
* programs correctly. This string has to be constant available
* through the running of program. This method does not create a copy.
*/
static void SetWindows9xComspecSubstitute(const char*);
static const char* GetWindows9xComspecSubstitute();
/** Windows if this is true, the CreateProcess in RunCommand will
* not show new consol windows when running programs.
*/
static void SetRunCommandHideConsole(bool v){s_RunCommandHideConsole = v;}
static bool GetRunCommandHideConsole(){ return s_RunCommandHideConsole;}
2003-02-06 06:26:55 +03:00
/** Call cmSystemTools::Error with the message m, plus the
* result of strerror(errno)
*/
static void ReportLastSystemError(const char* m);
2003-06-23 16:58:58 +04:00
/** 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, std::vector<cmStdString>& l);
static void SetForceUnixPaths(bool v)
{
s_ForceUnixPaths = v;
}
static bool GetForceUnixPaths()
{
return s_ForceUnixPaths;
}
// ConvertToOutputPath use s_ForceUnixPaths
static std::string ConvertToOutputPath(const char* path);
// ConvertToRunCommandPath does not use s_ForceUnixPaths and should
// be used when RunCommand is called from cmake, because the
// running cmake needs paths to be in its format
static std::string ConvertToRunCommandPath(const char* path);
//! Check if the first string ends with the second one.
static bool StringEndsWith(const char* str1, const char* str2);
2003-11-26 22:52:12 +03:00
static bool CreateSymlink(const char* origName, const char* newName);
///! compute the relative path from local to remote
static std::string RelativePath(const char* local, const char* remote);
///! split a path by separator into an array of strings, default is /
static std::vector<cmStdString> SplitString(const char* s, char separator = '/');
2004-01-26 21:32:46 +03:00
/** put a string into the environment
of the form var=value */
static bool PutEnv(const char* value);
///! Get permissions of the file
static bool GetPermissions(const char* file, mode_t& mode);
static bool SetPermissions(const char* file, mode_t mode);
2001-02-23 03:24:43 +03:00
private:
static bool s_ForceUnixPaths;
static bool s_RunCommandHideConsole;
2001-02-23 03:24:43 +03:00
static bool s_ErrorOccured;
static bool s_FatalErrorOccured;
static bool s_DisableMessages;
static bool s_DisableRunCommandOutput;
2001-10-29 18:19:34 +03:00
static ErrorCallback s_ErrorCallback;
static StdoutCallback s_StdoutCallback;
static void* s_ErrorCallbackClientData;
static void* s_StdoutCallbackClientData;
static std::string s_Windows9xComspecSubstitute;
};
#endif