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