Source/cmMakefile.h

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmMakefile.h,v $
   5   Language:  C++
   6   Date:      $Date: 2009-09-10 20:59:44 $
   7   Version:   $Revision: 1.259 $
   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 cmMakefile_h
  18 #define cmMakefile_h
  19
  20 #include "cmCacheManager.h"
  21 #include "cmData.h"
  22 #include "cmExecutionStatus.h"
  23 #include "cmListFileCache.h"
  24 #include "cmPolicies.h"
  25 #include "cmPropertyMap.h"
  26 #include "cmSystemTools.h"
  27 #include "cmTarget.h"
  28 #include "cmake.h"
  29
  30 #if defined(CMAKE_BUILD_WITH_CMAKE)
  31 #include "cmSourceGroup.h"
  32 #endif
  33
  34 #include <cmsys/auto_ptr.hxx>
  35 #include <cmsys/RegularExpression.hxx>
  36
  37 class cmFunctionBlocker;
  38 class cmCommand;
  39 class cmInstallGenerator;
  40 class cmLocalGenerator;
  41 class cmMakeDepend;
  42 class cmSourceFile;
  43 class cmTest;
  44 class cmTestGenerator;
  45 class cmVariableWatch;
  46 class cmake;
  47 class cmMakefileCall;
  48 class cmCMakePolicyCommand;
  49
  50 /** \class cmMakefile
  51  * \brief Process the input CMakeLists.txt file.
  52  *
  53  * Process and store into memory the input CMakeLists.txt file.
  54  * Each CMakeLists.txt file is parsed and the commands found there
  55  * are added into the build process.
  56  */
  57 class cmMakefile
  58 {
  59   class Internals;
  60   cmsys::auto_ptr<Internals> Internal;
  61 public:
  62   /**
  63    * Return the major and minor version of the cmake that
  64    * was used to write the currently loaded cache, note
  65    * this method will not work before the cache is loaded.
  66    */
  67   unsigned int GetCacheMajorVersion();
  68   unsigned int GetCacheMinorVersion();
  69
  70   /** Return whether compatibility features needed for a version of
  71       the cache or lower should be enabled.  */
  72   bool NeedCacheCompatibility(int major, int minor);
  73
  74   /**
  75    * Construct an empty makefile.
  76    */
  77   cmMakefile();
  78   cmMakefile(const cmMakefile& mf);
  79
  80   /**
  81    * Destructor.
  82    */
  83   ~cmMakefile();
  84
  85   /**
  86    * Read and parse a CMakeLists.txt file.
  87    */
  88   bool ReadListFile(const char* listfile,
  89                     const char* external= 0,
  90                     std::string* fullPath= 0,
  91                     bool noPolicyScope = true);
  92
  93   /**
  94    * Add a function blocker to this makefile
  95    */
  96   void AddFunctionBlocker(cmFunctionBlocker* fb);
  97
  98   /**
  99    * Remove the function blocker whose scope ends with the given command.
 100    * This returns ownership of the function blocker object.
 101    */
 102   cmsys::auto_ptr<cmFunctionBlocker>
 103   RemoveFunctionBlocker(cmFunctionBlocker* fb, const cmListFileFunction& lff);
 104
 105   /** Push/pop a lexical (function blocker) barrier automatically.  */
 106   class LexicalPushPop
 107   {
 108   public:
 109     LexicalPushPop(cmMakefile* mf);
 110     ~LexicalPushPop();
 111     void Quiet() { this->ReportError = false; }
 112   private:
 113     cmMakefile* Makefile;
 114     bool ReportError;
 115   };
 116   friend class LexicalPushPop;
 117
 118   /**
 119    * Try running cmake and building a file. This is used for dynalically
 120    * loaded commands, not as part of the usual build process.
 121    */
 122   int TryCompile(const char *srcdir, const char *bindir,
 123                  const char *projectName, const char *targetName,
 124                  bool fast,
 125                  const std::vector<std::string> *cmakeArgs,
 126                  std::string *output);
 127
 128   /**
 129    * Specify the makefile generator. This is platform/compiler
 130    * dependent, although the interface is through a generic
 131    * superclass.
 132    */
 133   void SetLocalGenerator(cmLocalGenerator*);
 134
 135   ///! Get the current makefile generator.
 136   cmLocalGenerator* GetLocalGenerator()
 137     { return this->LocalGenerator;}
 138
 139   /**
 140    * Test whether compatibility is set to a given version or lower.
 141    */
 142   bool NeedBackwardsCompatibility(unsigned int major,
 143                                   unsigned int minor,
 144                                   unsigned int patch = 0xFFu);
 145
 146   /**
 147    * Help enforce global target name uniqueness.
 148    */
 149   bool EnforceUniqueName(std::string const& name, std::string& msg,
 150                          bool isCustom = false);
 151
 152   /**
 153    * Perform FinalPass, Library dependency analysis etc before output of the
 154    * makefile.
 155    */
 156   void ConfigureFinalPass();
 157
 158   /**
 159    * run the final pass on all commands.
 160    */
 161   void FinalPass();
 162
 163   /**
 164    * Print the object state to std::cout.
 165    */
 166   void Print();
 167
 168   /** Add a custom command to the build.  */
 169   void AddCustomCommandToTarget(const char* target,
 170                                 const std::vector<std::string>& depends,
 171                                 const cmCustomCommandLines& commandLines,
 172                                 cmTarget::CustomCommandType type,
 173                                 const char* comment, const char* workingDir,
 174                                 bool escapeOldStyle = true);
 175   void AddCustomCommandToOutput(const std::vector<std::string>& outputs,
 176                                 const std::vector<std::string>& depends,
 177                                 const char* main_dependency,
 178                                 const cmCustomCommandLines& commandLines,
 179                                 const char* comment, const char* workingDir,
 180                                 bool replace = false,
 181                                 bool escapeOldStyle = true);
 182   void AddCustomCommandToOutput(const char* output,
 183                                 const std::vector<std::string>& depends,
 184                                 const char* main_dependency,
 185                                 const cmCustomCommandLines& commandLines,
 186                                 const char* comment, const char* workingDir,
 187                                 bool replace = false,
 188                                 bool escapeOldStyle = true);
 189   void AddCustomCommandOldStyle(const char* target,
 190                                 const std::vector<std::string>& outputs,
 191                                 const std::vector<std::string>& depends,
 192                                 const char* source,
 193                                 const cmCustomCommandLines& commandLines,
 194                                 const char* comment);
 195
 196   /**
 197    * Add a define flag to the build.
 198    */
 199   void AddDefineFlag(const char* definition);
 200   void RemoveDefineFlag(const char* definition);
 201
 202   /** Create a new imported target with the name and type given.  */
 203   cmTarget* AddImportedTarget(const char* name, cmTarget::TargetType type);
 204
 205   cmTarget* AddNewTarget(cmTarget::TargetType type, const char* name);
 206
 207   /**
 208    * Add an executable to the build.
 209    */
 210   cmTarget* AddExecutable(const char *exename,
 211                           const std::vector<std::string> &srcs,
 212                           bool excludeFromAll = false);
 213
 214   /**
 215    * Add a utility to the build.  A utiltity target is a command that
 216    * is run every time the target is built.
 217    */
 218   void AddUtilityCommand(const char* utilityName, bool excludeFromAll,
 219                          const std::vector<std::string>& depends,
 220                          const char* workingDirectory,
 221                          const char* command,
 222                          const char* arg1=0,
 223                          const char* arg2=0,
 224                          const char* arg3=0,
 225                          const char* arg4=0);
 226   cmTarget* AddUtilityCommand(const char* utilityName, bool excludeFromAll,
 227                               const char* workingDirectory,
 228                               const std::vector<std::string>& depends,
 229                               const cmCustomCommandLines& commandLines,
 230                               bool escapeOldStyle = true,
 231                               const char* comment = 0);
 232
 233   /**
 234    * Add a link library to the build.
 235    */
 236   void AddLinkLibrary(const char*);
 237   void AddLinkLibrary(const char*, cmTarget::LinkLibraryType type);
 238   void AddLinkLibraryForTarget(const char *tgt, const char*,
 239                                cmTarget::LinkLibraryType type);
 240   void AddLinkDirectoryForTarget(const char *tgt, const char* d);
 241
 242   /**
 243    * Add a link directory to the build.
 244    */
 245   void AddLinkDirectory(const char*);
 246
 247   /**
 248    * Get the list of link directories
 249    */
 250   std::vector<std::string>& GetLinkDirectories()
 251     {
 252       return this->LinkDirectories;
 253     }
 254   const std::vector<std::string>& GetLinkDirectories() const
 255     {
 256       return this->LinkDirectories;
 257     }
 258   void SetLinkDirectories(const std::vector<std::string>& vec)
 259     {
 260       this->LinkDirectories = vec;
 261     }
 262
 263   /**
 264    * Add a subdirectory to the build.
 265    */
 266   void AddSubDirectory(const char*, bool excludeFromAll=false,
 267                        bool preorder = false);
 268   void AddSubDirectory(const char* fullSrcDir,const char *fullBinDir,
 269                        bool excludeFromAll, bool preorder,
 270                        bool immediate);
 271
 272   /**
 273    * Configure a subdirectory
 274    */
 275   void ConfigureSubDirectory(cmLocalGenerator *);
 276
 277   /**
 278    * Add an include directory to the build.
 279    */
 280   void AddIncludeDirectory(const char*, bool before = false);
 281
 282   /**
 283    * Add a variable definition to the build. This variable
 284    * can be used in CMake to refer to lists, directories, etc.
 285    */
 286   void AddDefinition(const char* name, const char* value);
 287   ///! Add a definition to this makefile and the global cmake cache.
 288   void AddCacheDefinition(const char* name, const char* value,
 289                           const char* doc,
 290                           cmCacheManager::CacheEntryType type,
 291                           bool force = false);
 292
 293   /**
 294    * Update the variable scope to make the cache definition visible.
 295    */
 296   void UseCacheDefinition(cmCacheManager::CacheIterator const& it);
 297
 298   /**
 299    * Add bool variable definition to the build.
 300    */
 301   void AddDefinition(const char* name, bool);
 302
 303   /**
 304    * Remove a variable definition from the build.  This is not valid
 305    * for cache entries, and will only affect the current makefile.
 306    */
 307   void RemoveDefinition(const char* name);
 308   ///! Remove a definition from the cache.
 309   void RemoveCacheDefinition(const char* name);
 310
 311   /**
 312    * Specify the name of the project for this build.
 313    */
 314   void SetProjectName(const char*);
 315
 316   /**
 317    * Get the name of the project for this build.
 318    */
 319   const char* GetProjectName() const
 320     {
 321       return this->ProjectName.c_str();
 322     }
 323
 324   /**
 325    * Set the name of the library.
 326    */
 327   void AddLibrary(const char *libname, cmTarget::TargetType type,
 328                   const std::vector<std::string> &srcs,
 329                   bool excludeFromAll = false);
 330
 331 #if defined(CMAKE_BUILD_WITH_CMAKE)
 332   /**
 333    * Add a root source group for consideration when adding a new source.
 334    */
 335   void AddSourceGroup(const char* name, const char* regex=0);
 336
 337   /**
 338    * Add a source group for consideration when adding a new source.
 339    * name is tokenized.
 340    */
 341   void AddSourceGroup(const std::vector<std::string>& name,
 342                       const char* regex=0);
 343
 344 #endif
 345
 346   //@{
 347   /**
 348      * Set, Push, Pop policy values for CMake.
 349      */
 350   bool SetPolicy(cmPolicies::PolicyID id, cmPolicies::PolicyStatus status);
 351   bool SetPolicy(const char *id, cmPolicies::PolicyStatus status);
 352   cmPolicies::PolicyStatus GetPolicyStatus(cmPolicies::PolicyID id);
 353   bool SetPolicyVersion(const char *version);
 354   void RecordPolicies(cmPolicies::PolicyMap& pm);
 355   //@}
 356
 357   /** Helper class to push and pop policies automatically.  */
 358   class PolicyPushPop
 359   {
 360   public:
 361     PolicyPushPop(cmMakefile* m,
 362                   bool weak = false,
 363                   cmPolicies::PolicyMap const& pm = cmPolicies::PolicyMap());
 364     ~PolicyPushPop();
 365     void Quiet() { this->ReportError = false; }
 366   private:
 367     cmMakefile* Makefile;
 368     bool ReportError;
 369   };
 370   friend class PolicyPushPop;
 371
 372   /**
 373     * Get the Policies Instance
 374     */
 375  cmPolicies *GetPolicies();
 376
 377   /**
 378    * Add an auxiliary directory to the build.
 379    */
 380   void AddExtraDirectory(const char* dir);
 381
 382
 383   /**
 384    * Add an auxiliary directory to the build.
 385    */
 386   void MakeStartDirectoriesCurrent()
 387     {
 388       this->AddDefinition("CMAKE_CURRENT_SOURCE_DIR",
 389                           this->cmStartDirectory.c_str());
 390       this->AddDefinition("CMAKE_CURRENT_BINARY_DIR",
 391                           this->StartOutputDirectory.c_str());
 392     }
 393
 394   //@{
 395   /**
 396    * Set/Get the home directory (or output directory) in the project. The
 397    * home directory is the top directory of the project. It is where
 398    * CMakeSetup or configure was run. Remember that CMake processes
 399    * CMakeLists files by recursing up the tree starting at the StartDirectory
 400    * and going up until it reaches the HomeDirectory.
 401    */
 402   void SetHomeDirectory(const char* dir);
 403   const char* GetHomeDirectory() const
 404     {
 405       return this->cmHomeDirectory.c_str();
 406     }
 407   void SetHomeOutputDirectory(const char* lib);
 408   const char* GetHomeOutputDirectory() const
 409     {
 410       return this->HomeOutputDirectory.c_str();
 411     }
 412   //@}
 413
 414   //@{
 415   /**
 416    * Set/Get the start directory (or output directory). The start directory
 417    * is the directory of the CMakeLists.txt file that started the current
 418    * round of processing. Remember that CMake processes CMakeLists files by
 419    * recursing up the tree starting at the StartDirectory and going up until
 420    * it reaches the HomeDirectory.
 421    */
 422   void SetStartDirectory(const char* dir)
 423     {
 424       this->cmStartDirectory = dir;
 425       cmSystemTools::ConvertToUnixSlashes(this->cmStartDirectory);
 426       this->cmStartDirectory =
 427         cmSystemTools::CollapseFullPath(this->cmStartDirectory.c_str());
 428       this->AddDefinition("CMAKE_CURRENT_SOURCE_DIR",
 429                           this->cmStartDirectory.c_str());
 430     }
 431   const char* GetStartDirectory() const
 432     {
 433       return this->cmStartDirectory.c_str();
 434     }
 435   void SetStartOutputDirectory(const char* lib)
 436     {
 437       this->StartOutputDirectory = lib;
 438       cmSystemTools::ConvertToUnixSlashes(this->StartOutputDirectory);
 439       this->StartOutputDirectory =
 440         cmSystemTools::CollapseFullPath(this->StartOutputDirectory.c_str());
 441       cmSystemTools::MakeDirectory(this->StartOutputDirectory.c_str());
 442       this->AddDefinition("CMAKE_CURRENT_BINARY_DIR",
 443                           this->StartOutputDirectory.c_str());
 444     }
 445   const char* GetStartOutputDirectory() const
 446     {
 447       return this->StartOutputDirectory.c_str();
 448     }
 449   //@}
 450
 451   const char* GetCurrentDirectory() const
 452     {
 453       return this->cmStartDirectory.c_str();
 454     }
 455   const char* GetCurrentOutputDirectory() const
 456     {
 457       return this->StartOutputDirectory.c_str();
 458     }
 459
 460   /* Get the current CMakeLists.txt file that is being processed.  This
 461    * is just used in order to be able to 'branch' from one file to a second
 462    * transparently */
 463   const char* GetCurrentListFile() const
 464     {
 465       return this->cmCurrentListFile.c_str();
 466     }
 467
 468   //@}
 469
 470   /**
 471    * Set a regular expression that include files must match
 472    * in order to be considered as part of the depend information.
 473    */
 474   void SetIncludeRegularExpression(const char* regex)
 475     {
 476       this->IncludeFileRegularExpression = regex;
 477     }
 478   const char* GetIncludeRegularExpression()
 479     {
 480       return this->IncludeFileRegularExpression.c_str();
 481     }
 482
 483   /**
 484    * Set a regular expression that include files that are not found
 485    * must match in order to be considered a problem.
 486    */
 487   void SetComplainRegularExpression(const char* regex)
 488     {
 489       this->ComplainFileRegularExpression = regex;
 490     }
 491   const char* GetComplainRegularExpression()
 492     {
 493       return this->ComplainFileRegularExpression.c_str();
 494     }
 495
 496   /**
 497    * Get the list of targets
 498    */
 499   cmTargets &GetTargets() { return this->Targets; }
 500   /**
 501    * Get the list of targets, const version
 502    */
 503   const cmTargets &GetTargets() const { return this->Targets; }
 504
 505   cmTarget* FindTarget(const char* name);
 506
 507   /** Find a target to use in place of the given name.  The target
 508       returned may be imported or built within the project.  */
 509   cmTarget* FindTargetToUse(const char* name);
 510
 511   /**
 512    * Get a list of include directories in the build.
 513    */
 514   std::vector<std::string>& GetIncludeDirectories()
 515     {
 516       return this->IncludeDirectories;
 517     }
 518   const std::vector<std::string>& GetIncludeDirectories() const
 519     {
 520       return this->IncludeDirectories;
 521     }
 522   void SetIncludeDirectories(const std::vector<std::string>& vec)
 523     {
 524       this->IncludeDirectories = vec;
 525     }
 526
 527   /**
 528    * Mark include directories as system directories.
 529    */
 530   void AddSystemIncludeDirectory(const char* dir);
 531   bool IsSystemIncludeDirectory(const char* dir);
 532
 533   /** Expand out any arguements in the vector that have ; separated
 534    *  strings into multiple arguements.  A new vector is created
 535    *  containing the expanded versions of all arguments in argsIn.
 536    * This method differes from the one in cmSystemTools in that if
 537    * the CmakeLists file is version 1.2 or earlier it will check for
 538    * source lists being used without ${} around them
 539    */
 540   void ExpandSourceListArguments(std::vector<std::string> const& argsIn,
 541                                  std::vector<std::string>& argsOut,
 542                                  unsigned int startArgumentIndex);
 543
 544   /** Get a cmSourceFile pointer for a given source name, if the name is
 545    *  not found, then a null pointer is returned.
 546    */
 547   cmSourceFile* GetSource(const char* sourceName);
 548
 549   /** Get a cmSourceFile pointer for a given source name, if the name is
 550    *  not found, then create the source file and return it. generated
 551    * indicates if it is a generated file, this is used in determining
 552    * how to create the source file instance e.g. name
 553    */
 554   cmSourceFile* GetOrCreateSource(const char* sourceName,
 555                                   bool generated = false);
 556
 557   /**
 558    * Obtain a list of auxiliary source directories.
 559    */
 560   std::vector<std::string>& GetAuxSourceDirectories()
 561     {return this->AuxSourceDirectories;}
 562
 563   //@{
 564   /**
 565    * Return a list of extensions associated with source and header
 566    * files
 567    */
 568   const std::vector<std::string>& GetSourceExtensions() const
 569     {return this->SourceFileExtensions;}
 570   const std::vector<std::string>& GetHeaderExtensions() const
 571     {return this->HeaderFileExtensions;}
 572   //@}
 573
 574   /**
 575    * Given a variable name, return its value (as a string).
 576    * If the variable is not found in this makefile instance, the
 577    * cache is then queried.
 578    */
 579   const char* GetDefinition(const char*) const;
 580   const char* GetSafeDefinition(const char*) const;
 581   const char* GetRequiredDefinition(const char* name) const;
 582   bool IsDefinitionSet(const char*) const;
 583   /**
 584    * Get the list of all variables in the current space. If argument
 585    * cacheonly is specified and is greater than 0, then only cache
 586    * variables will be listed.
 587    */
 588   std::vector<std::string> GetDefinitions(int cacheonly=0) const;
 589
 590   /** Test a boolean cache entry to see if it is true or false,
 591    *  returns false if no entry defined.
 592    */
 593   bool IsOn(const char* name) const;
 594   bool IsSet(const char* name) const;
 595
 596   /**
 597    * Get a list of preprocessor define flags.
 598    */
 599   const char* GetDefineFlags()
 600     {return this->DefineFlags.c_str();}
 601
 602   /**
 603    * Make sure CMake can write this file
 604    */
 605   bool CanIWriteThisFile(const char* fileName);
 606
 607   /**
 608    * Get the vector of used command instances.
 609    */
 610   const std::vector<cmCommand*>& GetUsedCommands() const
 611     {return this->UsedCommands;}
 612
 613 #if defined(CMAKE_BUILD_WITH_CMAKE)
 614   /**
 615    * Get the vector source groups.
 616    */
 617   const std::vector<cmSourceGroup>& GetSourceGroups() const
 618     { return this->SourceGroups; }
 619
 620   /**
 621    * Get the source group
 622    */
 623   cmSourceGroup* GetSourceGroup(const std::vector<std::string>&name);
 624 #endif
 625
 626   /**
 627    * Get the vector of list files on which this makefile depends
 628    */
 629   const std::vector<std::string>& GetListFiles() const
 630     { return this->ListFiles; }
 631   ///! When the file changes cmake will be re-run from the build system.
 632   void AddCMakeDependFile(const char* file)
 633     { this->ListFiles.push_back(file);}
 634
 635     /**
 636      * Get the list file stack as a string
 637      */
 638     std::string GetListFileStack();
 639
 640   /**
 641    * Get the current context backtrace.
 642    */
 643   bool GetBacktrace(cmListFileBacktrace& backtrace) const;
 644
 645   /**
 646    * Get the vector of  files created by this makefile
 647    */
 648   const std::vector<std::string>& GetOutputFiles() const
 649     { return this->OutputFiles; }
 650   void AddCMakeOutputFile(const char* file)
 651     { this->OutputFiles.push_back(file);}
 652
 653   /**
 654    * Expand all defined variables in the string.
 655    * Defined variables come from the this->Definitions map.
 656    * They are expanded with ${var} where var is the
 657    * entry in the this->Definitions map.  Also @var@ is
 658    * expanded to match autoconf style expansions.
 659    */
 660   const char *ExpandVariablesInString(std::string& source);
 661   const char *ExpandVariablesInString(std::string& source, bool escapeQuotes,
 662                                       bool noEscapes,
 663                                       bool atOnly = false,
 664                                       const char* filename = 0,
 665                                       long line = -1,
 666                                       bool removeEmpty = false,
 667                                       bool replaceAt = true);
 668
 669   /**
 670    * Remove any remaining variables in the string. Anything with ${var} or
 671    * @var@ will be removed.
 672    */
 673   void RemoveVariablesInString(std::string& source,
 674                                bool atOnly = false) const;
 675
 676   /**
 677    * Expand variables in the makefiles ivars such as link directories etc
 678    */
 679   void ExpandVariables();
 680
 681   /**
 682    * Replace variables and #cmakedefine lines in the given string.
 683    * See cmConfigureFileCommand for details.
 684    */
 685   void ConfigureString(const std::string& input, std::string& output,
 686                        bool atOnly, bool escapeQuotes);
 687
 688   /**
 689    * Copy file but change lines acording to ConfigureString
 690    */
 691   int ConfigureFile(const char* infile, const char* outfile,
 692                     bool copyonly, bool atOnly, bool escapeQuotes);
 693
 694 #if defined(CMAKE_BUILD_WITH_CMAKE)
 695   /**
 696    * find what source group this source is in
 697    */
 698   cmSourceGroup& FindSourceGroup(const char* source,
 699                                  std::vector<cmSourceGroup> &groups);
 700 #endif
 701
 702   void RegisterData(cmData*);
 703   void RegisterData(const char*, cmData*);
 704   cmData* LookupData(const char*) const;
 705
 706   /**
 707    * Execute a single CMake command.  Returns true if the command
 708    * succeeded or false if it failed.
 709    */
 710   bool ExecuteCommand(const cmListFileFunction& lff,
 711                       cmExecutionStatus &status);
 712
 713   /** Check if a command exists. */
 714   bool CommandExists(const char* name) const;
 715
 716   /**
 717    * Add a command to this cmake instance
 718    */
 719   void AddCommand(cmCommand* );
 720
 721   ///! Enable support for named language, if nil then all languages are
 722   ///enabled.
 723   void EnableLanguage(std::vector<std::string>const& languages, bool optional);
 724
 725   /**
 726    * Set/Get the name of the parent directories CMakeLists file
 727    * given a current CMakeLists file name
 728    */
 729   cmCacheManager *GetCacheManager() const;
 730
 731   /**
 732    * Get the variable watch. This is used to determine when certain variables
 733    * are accessed.
 734    */
 735 #ifdef CMAKE_BUILD_WITH_CMAKE
 736   cmVariableWatch* GetVariableWatch() const;
 737 #endif
 738
 739   ///! Display progress or status message.
 740   void DisplayStatus(const char*, float);
 741
 742   /**
 743    * Expand the given list file arguments into the full set after
 744    * variable replacement and list expansion.
 745    */
 746   bool ExpandArguments(std::vector<cmListFileArgument> const& inArgs,
 747                        std::vector<std::string>& outArgs);
 748   /**
 749    * Get the instance
 750    */
 751   cmake *GetCMakeInstance() const;
 752
 753   /**
 754    * Get all the source files this makefile knows about
 755    */
 756   const std::vector<cmSourceFile*> &GetSourceFiles() const
 757     {return this->SourceFiles;}
 758   std::vector<cmSourceFile*> &GetSourceFiles() {return this->SourceFiles;}
 759
 760   /**
 761    * Is there a source file that has the provided source file as an output?
 762    * if so then return it
 763    */
 764   cmSourceFile *GetSourceFileWithOutput(const char *outName);
 765
 766   /**
 767    * Add a macro to the list of macros. The arguments should be name of the
 768    * macro and a documentation signature of it
 769    */
 770   void AddMacro(const char* name, const char* signature);
 771
 772   ///! Add a new cmTest to the list of tests for this makefile.
 773   cmTest* CreateTest(const char* testName);
 774
 775   /** Get a cmTest pointer for a given test name, if the name is
 776    *  not found, then a null pointer is returned.
 777    */
 778   cmTest* GetTest(const char* testName) const;
 779
 780   /**
 781    * Get a list of macros as a ; separated string
 782    */
 783   void GetListOfMacros(std::string& macros);
 784
 785   /**
 786    * Return a location of a file in cmake or custom modules directory
 787    */
 788   std::string GetModulesFile(const char* name);
 789
 790   ///! Set/Get a property of this directory
 791   void SetProperty(const char *prop, const char *value);
 792   void AppendProperty(const char *prop, const char *value);
 793   const char *GetProperty(const char *prop);
 794   const char *GetPropertyOrDefinition(const char *prop);
 795   const char *GetProperty(const char *prop, cmProperty::ScopeType scope);
 796   bool GetPropertyAsBool(const char *prop);
 797
 798   // Get the properties
 799   cmPropertyMap &GetProperties() { return this->Properties; };
 800
 801   ///! Initialize a makefile from its parent
 802   void InitializeFromParent();
 803
 804   ///! Set/Get the preorder flag
 805   void SetPreOrder(bool p) { this->PreOrder = p; }
 806   bool GetPreOrder() const { return this->PreOrder; }
 807
 808   void AddInstallGenerator(cmInstallGenerator* g)
 809     { if(g) this->InstallGenerators.push_back(g); }
 810   std::vector<cmInstallGenerator*>& GetInstallGenerators()
 811     { return this->InstallGenerators; }
 812
 813   void AddTestGenerator(cmTestGenerator* g)
 814     { if(g) this->TestGenerators.push_back(g); }
 815   std::vector<cmTestGenerator*>& GetTestGenerators()
 816     { return this->TestGenerators; }
 817
 818   // Define the properties
 819   static void DefineProperties(cmake *cm);
 820
 821   // push and pop variable scopes
 822   void PushScope();
 823   void PopScope();
 824   void RaiseScope(const char *var, const char *value);
 825
 826   /** Helper class to push and pop scopes automatically.  */
 827   class ScopePushPop
 828   {
 829   public:
 830     ScopePushPop(cmMakefile* m): Makefile(m) { this->Makefile->PushScope(); }
 831     ~ScopePushPop() { this->Makefile->PopScope(); }
 832   private:
 833     cmMakefile* Makefile;
 834   };
 835
 836   void IssueMessage(cmake::MessageType t,
 837                     std::string const& text) const;
 838
 839   /** Set whether or not to report a CMP0000 violation.  */
 840   void SetCheckCMP0000(bool b) { this->CheckCMP0000 = b; }
 841
 842 protected:
 843   // add link libraries and directories to the target
 844   void AddGlobalLinkInformation(const char* name, cmTarget& target);
 845
 846   std::string Prefix;
 847   std::vector<std::string> AuxSourceDirectories; //
 848
 849   std::string cmStartDirectory;
 850   std::string StartOutputDirectory;
 851   std::string cmHomeDirectory;
 852   std::string HomeOutputDirectory;
 853   std::string cmCurrentListFile;
 854
 855   std::string ProjectName;    // project name
 856
 857   // libraries, classes, and executables
 858   cmTargets Targets;
 859   std::vector<cmSourceFile*> SourceFiles;
 860
 861   // Tests
 862   std::map<cmStdString, cmTest*> Tests;
 863
 864   // The include and link-library paths.  These may have order
 865   // dependency, so they must be vectors (not set).
 866   std::vector<std::string> IncludeDirectories;
 867   std::vector<std::string> LinkDirectories;
 868
 869   // The set of include directories that are marked as system include
 870   // directories.
 871   std::set<cmStdString> SystemIncludeDirectories;
 872
 873   std::vector<std::string> ListFiles; // list of command files loaded
 874   std::vector<std::string> OutputFiles; // list of command files loaded
 875
 876
 877   cmTarget::LinkLibraryVectorType LinkLibraries;
 878
 879   std::vector<cmInstallGenerator*> InstallGenerators;
 880   std::vector<cmTestGenerator*> TestGenerators;
 881
 882   std::string IncludeFileRegularExpression;
 883   std::string ComplainFileRegularExpression;
 884   std::vector<std::string> SourceFileExtensions;
 885   std::vector<std::string> HeaderFileExtensions;
 886   std::string DefineFlags;
 887
 888   // Track the value of the computed DEFINITIONS property.
 889   void AddDefineFlag(const char*, std::string&);
 890   void RemoveDefineFlag(const char*, std::string::size_type, std::string&);
 891   std::string DefineFlagsOrig;
 892
 893 #if defined(CMAKE_BUILD_WITH_CMAKE)
 894   std::vector<cmSourceGroup> SourceGroups;
 895 #endif
 896
 897   std::vector<cmCommand*> UsedCommands;
 898   cmLocalGenerator* LocalGenerator;
 899   bool IsFunctionBlocked(const cmListFileFunction& lff,
 900                          cmExecutionStatus &status);
 901
 902 private:
 903   void Initialize();
 904
 905   bool ParseDefineFlag(std::string const& definition, bool remove);
 906
 907   bool EnforceUniqueDir(const char* srcPath, const char* binPath);
 908
 909   void ReadSources(std::ifstream& fin, bool t);
 910   friend class cmMakeDepend;    // make depend needs direct access
 911                                 // to the Sources array
 912   void PrintStringVector(const char* s, const
 913                          std::vector<std::pair<cmStdString, bool> >& v) const;
 914   void PrintStringVector(const char* s,
 915                          const std::vector<std::string>& v) const;
 916
 917   void AddDefaultDefinitions();
 918   typedef std::vector<cmFunctionBlocker*> FunctionBlockersType;
 919   FunctionBlockersType FunctionBlockers;
 920   std::vector<FunctionBlockersType::size_type> FunctionBlockerBarriers;
 921   void PushFunctionBlockerBarrier();
 922   void PopFunctionBlockerBarrier(bool reportError = true);
 923
 924   typedef std::map<cmStdString, cmData*> DataMapType;
 925   DataMapType DataMap;
 926
 927   typedef std::map<cmStdString, cmStdString> StringStringMap;
 928   StringStringMap MacrosMap;
 929
 930   std::map<cmStdString, bool> SubDirectoryOrder;
 931
 932   cmsys::RegularExpression cmDefineRegex;
 933   cmsys::RegularExpression cmDefine01Regex;
 934   cmsys::RegularExpression cmAtVarRegex;
 935
 936   cmPropertyMap Properties;
 937
 938   // should this makefile be processed before or after processing the parent
 939   bool PreOrder;
 940
 941   // stack of list files being read
 942   std::deque<cmStdString> ListFileStack;
 943
 944   // stack of commands being invoked.
 945   struct CallStackEntry
 946   {
 947     cmListFileContext const* Context;
 948     cmExecutionStatus* Status;
 949   };
 950   typedef std::deque<CallStackEntry> CallStackType;
 951   CallStackType CallStack;
 952   friend class cmMakefileCall;
 953
 954   cmTarget* FindBasicTarget(const char* name);
 955   std::vector<cmTarget*> ImportedTargetsOwned;
 956   std::map<cmStdString, cmTarget*> ImportedTargets;
 957
 958   // Internal policy stack management.
 959   void PushPolicy(bool weak = false,
 960                   cmPolicies::PolicyMap const& pm = cmPolicies::PolicyMap());
 961   void PopPolicy();
 962   void PushPolicyBarrier();
 963   void PopPolicyBarrier(bool reportError = true);
 964   friend class cmCMakePolicyCommand;
 965   class IncludeScope;
 966   friend class IncludeScope;
 967
 968   // stack of policy settings
 969   struct PolicyStackEntry: public cmPolicies::PolicyMap
 970   {
 971     typedef cmPolicies::PolicyMap derived;
 972     PolicyStackEntry(bool w = false): derived(), Weak(w) {}
 973     PolicyStackEntry(derived const& d, bool w = false): derived(d), Weak(w) {}
 974     PolicyStackEntry(PolicyStackEntry const& r): derived(r), Weak(r.Weak) {}
 975     bool Weak;
 976   };
 977   typedef std::vector<PolicyStackEntry> PolicyStackType;
 978   PolicyStackType PolicyStack;
 979   std::vector<PolicyStackType::size_type> PolicyBarriers;
 980   cmPolicies::PolicyStatus GetPolicyStatusInternal(cmPolicies::PolicyID id);
 981
 982   bool CheckCMP0000;
 983
 984   // Enforce rules about CMakeLists.txt files.
 985   void EnforceDirectoryLevelRules();
 986 };
 987
 988 //----------------------------------------------------------------------------
 989 // Helper class to make sure the call stack is valid.
 990 class cmMakefileCall
 991 {
 992 public:
 993   cmMakefileCall(cmMakefile* mf,
 994                  cmListFileContext const& lfc,
 995                  cmExecutionStatus& status): Makefile(mf)
 996     {
 997     cmMakefile::CallStackEntry entry = {&lfc, &status};
 998     this->Makefile->CallStack.push_back(entry);
 999     }
1000   ~cmMakefileCall()
1001     {
1002     this->Makefile->CallStack.pop_back();
1003     }
1004 private:
1005   cmMakefile* Makefile;
1006 };
1007
1008 #endif