Source/cmLocalGenerator.h

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmLocalGenerator.h,v $
   5   Language:  C++
   6   Date:      $Date: 2009-09-22 20:16:56 $
   7   Version:   $Revision: 1.117 $
   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                              const char* lang = "C");
 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     cmTarget* CMTarget;
 207     const char* TargetPDB;
 208     const char* TargetVersionMajor;
 209     const char* TargetVersionMinor;
 210     const char* Language;
 211     const char* Objects;
 212     const char* Target;
 213     const char* LinkLibraries;
 214     const char* Source;
 215     const char* AssemblySource;
 216     const char* PreprocessedSource;
 217     const char* Output;
 218     const char* Object;
 219     const char* ObjectDir;
 220     const char* Flags;
 221     const char* ObjectsQuoted;
 222     const char* TargetSOName;
 223     const char* TargetInstallNameDir;
 224     const char* LinkFlags;
 225     const char* LanguageCompileFlags;
 226     const char* Defines;
 227     const char* RuleLauncher;
 228   };
 229
 230   /** Set whether to treat conversions to SHELL as a link script shell.  */
 231   void SetLinkScriptShell(bool b) { this->LinkScriptShell = b; }
 232
 233   /** Escape the given string to be used as a command line argument in
 234       the native build system shell.  Optionally allow the build
 235       system to replace make variable references.  Optionally adjust
 236       escapes for the special case of passing to the native echo
 237       command.  */
 238   std::string EscapeForShell(const char* str, bool makeVars = false,
 239                              bool forEcho = false);
 240
 241   /** Backwards-compatibility version of EscapeForShell.  */
 242   std::string EscapeForShellOldStyle(const char* str);
 243
 244   /** Escape the given string as an argument in a CMake script.  */
 245   std::string EscapeForCMake(const char* str);
 246
 247   /** Return the directories into which object files will be put.
 248    *  There maybe more than one for fat binary systems like OSX.
 249    */
 250   virtual void
 251   GetTargetObjectFileDirectories(cmTarget* target,
 252                                  std::vector<std::string>&
 253                                  dirs);
 254
 255   /**
 256    * Convert the given remote path to a relative path with respect to
 257    * the given local path.  The local path must be given in component
 258    * form (see SystemTools::SplitPath) without a trailing slash.  The
 259    * remote path must use forward slashes and not already be escaped
 260    * or quoted.
 261    */
 262   std::string ConvertToRelativePath(const std::vector<std::string>& local,
 263                                     const char* remote, bool force=false);
 264
 265   /**
 266    * Get the relative path from the generator output directory to a
 267    * per-target support directory.
 268    */
 269   virtual std::string GetTargetDirectory(cmTarget const& target) const;
 270
 271   /**
 272    * Get the level of backwards compatibility requested by the project
 273    * in this directory.  This is the value of the CMake variable
 274    * CMAKE_BACKWARDS_COMPATIBILITY whose format is
 275    * "major.minor[.patch]".  The returned integer is encoded as
 276    *
 277    *   CMake_VERSION_ENCODE(major, minor, patch)
 278    *
 279    * and is monotonically increasing with the CMake version.
 280    */
 281   unsigned int GetBackwardsCompatibility();
 282
 283   /**
 284    * Test whether compatibility is set to a given version or lower.
 285    */
 286   bool NeedBackwardsCompatibility(unsigned int major,
 287                                   unsigned int minor,
 288                                   unsigned int patch = 0xFFu);
 289
 290   /**
 291    * Generate a Mac OS X application bundle Info.plist file.
 292    */
 293   void GenerateAppleInfoPList(cmTarget* target, const char* targetName,
 294                               const char* fname);
 295
 296   /**
 297    * Generate a Mac OS X framework Info.plist file.
 298    */
 299   void GenerateFrameworkInfoPList(cmTarget* target,
 300                                   const char* targetName,
 301                                   const char* fname);
 302   /** Construct a comment for a custom command.  */
 303   std::string ConstructComment(const cmCustomCommand& cc,
 304                                const char* default_comment = "");
 305   // Compute object file names.
 306   std::string GetObjectFileNameWithoutTarget(const cmSourceFile& source,
 307                                              std::string const& dir_max,
 308                                              bool* hasSourceExtension = 0);
 309
 310 protected:
 311   /** Fill out these strings for the given target.  Libraries to link,
 312    *  flags, and linkflags. */
 313   void GetTargetFlags(std::string& linkLibs,
 314                       std::string& flags,
 315                       std::string& linkFlags,
 316                       cmTarget&target);
 317
 318   ///! put all the libraries for a target on into the given stream
 319   virtual void OutputLinkLibraries(std::ostream&, cmTarget&, bool relink);
 320
 321   // Expand rule variables in CMake of the type found in language rules
 322   void ExpandRuleVariables(std::string& string,
 323                            const RuleVariables& replaceValues);
 324   // Expand rule variables in a single string
 325   std::string ExpandRuleVariable(std::string const& variable,
 326                                  const RuleVariables& replaceValues);
 327
 328   const char* GetRuleLauncher(cmTarget* target, const char* prop);
 329   void InsertRuleLauncher(std::string& s, cmTarget* target,
 330                           const char* prop);
 331
 332
 333   /** Convert a target to a utility target for unsupported
 334    *  languages of a generator */
 335   void AddBuildTargetRule(const char* llang, cmTarget& target);
 336   ///! add a custom command to build a .o file that is part of a target
 337   void AddCustomCommandToCreateObject(const char* ofname,
 338                                       const char* lang,
 339                                       cmSourceFile& source,
 340                                       cmTarget& target);
 341   // Create Custom Targets and commands for unsupported languages
 342   // The set passed in should contain the languages supported by the
 343   // generator directly.  Any targets containing files that are not
 344   // of the types listed will be compiled as custom commands and added
 345   // to a custom target.
 346   void CreateCustomTargetsAndCommands(std::set<cmStdString> const&);
 347
 348   // Handle old-style install rules stored in the targets.
 349   void GenerateTargetInstallRules(
 350     std::ostream& os, const char* config,
 351     std::vector<std::string> const& configurationTypes);
 352
 353   std::string& CreateSafeUniqueObjectFileName(const char* sin,
 354                                               std::string const& dir_max);
 355   void ComputeObjectMaxPath();
 356
 357   void ConfigureRelativePaths();
 358   std::string FindRelativePathTopSource();
 359   std::string FindRelativePathTopBinary();
 360   void SetupPathConversions();
 361
 362   std::string ConvertToLinkReference(std::string const& lib);
 363
 364   /** Check whether the native build system supports the given
 365       definition.  Issues a warning.  */
 366   virtual bool CheckDefinition(std::string const& define) const;
 367
 368   /** Read the input CMakeLists.txt file.  */
 369   void ReadInputFile();
 370
 371   cmMakefile *Makefile;
 372   cmGlobalGenerator *GlobalGenerator;
 373   // members used for relative path function ConvertToMakefilePath
 374   std::string RelativePathToSourceDir;
 375   std::string RelativePathToBinaryDir;
 376   std::vector<std::string> HomeDirectoryComponents;
 377   std::vector<std::string> StartDirectoryComponents;
 378   std::vector<std::string> HomeOutputDirectoryComponents;
 379   std::vector<std::string> StartOutputDirectoryComponents;
 380   cmLocalGenerator* Parent;
 381   std::vector<cmLocalGenerator*> Children;
 382   std::map<cmStdString, cmStdString> LanguageToIncludeFlags;
 383   std::map<cmStdString, cmStdString> UniqueObjectNamesMap;
 384   std::string::size_type ObjectPathMax;
 385   std::set<cmStdString> ObjectMaxPathViolations;
 386   bool WindowsShell;
 387   bool WindowsVSIDE;
 388   bool WatcomWMake;
 389   bool MinGWMake;
 390   bool NMake;
 391   bool ForceUnixPath;
 392   bool MSYSShell;
 393   bool LinkScriptShell;
 394   bool UseRelativePaths;
 395   bool IgnoreLibPrefix;
 396   bool Configured;
 397   bool EmitUniversalBinaryFlags;
 398   // A type flag is not nice. It's used only in TraceDependencies().
 399   bool IsMakefileGenerator;
 400   // Hack for ExpandRuleVariable until object-oriented version is
 401   // committed.
 402   std::string TargetImplib;
 403
 404   // The top-most directories for relative path conversion.  Both the
 405   // source and destination location of a relative path conversion
 406   // must be underneath one of these directories (both under source or
 407   // both under binary) in order for the relative path to be evaluated
 408   // safely by the build tools.
 409   std::string RelativePathTopSource;
 410   std::string RelativePathTopBinary;
 411   bool RelativePathsConfigured;
 412   bool PathConversionsSetup;
 413
 414   unsigned int BackwardsCompatibility;
 415   bool BackwardsCompatibilityFinal;
 416 private:
 417   std::string ConvertToOutputForExistingCommon(const char* remote,
 418                                                std::string const& result);
 419 };
 420
 421 #endif