Source/cmSystemTools.h

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmSystemTools.h,v $
   5   Language:  C++
   6   Date:      $Date: 2009-02-05 21:31:36 $
   7   Version:   $Revision: 1.157 $
   8
   9   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  10   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  11
  12      This software is distributed WITHOUT ANY WARRANTY; without even
  13      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14      PURPOSE.  See the above copyright notices for more information.
  15
  16 =========================================================================*/
  17 #ifndef cmSystemTools_h
  18 #define cmSystemTools_h
  19
  20 #include "cmStandardIncludes.h"
  21
  22 #include <cmsys/SystemTools.hxx>
  23 #include <cmsys/Process.h>
  24
  25 class cmSystemToolsFileTime;
  26
  27 /** \class cmSystemTools
  28  * \brief A collection of useful functions for CMake.
  29  *
  30  * cmSystemTools is a class that provides helper functions
  31  * for the CMake build system.
  32  */
  33 class cmSystemTools: public cmsys::SystemTools
  34 {
  35 public:
  36   typedef cmsys::SystemTools Superclass;
  37
  38   /** Expand out any arguements in the vector that have ; separated
  39    *  strings into multiple arguements.  A new vector is created
  40    *  containing the expanded versions of all arguments in argsIn.
  41    */
  42   static void ExpandList(std::vector<std::string> const& argsIn,
  43                          std::vector<std::string>& argsOut);
  44   static void ExpandListArgument(const std::string& arg,
  45                                  std::vector<std::string>& argsOut,
  46                                  bool emptyArgs=false);
  47
  48   /**
  49    * Look for and replace registry values in a string
  50    */
  51   static void ExpandRegistryValues(std::string& source,
  52                                    KeyWOW64 view = KeyWOW64_Default);
  53
  54   /**
  55    * Platform independent escape spaces, unix uses backslash,
  56    * windows double quotes the string.
  57    */
  58   static std::string EscapeSpaces(const char* str);
  59
  60   ///! Escape quotes in a string.
  61   static std::string EscapeQuotes(const char* str);
  62
  63   /**
  64    * Given a string, replace any escape sequences with the corresponding
  65    * characters.
  66    */
  67   static std::string RemoveEscapes(const char*);
  68
  69   typedef  void (*ErrorCallback)(const char*, const char*, bool&, void*);
  70   /**
  71    *  Set the function used by GUI's to display error messages
  72    *  Function gets passed: message as a const char*,
  73    *  title as a const char*, and a reference to bool that when
  74    *  set to false, will disable furthur messages (cancel).
  75    */
  76   static void SetErrorCallback(ErrorCallback f, void* clientData=0);
  77
  78   /**
  79    * Display an error message.
  80    */
  81   static void Error(const char* m, const char* m2=0,
  82                     const char* m3=0, const char* m4=0);
  83
  84   /**
  85    * Display a message.
  86    */
  87   static void Message(const char* m, const char* title=0);
  88
  89   ///! Send a string to stdout
  90   static void Stdout(const char* s);
  91   static void Stdout(const char* s, int length);
  92   typedef  void (*StdoutCallback)(const char*, int length, void*);
  93   static void SetStdoutCallback(StdoutCallback, void* clientData=0);
  94
  95   ///! Return true if there was an error at any point.
  96   static bool GetErrorOccuredFlag()
  97     {
  98       return cmSystemTools::s_ErrorOccured ||
  99         cmSystemTools::s_FatalErrorOccured;
 100     }
 101   ///! If this is set to true, cmake stops processing commands.
 102   static void SetFatalErrorOccured()
 103     {
 104       cmSystemTools::s_FatalErrorOccured = true;
 105     }
 106   static void SetErrorOccured()
 107     {
 108       cmSystemTools::s_ErrorOccured = true;
 109     }
 110  ///! Return true if there was an error at any point.
 111   static bool GetFatalErrorOccured()
 112     {
 113       return cmSystemTools::s_FatalErrorOccured;
 114     }
 115
 116   ///! Set the error occured flag and fatal error back to false
 117   static void ResetErrorOccuredFlag()
 118     {
 119       cmSystemTools::s_FatalErrorOccured = false;
 120       cmSystemTools::s_ErrorOccured = false;
 121     }
 122
 123   /**
 124    * does a string indicate a true or on value ? This is not the same
 125    * as ifdef.
 126    */
 127   static bool IsOn(const char* val);
 128
 129   /**
 130    * does a string indicate a false or off value ? Note that this is
 131    * not the same as !IsOn(...) because there are a number of
 132    * ambiguous values such as "/usr/local/bin" a path will result in
 133    * IsON and IsOff both returning false. Note that the special path
 134    * NOTFOUND, *-NOTFOUND or IGNORE will cause IsOff to return true.
 135    */
 136   static bool IsOff(const char* val);
 137
 138   ///! Return true if value is NOTFOUND or ends in -NOTFOUND.
 139   static bool IsNOTFOUND(const char* value);
 140   ///! Return true if the path is a framework
 141   static bool IsPathToFramework(const char* value);
 142
 143   static bool DoesFileExistWithExtensions(
 144     const char *name,
 145     const std::vector<std::string>& sourceExts);
 146
 147   static void Glob(const char *directory, const char *regexp,
 148                    std::vector<std::string>& files);
 149   static void GlobDirs(const char *fullPath, std::vector<std::string>& files);
 150
 151   /**
 152    * Try to find a list of files that match the "simple" globbing
 153    * expression. At this point in time the globbing expressions have
 154    * to be in form: /directory/partial_file_name*. The * character has
 155    * to be at the end of the string and it does not support ?
 156    * []... The optional argument type specifies what kind of files you
 157    * want to find. 0 means all files, -1 means directories, 1 means
 158    * files only. This method returns true if search was succesfull.
 159    */
 160   static bool SimpleGlob(const cmStdString& glob,
 161                          std::vector<cmStdString>& files,
 162                          int type = 0);
 163
 164   ///! Copy a file.
 165   static bool cmCopyFile(const char* source, const char* destination);
 166   static bool CopyFileIfDifferent(const char* source,
 167     const char* destination);
 168
 169   ///! Compute the md5sum of a file
 170   static bool ComputeFileMD5(const char* source, char* md5out);
 171
 172   /** Compute the md5sum of a string.  */
 173   static std::string ComputeStringMD5(const char* input);
 174
 175   /**
 176    * Run an executable command and put the stdout in output.
 177    * A temporary file is created in the binaryDir for storing the
 178    * output because windows does not have popen.
 179    *
 180    * If verbose is false, no user-viewable output from the program
 181    * being run will be generated.
 182    *
 183    * If timeout is specified, the command will be terminated after
 184    * timeout expires.
 185    */
 186   static bool RunCommand(const char* command, std::string& output,
 187                          const char* directory = 0,
 188                          bool verbose = true, int timeout = 0);
 189   static bool RunCommand(const char* command, std::string& output,
 190                          int &retVal, const char* directory = 0,
 191                          bool verbose = true, int timeout = 0);
 192   /**
 193    * Run a single executable command and put the stdout and stderr
 194    * in output.
 195    *
 196    * If verbose is false, no user-viewable output from the program
 197    * being run will be generated.
 198    *
 199    * If timeout is specified, the command will be terminated after
 200    * timeout expires. Timeout is specified in seconds.
 201    *
 202    * Argument retVal should be a pointer to the location where the
 203    * exit code will be stored. If the retVal is not specified and
 204    * the program exits with a code other than 0, then the this
 205    * function will return false.
 206    *
 207    * If the command has spaces in the path the caller MUST call
 208    * cmSystemTools::ConvertToRunCommandPath on the command before passing
 209    * it into this function or it will not work.  The command must be correctly
 210    * escaped for this to with spaces.
 211    */
 212   static bool RunSingleCommand(const char* command, std::string* output = 0,
 213                                int* retVal = 0, const char* dir = 0,
 214                                bool verbose = true,
 215                                double timeout = 0.0);
 216   /**
 217    * In this version of RunSingleCommand, command[0] should be
 218    * the command to run, and each argument to the command should
 219    * be in comand[1]...command[command.size()]
 220    */
 221   static bool RunSingleCommand(std::vector<cmStdString> const& command,
 222                                std::string* output = 0,
 223                                int* retVal = 0, const char* dir = 0,
 224                                bool verbose = true,
 225                                double timeout = 0.0);
 226
 227   /**
 228    * Parse arguments out of a single string command
 229    */
 230   static std::vector<cmStdString> ParseArguments(const char* command);
 231
 232   /** Parse arguments out of a windows command line string.  */
 233   static void ParseWindowsCommandLine(const char* command,
 234                                       std::vector<std::string>& args);
 235
 236   /** Compute an escaped version of the given argument for use in a
 237       windows shell.  See kwsys/System.h.in for details.  */
 238   static std::string EscapeWindowsShellArgument(const char* arg,
 239                                                 int shell_flags);
 240
 241   static void EnableMessages() { s_DisableMessages = false; }
 242   static void DisableMessages() { s_DisableMessages = true; }
 243   static void DisableRunCommandOutput() {s_DisableRunCommandOutput = true; }
 244   static void EnableRunCommandOutput() {s_DisableRunCommandOutput = false; }
 245   static bool GetRunCommandOutput() { return s_DisableRunCommandOutput; }
 246
 247   /**
 248    * Come constants for different file formats.
 249    */
 250   enum FileFormat {
 251     NO_FILE_FORMAT = 0,
 252     C_FILE_FORMAT,
 253     CXX_FILE_FORMAT,
 254     FORTRAN_FILE_FORMAT,
 255     JAVA_FILE_FORMAT,
 256     HEADER_FILE_FORMAT,
 257     RESOURCE_FILE_FORMAT,
 258     DEFINITION_FILE_FORMAT,
 259     STATIC_LIBRARY_FILE_FORMAT,
 260     SHARED_LIBRARY_FILE_FORMAT,
 261     MODULE_FILE_FORMAT,
 262     OBJECT_FILE_FORMAT,
 263     UNKNOWN_FILE_FORMAT
 264   };
 265
 266   /**
 267    * Determine the file type based on the extension
 268    */
 269   static FileFormat GetFileFormat(const char* ext);
 270
 271   /**
 272    * On Windows 9x we need a comspec (command.com) substitute to run
 273    * programs correctly. This string has to be constant available
 274    * through the running of program. This method does not create a copy.
 275    */
 276   static void SetWindows9xComspecSubstitute(const char*);
 277   static const char* GetWindows9xComspecSubstitute();
 278
 279   /** Windows if this is true, the CreateProcess in RunCommand will
 280    *  not show new consol windows when running programs.
 281    */
 282   static void SetRunCommandHideConsole(bool v){s_RunCommandHideConsole = v;}
 283   static bool GetRunCommandHideConsole(){ return s_RunCommandHideConsole;}
 284   /** Call cmSystemTools::Error with the message m, plus the
 285    * result of strerror(errno)
 286    */
 287   static void ReportLastSystemError(const char* m);
 288
 289   /** a general output handler for cmsysProcess  */
 290   static int WaitForLine(cmsysProcess* process, std::string& line,
 291                          double timeout,
 292                          std::vector<char>& out,
 293                          std::vector<char>& err);
 294
 295   /** Split a string on its newlines into multiple lines.  Returns
 296       false only if the last line stored had no newline.  */
 297   static bool Split(const char* s, std::vector<cmStdString>& l);
 298   static void SetForceUnixPaths(bool v)
 299     {
 300       s_ForceUnixPaths = v;
 301     }
 302   static bool GetForceUnixPaths()
 303     {
 304       return s_ForceUnixPaths;
 305     }
 306
 307   // ConvertToOutputPath use s_ForceUnixPaths
 308   static std::string ConvertToOutputPath(const char* path);
 309   static void ConvertToOutputSlashes(std::string& path);
 310
 311   // ConvertToRunCommandPath does not use s_ForceUnixPaths and should
 312   // be used when RunCommand is called from cmake, because the
 313   // running cmake needs paths to be in its format
 314   static std::string ConvertToRunCommandPath(const char* path);
 315   //! Check if the first string ends with the second one.
 316   static bool StringEndsWith(const char* str1, const char* str2);
 317
 318   /** compute the relative path from local to remote.  local must
 319       be a directory.  remote can be a file or a directory.
 320       Both remote and local must be full paths.  Basically, if
 321       you are in directory local and you want to access the file in remote
 322       what is the relative path to do that.  For example:
 323       /a/b/c/d to /a/b/c1/d1 -> ../../c1/d1
 324       from /usr/src to /usr/src/test/blah/foo.cpp -> test/blah/foo.cpp
 325   */
 326   static std::string RelativePath(const char* local, const char* remote);
 327
 328   /** Put a string into the environment
 329       of the form var=value */
 330   static bool PutEnv(const char* value);
 331
 332 #ifdef CMAKE_BUILD_WITH_CMAKE
 333   /** Remove an environment variable */
 334   static bool UnsetEnv(const char* value);
 335
 336   /** Get the list of all environment variables */
 337   static std::vector<std::string> GetEnvironmentVariables();
 338
 339   /** Append multiple variables to the current environment.
 340       Return the original environment, as it was before the
 341       append. */
 342   static std::vector<std::string> AppendEnv(
 343     std::vector<std::string>* env);
 344
 345   /** Restore the full environment to "env" - use after
 346       AppendEnv to put the environment back to the way it
 347       was. */
 348   static void RestoreEnv(const std::vector<std::string>& env);
 349 #endif
 350
 351   /** Setup the environment to enable VS 8 IDE output.  */
 352   static void EnableVSConsoleOutput();
 353
 354   /** Create tar */
 355   static bool ListTar(const char* outFileName,
 356                       std::vector<cmStdString>& files,
 357                       bool gzip, bool verbose);
 358   static bool CreateTar(const char* outFileName,
 359                         const std::vector<cmStdString>& files, bool gzip,
 360                         bool verbose);
 361   static bool ExtractTar(const char* inFileName,
 362                          const std::vector<cmStdString>& files, bool gzip,
 363                          bool verbose);
 364   // This should be called first thing in main
 365   // it will keep child processes from inheriting the
 366   // stdin and stdout of this process.  This is important
 367   // if you want to be able to kill child processes and
 368   // not get stuck waiting for all the output on the pipes.
 369   static void DoNotInheritStdPipes();
 370
 371   /** Copy the file create/access/modify times from the file named by
 372       the first argument to that named by the second.  */
 373   static bool CopyFileTime(const char* fromFile, const char* toFile);
 374
 375   /** Save and restore file times.  */
 376   static cmSystemToolsFileTime* FileTimeNew();
 377   static void FileTimeDelete(cmSystemToolsFileTime*);
 378   static bool FileTimeGet(const char* fname, cmSystemToolsFileTime* t);
 379   static bool FileTimeSet(const char* fname, cmSystemToolsFileTime* t);
 380
 381   /** Find the directory containing the running executable.  Save it
 382    in a global location to be queried by GetExecutableDirectory
 383    later.  */
 384   static void FindExecutableDirectory(const char* argv0);
 385
 386   /** Get the directory containing the currently running executable.  */
 387   static const char* GetExecutableDirectory();
 388
 389 #if defined(CMAKE_BUILD_WITH_CMAKE)
 390   /** Echo a message in color using KWSys's Terminal cprintf.  */
 391   static void MakefileColorEcho(int color, const char* message,
 392                                 bool newLine, bool enabled);
 393 #endif
 394
 395   /** Try to guess the soname of a shared library.  */
 396   static bool GuessLibrarySOName(std::string const& fullPath,
 397                                  std::string& soname);
 398
 399   /** Try to set the RPATH in an ELF binary.  */
 400   static bool ChangeRPath(std::string const& file,
 401                           std::string const& oldRPath,
 402                           std::string const& newRPath,
 403                           std::string* emsg = 0,
 404                           bool* changed = 0);
 405
 406   /** Try to remove the RPATH from an ELF binary.  */
 407   static bool RemoveRPath(std::string const& file, std::string* emsg = 0,
 408                           bool* removed = 0);
 409
 410   /** Check whether the RPATH in an ELF binary contains the path
 411       given.  */
 412   static bool CheckRPath(std::string const& file,
 413                          std::string const& newRPath);
 414
 415 private:
 416   static bool s_ForceUnixPaths;
 417   static bool s_RunCommandHideConsole;
 418   static bool s_ErrorOccured;
 419   static bool s_FatalErrorOccured;
 420   static bool s_DisableMessages;
 421   static bool s_DisableRunCommandOutput;
 422   static ErrorCallback s_ErrorCallback;
 423   static StdoutCallback s_StdoutCallback;
 424   static void* s_ErrorCallbackClientData;
 425   static void* s_StdoutCallbackClientData;
 426
 427   static std::string s_Windows9xComspecSubstitute;
 428 };
 429
 430 #endif