Source/cmSystemTools.h

   1 /*=========================================================================
   2
   3   Program:   Insight Segmentation & Registration Toolkit
   4   Module:    $RCSfile: cmSystemTools.h,v $
   5   Language:  C++
   6   Date:      $Date: 2002-07-15 13:45:47 $
   7   Version:   $Revision: 1.65 $
   8
   9   Copyright (c) 2002 Insight Consortium. All rights reserved.
  10   See ITKCopyright.txt or http://www.itk.org/HTML/Copyright.htm 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 class cmMakefile;
  23
  24 /** \class cmSystemTools
  25  * \brief A collection of useful functions for CMake.
  26  *
  27  * cmSystemTools is a class that provides helper functions
  28  * for the CMake build system.
  29  */
  30 class cmSystemTools
  31 {
  32 public:
  33   /**
  34    * Make a new directory if it is not there.  This function
  35    * can make a full path even if none of the directories existed
  36    * prior to calling this function.
  37    */
  38   static bool MakeDirectory(const char* path);
  39
  40   /**
  41    * Replace replace all occurances of the string in
  42    * the source string.
  43    */
  44   static void ReplaceString(std::string& source,
  45                             const char* replace,
  46                             const char* with);
  47
  48   /** Expand out any arguements in the vector that have ; separated
  49    *  strings into multiple arguements.  A new vector is created
  50    *  containing the expanded versions of all arguments in argsIn.
  51    */
  52   static void ExpandListArguments(std::vector<std::string> const& argsIn,
  53                                   std::vector<std::string>& argsOut);
  54
  55   /**
  56    * Read a registry value
  57    */
  58   static bool ReadRegistryValue(const char *key, std::string &value);
  59
  60   /**
  61    * Write a registry value
  62    */
  63   static bool WriteRegistryValue(const char *key, const char *value);
  64
  65   /**
  66    * Delete a registry value
  67    */
  68   static bool DeleteRegistryValue(const char *key);
  69
  70   /**
  71    * Look for and replace registry values in a string
  72    */
  73   static void ExpandRegistryValues(std::string& source);
  74
  75   /**
  76    * Return a capitalized string (i.e the first letter is uppercased, all other
  77    * are lowercased).
  78    */
  79   static std::string Capitalized(const std::string&);
  80
  81   /**
  82    * Return a lower case string
  83    */
  84   static std::string LowerCase(const std::string&);
  85
  86   /**
  87    * Return a lower case string
  88    */
  89   static std::string UpperCase(const std::string&);
  90
  91   /**
  92    * Replace Windows file system slashes with Unix-style slashes.
  93    */
  94   static void ConvertToUnixSlashes(std::string& path);
  95
  96   /**
  97    * Platform independent escape spaces, unix uses backslash,
  98    * windows double quotes the string.
  99    */
 100   static std::string EscapeSpaces(const char* str);
 101
 102   ///! Escape quotes in a string.
 103   static std::string EscapeQuotes(const char* str);
 104
 105   /**
 106    * For windows this calles ConvertToWindowsOutputPath and for unix
 107    * it calls ConvertToUnixOutputPath
 108    */
 109   static std::string ConvertToOutputPath(const char*);
 110
 111   ///! Return true if a file exists in the current directory.
 112   static bool FileExists(const char* filename);
 113
 114   /**
 115    * Read a CMake command (or function) from an input file.  This
 116    * returns the name of the function and a list of its
 117    * arguments.  The last argument is the name of the file that
 118    * the ifstream points to, and is used for debug info only.
 119    */
 120   static bool ParseFunction(std::ifstream&,
 121                             std::string& name,
 122                             std::vector<std::string>& arguments,
 123                             const char* filename, bool& parseError);
 124
 125   /**
 126    *  Extract white-space separated arguments from a string.
 127    *  Double quoted strings are accepted with spaces.
 128    *  This is called by ParseFunction.
 129    */
 130   static void GetArguments(std::string& line,
 131                            std::vector<std::string>& arguments);
 132
 133   /**
 134    * Given a string, replace any escape sequences with the corresponding
 135    * characters.
 136    */
 137   static std::string RemoveEscapes(const char*);
 138
 139
 140   /**
 141    *  Add the paths from the environment variable PATH to the
 142    *  string vector passed in.
 143    */
 144   static void GetPath(std::vector<std::string>& path);
 145
 146   /**
 147    *  Get the file extension (including ".") needed for an executable
 148    *  on the current platform ("" for unix, ".exe" for Windows).
 149    */
 150   static const char* GetExecutableExtension();
 151
 152   typedef  void (*ErrorCallback)(const char*, const char*, bool&);
 153   /**
 154    *  Set the function used by GUI's to display error messages
 155    *  Function gets passed: message as a const char*,
 156    *  title as a const char*, and a reference to bool that when
 157    *  set to false, will disable furthur messages (cancel).
 158    */
 159   static void SetErrorCallback(ErrorCallback f);
 160
 161   /**
 162    * Display an error message.
 163    */
 164   static void Error(const char* m, const char* m2=0,
 165                     const char* m3=0, const char* m4=0);
 166
 167   /**
 168    * Display a message.
 169    */
 170   static void Message(const char* m, const char* title=0);
 171
 172   ///! Return true if there was an error at any point.
 173   static bool GetErrorOccuredFlag()
 174     {
 175       return cmSystemTools::s_ErrorOccured;
 176     }
 177
 178   ///! Set the error occured flag back to false
 179   static void ResetErrorOccuredFlag()
 180     {
 181       cmSystemTools::s_ErrorOccured = false;
 182     }
 183
 184   /**
 185    * Copy the source file to the destination file only
 186    * if the two files differ.
 187    */
 188   static bool CopyFileIfDifferent(const char* source,
 189                                   const char* destination);
 190
 191   ///! Compare the contents of two files.  Return true if different.
 192   static bool FilesDiffer(const char* source,
 193                           const char* destination);
 194   ///! return true if the two files are the same file
 195   static bool SameFile(const char* file1, const char* file2);
 196
 197   ///! Copy a file.
 198   static void cmCopyFile(const char* source,
 199                        const char* destination);
 200
 201   ///! Remove a file.
 202   static bool RemoveFile(const char* source);
 203
 204   /**
 205    * does a string indicate a true or on value ? This is not the same
 206    * as ifdef.
 207    */
 208   static bool IsOn(const char* val);
 209
 210   /**
 211    * does a string indicate a false or off value ? Note that this is
 212    * not the same as !IsOn(...) because there are a number of
 213    * ambiguous values such as "/usr/local/bin" a path will result in
 214    * IsON and IsOff both returning false. Note that the special path
 215    * NOTFOUND or IGNORE will cause IsOff to return true.
 216    */
 217   static bool IsOff(const char* val);
 218
 219   ///! Find a file in the system PATH, with optional extra paths.
 220   static std::string FindFile(const char* name,
 221                                  const std::vector<std::string>& path= std::vector<std::string>());
 222
 223   ///! Find an executable in the system PATH, with optional extra paths.
 224   static std::string FindProgram(const char* name,
 225                                  const std::vector<std::string>& path = std::vector<std::string>(),
 226                                  bool no_system_path = false);
 227
 228   ///! Find a library in the system PATH, with optional extra paths.
 229   static std::string FindLibrary(const char* name,
 230                                  const std::vector<std::string>& path,
 231                                  const cmMakefile *makefile = 0);
 232
 233   ///! return true if the file is a directory.
 234   static bool FileIsDirectory(const char* name);
 235   static void Glob(const char *directory, const char *regexp,
 236                    std::vector<std::string>& files);
 237   static void GlobDirs(const char *fullPath, std::vector<std::string>& files);
 238
 239   static std::string GetCurrentWorkingDirectory();
 240   static std::string GetProgramPath(const char*);
 241   static void SplitProgramPath(const char* in_name,
 242                                std::string& dir,
 243                                std::string& file);
 244   static std::string CollapseFullPath(const char*);
 245
 246   ///! return path of a full filename (no trailing slashes).
 247   static std::string GetFilenamePath(const std::string&);
 248
 249   ///! return file name of a full filename (i.e. file name without path).
 250   static std::string GetFilenameName(const std::string&);
 251
 252   ///! return file extension of a full filename (dot included).
 253   static std::string GetFilenameExtension(const std::string&);
 254
 255   ///! return file name without extension of a full filename.
 256   static std::string GetFilenameWithoutExtension(const std::string&);
 257
 258   ///! return file name without its last (shortest) extension.
 259   static std::string GetFilenameWithoutLastExtension(const std::string&);
 260
 261   static long int ModifiedTime(const char* filename);
 262
 263   /**
 264    * Run an executable command and put the stdout in output.
 265    * A temporary file is created in the binaryDir for storing the
 266    * output because windows does not have popen.
 267    *
 268    * If verbose is false, no user-viewable output from the program
 269    * being run will be generated.
 270    */
 271   static bool RunCommand(const char* command, std::string& output, const char* directory = 0,
 272                          bool verbose = true);
 273   static bool RunCommand(const char* command, std::string& output,
 274                          int &retVal, const char* directory = 0, bool verbose = true);
 275
 276   ///! for windows return the short path for the given path, unix just a pass through
 277   static bool GetShortPath(const char* path, std::string& result);
 278
 279   ///! change directory the the directory specified
 280   static int ChangeDirectory(const char* dir);
 281
 282   static void EnableMessages() { s_DisableMessages = false; }
 283   static void DisableMessages() { s_DisableMessages = true; }
 284   static void DisableRunCommandOutput() {s_DisableRunCommandOutput = true; }
 285   static void EnableRunCommandOutput() {s_DisableRunCommandOutput = false; }
 286 protected:
 287   // these two functions can be called from ConvertToOutputPath
 288   /**
 289    * Convert the path to a string that can be used in a unix makefile.
 290    * double slashes are removed, and spaces are escaped.
 291    */
 292   static std::string ConvertToUnixOutputPath(const char*);
 293
 294   /**
 295    * Convert the path to string that can be used in a windows project or
 296    * makefile.   Double slashes are removed if they are not at the start of
 297    * the string, the slashes are converted to windows style backslashes, and
 298    * if there are spaces in the string it is double quoted.
 299    */
 300   static std::string ConvertToWindowsOutputPath(const char*);
 301
 302
 303 private:
 304   static bool s_ErrorOccured;
 305   static bool s_DisableMessages;
 306   static bool s_DisableRunCommandOutput;
 307   static ErrorCallback s_ErrorCallback;
 308 };
 309
 310
 311 #endif