Source/cmLocalGenerator.h

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmLocalGenerator.h,v $
   5   Language:  C++
   6   Date:      $Date: 2008-10-09 19:30:07 $
   7   Version:   $Revision: 1.106 $
   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 cmLocalGenerator_h
  18 #define cmLocalGenerator_h
  19
  20 #include "cmStandardIncludes.h"
  21
  22 class cmMakefile;
  23 class cmGlobalGenerator;
  24 class cmTarget;
  25 class cmTargetManifest;
  26 class cmSourceFile;
  27 class cmCustomCommand;
  28
  29 /** \class cmLocalGenerator
  30  * \brief Create required build files for a directory.
  31  *
  32  * Subclasses of this abstract class generate makefiles, DSP, etc for various
  33  * platforms. This class should never be constructued directly. A
  34  * GlobalGenerator will create it and invoke the appropriate commands on it.
  35  */
  36 class cmLocalGenerator
  37 {
  38 public:
  39   cmLocalGenerator();
  40   virtual ~cmLocalGenerator();
  41
  42   /**
  43    * Generate the makefile for this directory.
  44    */
  45   virtual void Generate() {}
  46
  47   /**
  48    * Process the CMakeLists files for this directory to fill in the
  49    * Makefile ivar
  50    */
  51   virtual void Configure();
  52
  53   /**
  54    * Calls TraceVSDependencies() on all targets of this generator.
  55    */
  56   virtual void TraceDependencies();
  57
  58   virtual void AddHelperCommands() {}
  59
  60   /**
  61    * Perform any final calculations prior to generation
  62    */
  63   virtual void ConfigureFinalPass();
  64
  65   /**
  66    * Generate the install rules files in this directory.
  67    */
  68   virtual void GenerateInstallRules();
  69
  70   /**
  71    * Generate the test files for tests.
  72    */
  73   virtual void GenerateTestFiles();
  74
  75   /**
  76    * Generate a manifest of target files that will be built.
  77    */
  78   virtual void GenerateTargetManifest();
  79
  80   ///! Get the makefile for this generator
  81   cmMakefile *GetMakefile() {
  82     return this->Makefile; };
  83
  84   ///! Get the makefile for this generator, const version
  85     const cmMakefile *GetMakefile() const {
  86       return this->Makefile; };
  87
  88   ///! Get the GlobalGenerator this is associated with
  89   cmGlobalGenerator *GetGlobalGenerator() {
  90     return this->GlobalGenerator; };
  91
  92   ///! Set the Global Generator, done on creation by the GlobalGenerator
  93   void SetGlobalGenerator(cmGlobalGenerator *gg);
  94
  95   /**
  96    * Convert something to something else. This is a centralized coversion
  97    * routine used by the generators to handle relative paths and the like.
  98    * The flags determine what is actually done.
  99    *
 100    * relative: treat the argument as a directory and convert it to make it
 101    * relative or full or unchanged. If relative (HOME, START etc) then that
 102    * specifies what it should be relative to.
 103    *
 104    * output: make the result suitable for output to a...
 105    *
 106    * optional: should any relative path operation be controlled by the rel
 107    * path setting
 108    */
 109   enum RelativeRoot { NONE, FULL, HOME, START, HOME_OUTPUT, START_OUTPUT };
 110   enum OutputFormat { UNCHANGED, MAKEFILE, SHELL };
 111   std::string ConvertToOutputFormat(const char* source, OutputFormat output);
 112   std::string Convert(const char* remote, RelativeRoot local,
 113                       OutputFormat output = UNCHANGED,
 114                       bool optional = false);
 115   std::string Convert(RelativeRoot remote, const char* local,
 116                       OutputFormat output = UNCHANGED,
 117                       bool optional = false);
 118
 119   /**
 120     * Get path for the specified relative root.
 121     */
 122   const char* GetRelativeRootPath(RelativeRoot relroot);
 123
 124   /**
 125    * Convert the given path to an output path that is optionally
 126    * relative based on the cache option CMAKE_USE_RELATIVE_PATHS.  The
 127    * remote path must use forward slashes and not already be escaped
 128    * or quoted.
 129    */
 130   std::string ConvertToOptionallyRelativeOutputPath(const char* remote);
 131
 132   ///! set/get the parent generator
 133   cmLocalGenerator* GetParent(){return this->Parent;}
 134   void SetParent(cmLocalGenerator* g) { this->Parent = g; g->AddChild(this); }
 135
 136   ///! set/get the children
 137   void AddChild(cmLocalGenerator* g) { this->Children.push_back(g); }
 138   std::vector<cmLocalGenerator*>& GetChildren() { return this->Children; };
 139
 140
 141   void AddLanguageFlags(std::string& flags, const char* lang,
 142                         const char* config);
 143   void AddSharedFlags(std::string& flags, const char* lang, bool shared);
 144   void AddConfigVariableFlags(std::string& flags, const char* var,
 145                               const char* config);
 146   virtual void AppendFlags(std::string& flags, const char* newFlags);
 147   ///! Get the include flags for the current makefile and language
 148   const char* GetIncludeFlags(const char* lang);
 149
 150   /**
 151    * Encode a list of preprocessor definitions for the compiler
 152    * command line.
 153    */
 154   void AppendDefines(std::string& defines, const char* defines_list,
 155                      const char* lang);
 156
 157   /** Translate a dependency as given in CMake code to the name to
 158       appear in a generated build file.  If the given name is that of
 159       a CMake target it will be transformed to the real output
 160       location of that target for the given configuration.  If the
 161       given name is the full path to a file it will be returned.
 162       Otherwise the name is treated as a relative path with respect to
 163       the source directory of this generator.  This should only be
 164       used for dependencies of custom commands.  */
 165   std::string GetRealDependency(const char* name, const char* config);
 166
 167   /** Translate a command as given in CMake code to the location of the
 168       executable if the command is the name of a CMake executable target.
 169       If that's not the case, just return the original name. */
 170   std::string GetRealLocation(const char* inName, const char* config);
 171
 172   ///! for existing files convert to output path and short path if spaces
 173   std::string ConvertToOutputForExisting(const char* remote,
 174                                          RelativeRoot local = START_OUTPUT);
 175
 176   /** For existing path identified by RelativeRoot convert to output
 177       path and short path if spaces.  */
 178   std::string ConvertToOutputForExisting(RelativeRoot remote,
 179                                          const char* local = 0);
 180
 181   /** Called from command-line hook to clear dependencies.  */
 182   virtual void ClearDependencies(cmMakefile* /* mf */,
 183                                  bool /* verbose */) {}
 184
 185   /** Called from command-line hook to update dependencies.  */
 186   virtual bool UpdateDependencies(const char* /* tgtInfo */,
 187                                   bool /*verbose*/,
 188                                   bool /*color*/)
 189     { return true; }
 190
 191   /** Get the include flags for the current makefile and language.  */
 192   void GetIncludeDirectories(std::vector<std::string>& dirs,
 193                              bool filter_system_dirs = true);
 194
 195   /** Compute the language used to compile the given source file.  */
 196   const char* GetSourceFileLanguage(const cmSourceFile& source);
 197
 198   // Create a struct to hold the varibles passed into
 199   // ExpandRuleVariables
 200   struct RuleVariables
 201   {
 202     RuleVariables()
 203       {
 204         memset(this, 0,  sizeof(*this));
 205       }
 206     const char* TargetPDB;
 207     const char* TargetVersionMajor;
 208     const char* TargetVersionMinor;
 209     const char* Language;
 210     const char* Objects;
 211     const char* Target;
 212     const char* LinkLibraries;
 213     const char* Source;
 214     const char* AssemblySource;
 215     const char* PreprocessedSource;
 216     const char* Object;
 217     const char* ObjectDir;
 218     const char* Flags;
 219     const char* ObjectsQuoted;
 220     const char* TargetSOName;
 221     const char* TargetInstallNameDir;
 222     const char* LinkFlags;
 223     const char* LanguageCompileFlags;
 224     const char* Defines;
 225   };
 226
 227   /** Set whether to treat conversions to SHELL as a link script shell.  */
 228   void SetLinkScriptShell(bool b) { this->LinkScriptShell = b; }
 229
 230   /** Escape the given string to be used as a command line argument in
 231       the native build system shell.  Optionally allow the build
 232       system to replace make variable references.  Optionally adjust
 233       escapes for the special case of passing to the native echo
 234       command.  */
 235   std::string EscapeForShell(const char* str, bool makeVars = false,
 236                              bool forEcho = false);
 237
 238   /** Backwards-compatibility version of EscapeForShell.  */
 239   std::string EscapeForShellOldStyle(const char* str);
 240
 241   /** Escape the given string as an argument in a CMake script.  */
 242   std::string EscapeForCMake(const char* str);
 243
 244   /** Return the directories into which object files will be put.
 245    *  There maybe more than one for fat binary systems like OSX.
 246    */
 247   virtual void
 248   GetTargetObjectFileDirectories(cmTarget* target,
 249                                  std::vector<std::string>&
 250                                  dirs);
 251
 252   /**
 253    * Convert the given remote path to a relative path with respect to
 254    * the given local path.  The local path must be given in component
 255    * form (see SystemTools::SplitPath) without a trailing slash.  The
 256    * remote path must use forward slashes and not already be escaped
 257    * or quoted.
 258    */
 259   std::string ConvertToRelativePath(const std::vector<std::string>& local,
 260                                     const char* remote);
 261
 262   /**
 263    * Get the relative path from the generator output directory to a
 264    * per-target support directory.
 265    */
 266   virtual std::string GetTargetDirectory(cmTarget const& target) const;
 267
 268   /**
 269    * Get the level of backwards compatibility requested by the project
 270    * in this directory.  This is the value of the CMake variable
 271    * CMAKE_BACKWARDS_COMPATIBILITY whose format is
 272    * "major.minor[.patch]".  The returned integer is encoded as
 273    *
 274    *   CMake_VERSION_ENCODE(major, minor, patch)
 275    *
 276    * and is monotonically increasing with the CMake version.
 277    */
 278   unsigned int GetBackwardsCompatibility();
 279
 280   /**
 281    * Test whether compatibility is set to a given version or lower.
 282    */
 283   bool NeedBackwardsCompatibility(unsigned int major,
 284                                   unsigned int minor,
 285                                   unsigned int patch = 0xFFu);
 286
 287   /**
 288    * Generate a Mac OS X application bundle Info.plist file.
 289    */
 290   void GenerateAppleInfoPList(cmTarget* target, const char* targetName,
 291                               const char* fname);
 292
 293   /**
 294    * Generate a Mac OS X framework Info.plist file.
 295    */
 296   void GenerateFrameworkInfoPList(cmTarget* target,
 297                                   const char* targetName,
 298                                   const char* fname);
 299 protected:
 300   /** Construct a comment for a custom command.  */
 301   std::string ConstructComment(const cmCustomCommand& cc,
 302                                const char* default_comment = "");
 303
 304   /** Fill out these strings for the given target.  Libraries to link,
 305    *  flags, and linkflags. */
 306   void GetTargetFlags(std::string& linkLibs,
 307                       std::string& flags,
 308                       std::string& linkFlags,
 309                       cmTarget&target);
 310
 311   ///! put all the libraries for a target on into the given stream
 312   virtual void OutputLinkLibraries(std::ostream&, cmTarget&, bool relink);
 313
 314   // Expand rule variables in CMake of the type found in language rules
 315   void ExpandRuleVariables(std::string& string,
 316                            const RuleVariables& replaceValues);
 317   // Expand rule variables in a single string
 318   std::string ExpandRuleVariable(std::string const& variable,
 319                                  const RuleVariables& replaceValues);
 320
 321   /** Convert a target to a utility target for unsupported
 322    *  languages of a generator */
 323   void AddBuildTargetRule(const char* llang, cmTarget& target);
 324   ///! add a custom command to build a .o file that is part of a target
 325   void AddCustomCommandToCreateObject(const char* ofname,
 326                                       const char* lang,
 327                                       cmSourceFile& source,
 328                                       cmTarget& target);
 329   // Create Custom Targets and commands for unsupported languages
 330   // The set passed in should contain the languages supported by the
 331   // generator directly.  Any targets containing files that are not
 332   // of the types listed will be compiled as custom commands and added
 333   // to a custom target.
 334   void CreateCustomTargetsAndCommands(std::set<cmStdString> const&);
 335
 336   // Handle old-style install rules stored in the targets.
 337   void GenerateTargetInstallRules(
 338     std::ostream& os, const char* config,
 339     std::vector<std::string> const& configurationTypes);
 340
 341   // Compute object file names.
 342   std::string GetObjectFileNameWithoutTarget(const cmSourceFile& source,
 343                                              std::string::size_type dir_len,
 344                                              bool* hasSourceExtension = 0);
 345   std::string& CreateSafeUniqueObjectFileName(const char* sin,
 346                                               std::string::size_type dir_len);
 347
 348   void ConfigureRelativePaths();
 349   std::string FindRelativePathTopSource();
 350   std::string FindRelativePathTopBinary();
 351   void SetupPathConversions();
 352
 353   std::string ConvertToLinkReference(std::string const& lib);
 354
 355   /** Check whether the native build system supports the given
 356       definition.  Issues a warning.  */
 357   virtual bool CheckDefinition(std::string const& define) const;
 358
 359   cmMakefile *Makefile;
 360   cmGlobalGenerator *GlobalGenerator;
 361   // members used for relative path function ConvertToMakefilePath
 362   std::string RelativePathToSourceDir;
 363   std::string RelativePathToBinaryDir;
 364   std::vector<std::string> HomeDirectoryComponents;
 365   std::vector<std::string> StartDirectoryComponents;
 366   std::vector<std::string> HomeOutputDirectoryComponents;
 367   std::vector<std::string> StartOutputDirectoryComponents;
 368   cmLocalGenerator* Parent;
 369   std::vector<cmLocalGenerator*> Children;
 370   std::map<cmStdString, cmStdString> LanguageToIncludeFlags;
 371   std::map<cmStdString, cmStdString> UniqueObjectNamesMap;
 372   std::string::size_type ObjectPathMax;
 373   bool WindowsShell;
 374   bool WindowsVSIDE;
 375   bool WatcomWMake;
 376   bool MinGWMake;
 377   bool NMake;
 378   bool ForceUnixPath;
 379   bool MSYSShell;
 380   bool LinkScriptShell;
 381   bool UseRelativePaths;
 382   bool IgnoreLibPrefix;
 383   bool Configured;
 384   bool EmitUniversalBinaryFlags;
 385   // A type flag is not nice. It's used only in TraceDependencies().
 386   bool IsMakefileGenerator;
 387   // Hack for ExpandRuleVariable until object-oriented version is
 388   // committed.
 389   std::string TargetImplib;
 390
 391   // The top-most directories for relative path conversion.  Both the
 392   // source and destination location of a relative path conversion
 393   // must be underneath one of these directories (both under source or
 394   // both under binary) in order for the relative path to be evaluated
 395   // safely by the build tools.
 396   std::string RelativePathTopSource;
 397   std::string RelativePathTopBinary;
 398   bool RelativePathsConfigured;
 399   bool PathConversionsSetup;
 400
 401   unsigned int BackwardsCompatibility;
 402   bool BackwardsCompatibilityFinal;
 403 private:
 404   std::string ConvertToOutputForExistingCommon(const char* remote,
 405                                                std::string const& result);
 406 };
 407
 408 #endif