CMakeLua/Source/cmMakefile.h

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