Source/cmMakefile.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmMakefile.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2008-10-09 17:52:25 $
   7   Version:   $Revision: 1.486 $
   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 #include "cmMakefile.h"
  18 #include "cmVersion.h"
  19 #include "cmCommand.h"
  20 #include "cmSourceFile.h"
  21 #include "cmSourceFileLocation.h"
  22 #include "cmSystemTools.h"
  23 #include "cmGlobalGenerator.h"
  24 #include "cmLocalGenerator.h"
  25 #include "cmCommands.h"
  26 #include "cmCacheManager.h"
  27 #include "cmFunctionBlocker.h"
  28 #include "cmListFileCache.h"
  29 #include "cmCommandArgumentParserHelper.h"
  30 #include "cmTest.h"
  31 #ifdef CMAKE_BUILD_WITH_CMAKE
  32 #  include "cmVariableWatch.h"
  33 #endif
  34 #include "cmInstallGenerator.h"
  35 #include "cmake.h"
  36 #include <stdlib.h> // required for atoi
  37
  38 #include <cmsys/RegularExpression.hxx>
  39
  40 #include <cmsys/auto_ptr.hxx>
  41
  42 #include <ctype.h> // for isspace
  43
  44 // default is not to be building executables
  45 cmMakefile::cmMakefile()
  46 {
  47   this->DefinitionStack.push_back(DefinitionMap());
  48
  49   // Setup the default include file regular expression (match everything).
  50   this->IncludeFileRegularExpression = "^.*$";
  51   // Setup the default include complaint regular expression (match nothing).
  52   this->ComplainFileRegularExpression = "^$";
  53   // Source and header file extensions that we can handle
  54
  55   // Set up a list of source and header extensions
  56   // these are used to find files when the extension
  57   // is not given
  58   // The "c" extension MUST precede the "C" extension.
  59   this->SourceFileExtensions.push_back( "c" );
  60   this->SourceFileExtensions.push_back( "C" );
  61
  62   this->SourceFileExtensions.push_back( "c++" );
  63   this->SourceFileExtensions.push_back( "cc" );
  64   this->SourceFileExtensions.push_back( "cpp" );
  65   this->SourceFileExtensions.push_back( "cxx" );
  66   this->SourceFileExtensions.push_back( "m" );
  67   this->SourceFileExtensions.push_back( "M" );
  68   this->SourceFileExtensions.push_back( "mm" );
  69
  70   this->HeaderFileExtensions.push_back( "h" );
  71   this->HeaderFileExtensions.push_back( "hh" );
  72   this->HeaderFileExtensions.push_back( "h++" );
  73   this->HeaderFileExtensions.push_back( "hm" );
  74   this->HeaderFileExtensions.push_back( "hpp" );
  75   this->HeaderFileExtensions.push_back( "hxx" );
  76   this->HeaderFileExtensions.push_back( "in" );
  77   this->HeaderFileExtensions.push_back( "txx" );
  78
  79   this->DefineFlags = " ";
  80   this->LocalGenerator = 0;
  81
  82 #if defined(CMAKE_BUILD_WITH_CMAKE)
  83   this->AddSourceGroup("", "^.*$");
  84   this->AddSourceGroup
  85     ("Source Files",
  86      "\\.(C|M|c|c\\+\\+|cc|cpp|cxx|f|f90|for|fpp"
  87      "|ftn|m|mm|rc|def|r|odl|idl|hpj|bat)$");
  88   this->AddSourceGroup("Header Files",
  89                        "\\.(h|hh|h\\+\\+|hm|hpp|hxx|in|txx|inl)$");
  90   this->AddSourceGroup("CMake Rules", "\\.rule$");
  91   this->AddSourceGroup("Resources", "\\.plist$");
  92 #endif
  93   this->AddDefaultDefinitions();
  94   this->Initialize();
  95   this->PreOrder = false;
  96 }
  97
  98 cmMakefile::cmMakefile(const cmMakefile& mf)
  99 {
 100   this->Prefix = mf.Prefix;
 101   this->AuxSourceDirectories = mf.AuxSourceDirectories;
 102   this->cmStartDirectory = mf.cmStartDirectory;
 103   this->StartOutputDirectory = mf.StartOutputDirectory;
 104   this->cmHomeDirectory = mf.cmHomeDirectory;
 105   this->HomeOutputDirectory = mf.HomeOutputDirectory;
 106   this->cmCurrentListFile = mf.cmCurrentListFile;
 107   this->ProjectName = mf.ProjectName;
 108   this->Targets = mf.Targets;
 109   this->SourceFiles = mf.SourceFiles;
 110   this->Tests = mf.Tests;
 111   this->IncludeDirectories = mf.IncludeDirectories;
 112   this->LinkDirectories = mf.LinkDirectories;
 113   this->SystemIncludeDirectories = mf.SystemIncludeDirectories;
 114   this->ListFiles = mf.ListFiles;
 115   this->OutputFiles = mf.OutputFiles;
 116   this->LinkLibraries = mf.LinkLibraries;
 117   this->InstallGenerators = mf.InstallGenerators;
 118   this->IncludeFileRegularExpression = mf.IncludeFileRegularExpression;
 119   this->ComplainFileRegularExpression = mf.ComplainFileRegularExpression;
 120   this->SourceFileExtensions = mf.SourceFileExtensions;
 121   this->HeaderFileExtensions = mf.HeaderFileExtensions;
 122   this->DefineFlags = mf.DefineFlags;
 123   this->DefineFlagsOrig = mf.DefineFlagsOrig;
 124
 125 #if defined(CMAKE_BUILD_WITH_CMAKE)
 126   this->SourceGroups = mf.SourceGroups;
 127 #endif
 128
 129   this->DefinitionStack.push_back(mf.DefinitionStack.back());
 130   this->LocalGenerator = mf.LocalGenerator;
 131   this->FunctionBlockers = mf.FunctionBlockers;
 132   this->DataMap = mf.DataMap;
 133   this->MacrosMap = mf.MacrosMap;
 134   this->SubDirectoryOrder = mf.SubDirectoryOrder;
 135   this->TemporaryDefinitionKey = mf.TemporaryDefinitionKey;
 136   this->Properties = mf.Properties;
 137   this->PreOrder = mf.PreOrder;
 138   this->ListFileStack = mf.ListFileStack;
 139   this->Initialize();
 140 }
 141
 142 //----------------------------------------------------------------------------
 143 void cmMakefile::Initialize()
 144 {
 145   this->cmDefineRegex.compile("#cmakedefine[ \t]+([A-Za-z_0-9]*)");
 146   this->cmDefine01Regex.compile("#cmakedefine01[ \t]+([A-Za-z_0-9]*)");
 147   this->cmAtVarRegex.compile("(@[A-Za-z_0-9/.+-]+@)");
 148
 149   // Enter a policy level for this directory.
 150   this->PushPolicy();
 151
 152   // By default the check is not done.  It is enabled by
 153   // cmListFileCache in the top level if necessary.
 154   this->CheckCMP0000 = false;
 155 }
 156
 157 unsigned int cmMakefile::GetCacheMajorVersion()
 158 {
 159   return this->GetCacheManager()->GetCacheMajorVersion();
 160 }
 161
 162 unsigned int cmMakefile::GetCacheMinorVersion()
 163 {
 164   return this->GetCacheManager()->GetCacheMinorVersion();
 165 }
 166
 167 bool cmMakefile::NeedCacheCompatibility(int major, int minor)
 168 {
 169   return this->GetCacheManager()->NeedCacheCompatibility(major, minor);
 170 }
 171
 172 cmMakefile::~cmMakefile()
 173 {
 174   for(std::vector<cmInstallGenerator*>::iterator
 175         i = this->InstallGenerators.begin();
 176       i != this->InstallGenerators.end(); ++i)
 177     {
 178     delete *i;
 179     }
 180   for(std::vector<cmSourceFile*>::iterator i = this->SourceFiles.begin();
 181       i != this->SourceFiles.end(); ++i)
 182     {
 183     delete *i;
 184     }
 185   for(std::vector<cmTest*>::iterator i = this->Tests.begin();
 186       i != this->Tests.end(); ++i)
 187     {
 188     delete *i;
 189     }
 190   for(std::vector<cmTarget*>::iterator
 191         i = this->ImportedTargetsOwned.begin();
 192       i != this->ImportedTargetsOwned.end(); ++i)
 193     {
 194     delete *i;
 195     }
 196   for(unsigned int i=0; i < this->UsedCommands.size(); i++)
 197     {
 198     delete this->UsedCommands[i];
 199     }
 200   for(DataMapType::const_iterator d = this->DataMap.begin();
 201       d != this->DataMap.end(); ++d)
 202     {
 203     if(d->second)
 204       {
 205       delete d->second;
 206       }
 207     }
 208   std::list<cmFunctionBlocker *>::iterator pos;
 209   for (pos = this->FunctionBlockers.begin();
 210        pos != this->FunctionBlockers.end(); ++pos)
 211     {
 212     cmFunctionBlocker* b = *pos;
 213     delete b;
 214     }
 215   this->FunctionBlockers.clear();
 216   if (this->PolicyStack.size() != 1)
 217   {
 218     cmSystemTools::Error("Internal CMake Error, Policy Stack has not been"
 219       " popped properly");
 220   }
 221 }
 222
 223 void cmMakefile::PrintStringVector(const char* s,
 224                                    const std::vector<std::string>& v) const
 225 {
 226   std::cout << s << ": ( \n";
 227   for(std::vector<std::string>::const_iterator i = v.begin();
 228       i != v.end(); ++i)
 229     {
 230     std::cout << (*i).c_str() << " ";
 231     }
 232   std::cout << " )\n";
 233 }
 234
 235 void cmMakefile
 236 ::PrintStringVector(const char* s,
 237                     const std::vector<std::pair<cmStdString, bool> >& v) const
 238 {
 239   std::cout << s << ": ( \n";
 240   for(std::vector<std::pair<cmStdString, bool> >::const_iterator i
 241         = v.begin(); i != v.end(); ++i)
 242     {
 243     std::cout << i->first.c_str() << " " << i->second;
 244     }
 245   std::cout << " )\n";
 246 }
 247
 248
 249 // call print on all the classes in the makefile
 250 void cmMakefile::Print()
 251 {
 252   // print the class lists
 253   std::cout << "classes:\n";
 254
 255   std::cout << " this->Targets: ";
 256   for (cmTargets::iterator l = this->Targets.begin();
 257        l != this->Targets.end(); l++)
 258     {
 259     std::cout << l->first << std::endl;
 260     }
 261
 262   std::cout << " this->StartOutputDirectory; " <<
 263     this->StartOutputDirectory.c_str() << std::endl;
 264   std::cout << " this->HomeOutputDirectory; " <<
 265     this->HomeOutputDirectory.c_str() << std::endl;
 266   std::cout << " this->cmStartDirectory; " <<
 267     this->cmStartDirectory.c_str() << std::endl;
 268   std::cout << " this->cmHomeDirectory; " <<
 269     this->cmHomeDirectory.c_str() << std::endl;
 270   std::cout << " this->ProjectName; "
 271             <<  this->ProjectName.c_str() << std::endl;
 272   this->PrintStringVector("this->IncludeDirectories;",
 273                           this->IncludeDirectories);
 274   this->PrintStringVector("this->LinkDirectories", this->LinkDirectories);
 275 #if defined(CMAKE_BUILD_WITH_CMAKE)
 276   for( std::vector<cmSourceGroup>::const_iterator i =
 277          this->SourceGroups.begin(); i != this->SourceGroups.end(); ++i)
 278     {
 279     std::cout << "Source Group: " << i->GetName() << std::endl;
 280     }
 281 #endif
 282 }
 283
 284 bool cmMakefile::CommandExists(const char* name) const
 285 {
 286   return this->GetCMakeInstance()->CommandExists(name);
 287 }
 288
 289
 290 //----------------------------------------------------------------------------
 291 void cmMakefile::IssueMessage(cmake::MessageType t,
 292                               std::string const& text) const
 293 {
 294   // Collect context information.
 295   cmListFileBacktrace backtrace;
 296   if(!this->CallStack.empty())
 297     {
 298     if((t == cmake::FATAL_ERROR) || (t == cmake::INTERNAL_ERROR))
 299       {
 300       this->CallStack.back().Status->SetNestedError(true);
 301       }
 302     this->GetBacktrace(backtrace);
 303     }
 304   else
 305     {
 306     cmListFileContext lfc;
 307     if(this->ListFileStack.empty())
 308       {
 309       // We are not processing the project.  Add the directory-level context.
 310       lfc.FilePath = this->GetCurrentDirectory();
 311       lfc.FilePath += "/CMakeLists.txt";
 312       }
 313     else
 314       {
 315       // We are processing the project but are not currently executing a
 316       // command.  Add whatever context information we have.
 317       lfc.FilePath = this->ListFileStack.back();
 318       }
 319     lfc.Line = 0;
 320     if(!this->GetCMakeInstance()->GetIsInTryCompile())
 321       {
 322       lfc.FilePath = this->LocalGenerator->Convert(lfc.FilePath.c_str(),
 323                                                    cmLocalGenerator::HOME);
 324       }
 325     backtrace.push_back(lfc);
 326     }
 327
 328   // Issue the message.
 329   this->GetCMakeInstance()->IssueMessage(t, text, backtrace);
 330 }
 331
 332 //----------------------------------------------------------------------------
 333 bool cmMakefile::GetBacktrace(cmListFileBacktrace& backtrace) const
 334 {
 335   if(this->CallStack.empty())
 336     {
 337     return false;
 338     }
 339   for(CallStackType::const_reverse_iterator i = this->CallStack.rbegin();
 340       i != this->CallStack.rend(); ++i)
 341     {
 342     cmListFileContext lfc = *(*i).Context;
 343     lfc.FilePath = this->LocalGenerator->Convert(lfc.FilePath.c_str(),
 344                                                  cmLocalGenerator::HOME);
 345     backtrace.push_back(lfc);
 346     }
 347   return true;
 348 }
 349
 350 //----------------------------------------------------------------------------
 351 // Helper class to make sure the call stack is valid.
 352 class cmMakefileCall
 353 {
 354 public:
 355   cmMakefileCall(cmMakefile* mf,
 356                  cmListFileContext const& lfc,
 357                  cmExecutionStatus& status): Makefile(mf)
 358     {
 359     cmMakefile::CallStackEntry entry = {&lfc, &status};
 360     this->Makefile->CallStack.push_back(entry);
 361     }
 362   ~cmMakefileCall()
 363     {
 364     this->Makefile->CallStack.pop_back();
 365     }
 366 private:
 367   cmMakefile* Makefile;
 368 };
 369
 370 //----------------------------------------------------------------------------
 371 bool cmMakefile::ExecuteCommand(const cmListFileFunction& lff,
 372                                 cmExecutionStatus &status)
 373 {
 374   bool result = true;
 375
 376   // quick return if blocked
 377   if(this->IsFunctionBlocked(lff,status))
 378     {
 379     // No error.
 380     return result;
 381     }
 382
 383   std::string name = lff.Name;
 384
 385   // Place this call on the call stack.
 386   cmMakefileCall stack_manager(this, lff, status);
 387   static_cast<void>(stack_manager);
 388
 389   // Lookup the command prototype.
 390   if(cmCommand* proto = this->GetCMakeInstance()->GetCommand(name.c_str()))
 391     {
 392     // Clone the prototype.
 393     cmsys::auto_ptr<cmCommand> pcmd(proto->Clone());
 394     pcmd->SetMakefile(this);
 395
 396     // Decide whether to invoke the command.
 397     if(pcmd->GetEnabled() && !cmSystemTools::GetFatalErrorOccured()  &&
 398        (!this->GetCMakeInstance()->GetScriptMode() || pcmd->IsScriptable()))
 399       {
 400       // if trace is one, print out invoke information
 401       if(this->GetCMakeInstance()->GetTrace())
 402         {
 403         cmOStringStream msg;
 404         msg << lff.FilePath << "(" << lff.Line << "):  ";
 405         msg << lff.Name << "(";
 406         for(std::vector<cmListFileArgument>::const_iterator i =
 407               lff.Arguments.begin(); i != lff.Arguments.end(); ++i)
 408           {
 409           msg << i->Value;
 410           msg << " ";
 411           }
 412         msg << ")";
 413         cmSystemTools::Message(msg.str().c_str());
 414         }
 415       // Try invoking the command.
 416       if(!pcmd->InvokeInitialPass(lff.Arguments,status) ||
 417          status.GetNestedError())
 418         {
 419         if(!status.GetNestedError())
 420           {
 421           // The command invocation requested that we report an error.
 422           this->IssueMessage(cmake::FATAL_ERROR, pcmd->GetError());
 423           }
 424         result = false;
 425         if ( this->GetCMakeInstance()->GetScriptMode() )
 426           {
 427           cmSystemTools::SetFatalErrorOccured();
 428           }
 429         }
 430       else
 431         {
 432         // use the command
 433         this->UsedCommands.push_back(pcmd.release());
 434         }
 435       }
 436     else if ( this->GetCMakeInstance()->GetScriptMode()
 437               && !pcmd->IsScriptable() )
 438       {
 439       std::string error = "Command ";
 440       error += pcmd->GetName();
 441       error += "() is not scriptable";
 442       this->IssueMessage(cmake::FATAL_ERROR, error);
 443       result = false;
 444       cmSystemTools::SetFatalErrorOccured();
 445       }
 446     }
 447   else
 448     {
 449     if(!cmSystemTools::GetFatalErrorOccured())
 450       {
 451       std::string error = "Unknown CMake command \"";
 452       error += lff.Name;
 453       error += "\".";
 454       this->IssueMessage(cmake::FATAL_ERROR, error);
 455       result = false;
 456       cmSystemTools::SetFatalErrorOccured();
 457       }
 458     }
 459
 460   return result;
 461 }
 462
 463 // Parse the given CMakeLists.txt file executing all commands
 464 //
 465 bool cmMakefile::ReadListFile(const char* filename_in,
 466                               const char *external_in,
 467                               std::string* fullPath)
 468 {
 469   std::string currentParentFile
 470     = this->GetSafeDefinition("CMAKE_PARENT_LIST_FILE");
 471   std::string currentFile
 472     = this->GetSafeDefinition("CMAKE_CURRENT_LIST_FILE");
 473   this->AddDefinition("CMAKE_PARENT_LIST_FILE", filename_in);
 474
 475   // used to watch for blockers going out of scope
 476   // e.g. mismatched IF statement
 477   std::set<cmFunctionBlocker *> originalBlockers;
 478
 479   const char* external = 0;
 480   std::string external_abs;
 481
 482   const char* filename = filename_in;
 483   std::string filename_abs;
 484
 485   if (external_in)
 486     {
 487     external_abs =
 488       cmSystemTools::CollapseFullPath(external_in,
 489                                       this->cmStartDirectory.c_str());
 490     external = external_abs.c_str();
 491     if (filename_in)
 492       {
 493       filename_abs =
 494         cmSystemTools::CollapseFullPath(filename_in,
 495                                         this->cmStartDirectory.c_str());
 496       filename = filename_abs.c_str();
 497       }
 498     }
 499
 500   // keep track of the current file being read
 501   if (filename)
 502     {
 503     if(this->cmCurrentListFile != filename)
 504       {
 505       this->cmCurrentListFile = filename;
 506       }
 507     }
 508
 509   // loop over current function blockers and record them
 510   for (std::list<cmFunctionBlocker *>::iterator pos
 511         = this->FunctionBlockers.begin();
 512        pos != this->FunctionBlockers.end(); ++pos)
 513     {
 514     originalBlockers.insert(*pos);
 515     }
 516
 517   // Now read the input file
 518   const char *filenametoread= filename;
 519
 520   if( external)
 521     {
 522     filenametoread= external;
 523     }
 524
 525   this->AddDefinition("CMAKE_CURRENT_LIST_FILE", filenametoread);
 526
 527   // try to see if the list file is the top most
 528   // list file for a project, and if it is, then it
 529   // must have a project command.   If there is not
 530   // one, then cmake will provide one via the
 531   // cmListFileCache class.
 532   bool requireProjectCommand = false;
 533   if(!external && this->cmStartDirectory == this->cmHomeDirectory)
 534     {
 535     if(cmSystemTools::LowerCase(
 536       cmSystemTools::GetFilenameName(filename)) == "cmakelists.txt")
 537       {
 538       requireProjectCommand = true;
 539       }
 540     }
 541
 542   // push the listfile onto the stack
 543   this->ListFileStack.push_back(filenametoread);
 544   if(fullPath!=0)
 545     {
 546     *fullPath=filenametoread;
 547     }
 548   cmListFile cacheFile;
 549   if( !cacheFile.ParseFile(filenametoread, requireProjectCommand, this) )
 550     {
 551     // pop the listfile off the stack
 552     this->ListFileStack.pop_back();
 553     if(fullPath!=0)
 554       {
 555       *fullPath = "";
 556       }
 557     this->AddDefinition("CMAKE_PARENT_LIST_FILE", currentParentFile.c_str());
 558     this->AddDefinition("CMAKE_CURRENT_LIST_FILE", currentFile.c_str());
 559     return false;
 560     }
 561   // add this list file to the list of dependencies
 562   this->ListFiles.push_back( filenametoread);
 563   bool endScopeNicely = true;
 564   const size_t numberFunctions = cacheFile.Functions.size();
 565   for(size_t i =0; i < numberFunctions; ++i)
 566     {
 567     cmExecutionStatus status;
 568     this->ExecuteCommand(cacheFile.Functions[i],status);
 569     if (status.GetReturnInvoked() ||
 570         cmSystemTools::GetFatalErrorOccured() )
 571       {
 572       // Exit early from processing this file.
 573       endScopeNicely = false;
 574       break;
 575       }
 576     }
 577
 578   // send scope ended to and function blockers
 579   if (endScopeNicely)
 580     {
 581     // loop over all function blockers to see if any block this command
 582     for (std::list<cmFunctionBlocker *>::iterator pos
 583          = this->FunctionBlockers.begin();
 584          pos != this->FunctionBlockers.end(); ++pos)
 585       {
 586       // if this blocker was not in the original then send a
 587       // scope ended message
 588       if (originalBlockers.find(*pos) == originalBlockers.end())
 589         {
 590         (*pos)->ScopeEnded(*this);
 591         }
 592       }
 593     }
 594
 595   // If this is the directory-level CMakeLists.txt file then perform
 596   // some extra checks.
 597   if(this->ListFileStack.size() == 1)
 598     {
 599     this->EnforceDirectoryLevelRules(endScopeNicely);
 600     }
 601
 602   this->AddDefinition("CMAKE_PARENT_LIST_FILE", currentParentFile.c_str());
 603   this->AddDefinition("CMAKE_CURRENT_LIST_FILE", currentFile.c_str());
 604
 605   // pop the listfile off the stack
 606   this->ListFileStack.pop_back();
 607
 608   return true;
 609 }
 610
 611 //----------------------------------------------------------------------------
 612 void cmMakefile::EnforceDirectoryLevelRules(bool endScopeNicely)
 613 {
 614   // Enforce policy stack depth.
 615   while(this->PolicyStack.size() > 1)
 616     {
 617     if(endScopeNicely)
 618       {
 619       this->IssueMessage(cmake::FATAL_ERROR,
 620                          "cmake_policy PUSH without matching POP");
 621       }
 622     this->PopPolicy(false);
 623     }
 624
 625   // Diagnose a violation of CMP0000 if necessary.
 626   if(this->CheckCMP0000)
 627     {
 628     cmOStringStream msg;
 629     msg << "No cmake_minimum_required command is present.  "
 630         << "A line of code such as\n"
 631         << "  cmake_minimum_required(VERSION "
 632         << cmVersion::GetMajorVersion() << "."
 633         << cmVersion::GetMinorVersion()
 634         << ")\n"
 635         << "should be added at the top of the file.  "
 636         << "The version specified may be lower if you wish to "
 637         << "support older CMake versions for this project.  "
 638         << "For more information run "
 639         << "\"cmake --help-policy CMP0000\".";
 640     switch (this->GetPolicyStatus(cmPolicies::CMP0000))
 641       {
 642       case cmPolicies::WARN:
 643         // Warn because the user did not provide a mimimum required
 644         // version.
 645         this->IssueMessage(cmake::AUTHOR_WARNING, msg.str().c_str());
 646       case cmPolicies::OLD:
 647         // OLD behavior is to use policy version 2.4 set in
 648         // cmListFileCache.
 649         break;
 650       case cmPolicies::REQUIRED_IF_USED:
 651       case cmPolicies::REQUIRED_ALWAYS:
 652       case cmPolicies::NEW:
 653         // NEW behavior is to issue an error.
 654         this->IssueMessage(cmake::FATAL_ERROR, msg.str().c_str());
 655         cmSystemTools::SetFatalErrorOccured();
 656         return;
 657       }
 658     }
 659 }
 660
 661 void cmMakefile::AddCommand(cmCommand* wg)
 662 {
 663   this->GetCMakeInstance()->AddCommand(wg);
 664 }
 665
 666 // Set the make file
 667 void cmMakefile::SetLocalGenerator(cmLocalGenerator* lg)
 668 {
 669   this->LocalGenerator = lg;
 670 }
 671
 672 bool cmMakefile::NeedBackwardsCompatibility(unsigned int major,
 673                                             unsigned int minor,
 674                                             unsigned int patch)
 675 {
 676   if(this->LocalGenerator)
 677     {
 678     return
 679       this->LocalGenerator->NeedBackwardsCompatibility(major, minor, patch);
 680     }
 681   else
 682     {
 683     return false;
 684     }
 685 }
 686
 687 void cmMakefile::FinalPass()
 688 {
 689   // do all the variable expansions here
 690   this->ExpandVariables();
 691
 692   // give all the commands a chance to do something
 693   // after the file has been parsed before generation
 694   for(std::vector<cmCommand*>::iterator i = this->UsedCommands.begin();
 695       i != this->UsedCommands.end(); ++i)
 696     {
 697     (*i)->FinalPass();
 698     }
 699
 700 }
 701
 702 // Generate the output file
 703 void cmMakefile::ConfigureFinalPass()
 704 {
 705   this->FinalPass();
 706   const char* oldValue
 707     = this->GetDefinition("CMAKE_BACKWARDS_COMPATIBILITY");
 708   if (oldValue && atof(oldValue) <= 1.2)
 709     {
 710     cmSystemTools::Error("You have requested backwards compatibility "
 711                          "with CMake version 1.2 or earlier. This version "
 712                          "of CMake only supports backwards compatibility "
 713                          "with CMake 1.4 or later. For compatibility with "
 714                          "1.2 or earlier please use CMake 2.0");
 715     }
 716   for (cmTargets::iterator l = this->Targets.begin();
 717        l != this->Targets.end(); l++)
 718     {
 719     l->second.AnalyzeLibDependencies(*this);
 720     }
 721 }
 722
 723 //----------------------------------------------------------------------------
 724 void
 725 cmMakefile::AddCustomCommandToTarget(const char* target,
 726                                      const std::vector<std::string>& depends,
 727                                      const cmCustomCommandLines& commandLines,
 728                                      cmTarget::CustomCommandType type,
 729                                      const char* comment,
 730                                      const char* workingDir,
 731                                      bool escapeOldStyle)
 732 {
 733   // Find the target to which to add the custom command.
 734   cmTargets::iterator ti = this->Targets.find(target);
 735   if(ti != this->Targets.end())
 736     {
 737     // Add the command to the appropriate build step for the target.
 738     std::vector<std::string> no_output;
 739     cmCustomCommand cc(no_output, depends, commandLines, comment, workingDir);
 740     cc.SetEscapeOldStyle(escapeOldStyle);
 741     cc.SetEscapeAllowMakeVars(true);
 742     switch(type)
 743       {
 744       case cmTarget::PRE_BUILD:
 745         ti->second.GetPreBuildCommands().push_back(cc);
 746         break;
 747       case cmTarget::PRE_LINK:
 748         ti->second.GetPreLinkCommands().push_back(cc);
 749         break;
 750       case cmTarget::POST_BUILD:
 751         ti->second.GetPostBuildCommands().push_back(cc);
 752         break;
 753       }
 754     }
 755 }
 756
 757 //----------------------------------------------------------------------------
 758 void
 759 cmMakefile::AddCustomCommandToOutput(const std::vector<std::string>& outputs,
 760                                      const std::vector<std::string>& depends,
 761                                      const char* main_dependency,
 762                                      const cmCustomCommandLines& commandLines,
 763                                      const char* comment,
 764                                      const char* workingDir,
 765                                      bool replace,
 766                                      bool escapeOldStyle)
 767 {
 768   // Make sure there is at least one output.
 769   if(outputs.empty())
 770     {
 771     cmSystemTools::Error("Attempt to add a custom rule with no output!");
 772     return;
 773     }
 774
 775   // Choose a source file on which to store the custom command.
 776   cmSourceFile* file = 0;
 777   if(main_dependency && main_dependency[0])
 778     {
 779     // The main dependency was specified.  Use it unless a different
 780     // custom command already used it.
 781     file = this->GetSource(main_dependency);
 782     if(file && file->GetCustomCommand() && !replace)
 783       {
 784       // The main dependency already has a custom command.
 785       if(commandLines == file->GetCustomCommand()->GetCommandLines())
 786         {
 787         // The existing custom command is identical.  Silently ignore
 788         // the duplicate.
 789         return;
 790         }
 791       else
 792         {
 793         // The existing custom command is different.  We need to
 794         // generate a rule file for this new command.
 795         file = 0;
 796         }
 797       }
 798     else
 799       {
 800       // The main dependency does not have a custom command or we are
 801       // allowed to replace it.  Use it to store the command.
 802       file = this->GetOrCreateSource(main_dependency);
 803       }
 804     }
 805
 806   // Generate a rule file if the main dependency is not available.
 807   if(!file)
 808     {
 809     // Construct a rule file associated with the first output produced.
 810     std::string outName = outputs[0];
 811     outName += ".rule";
 812
 813     // Check if the rule file already exists.
 814     file = this->GetSource(outName.c_str());
 815     if(file && file->GetCustomCommand() && !replace)
 816       {
 817       // The rule file already exists.
 818       if(commandLines != file->GetCustomCommand()->GetCommandLines())
 819         {
 820         cmSystemTools::Error("Attempt to add a custom rule to output \"",
 821                              outName.c_str(),
 822                              "\" which already has a custom rule.");
 823         }
 824       return;
 825       }
 826
 827     // Create a cmSourceFile for the rule file.
 828     file = this->GetOrCreateSource(outName.c_str(), true);
 829     }
 830
 831   // Always create the output sources and mark them generated.
 832   for(std::vector<std::string>::const_iterator o = outputs.begin();
 833       o != outputs.end(); ++o)
 834     {
 835     if(cmSourceFile* out = this->GetOrCreateSource(o->c_str(), true))
 836       {
 837       out->SetProperty("GENERATED", "1");
 838       }
 839     }
 840
 841   // Construct a complete list of dependencies.
 842   std::vector<std::string> depends2(depends);
 843   if(main_dependency && main_dependency[0])
 844     {
 845     depends2.push_back(main_dependency);
 846     }
 847
 848   // Attach the custom command to the file.
 849   if(file)
 850     {
 851     cmCustomCommand* cc =
 852       new cmCustomCommand(outputs, depends2, commandLines,
 853                           comment, workingDir);
 854     cc->SetEscapeOldStyle(escapeOldStyle);
 855     cc->SetEscapeAllowMakeVars(true);
 856     file->SetCustomCommand(cc);
 857     }
 858 }
 859
 860 //----------------------------------------------------------------------------
 861 void
 862 cmMakefile::AddCustomCommandToOutput(const char* output,
 863                                      const std::vector<std::string>& depends,
 864                                      const char* main_dependency,
 865                                      const cmCustomCommandLines& commandLines,
 866                                      const char* comment,
 867                                      const char* workingDir,
 868                                      bool replace,
 869                                      bool escapeOldStyle)
 870 {
 871   std::vector<std::string> outputs;
 872   outputs.push_back(output);
 873   this->AddCustomCommandToOutput(outputs, depends, main_dependency,
 874                                  commandLines, comment, workingDir,
 875                                  replace, escapeOldStyle);
 876 }
 877
 878 //----------------------------------------------------------------------------
 879 void
 880 cmMakefile::AddCustomCommandOldStyle(const char* target,
 881                                      const std::vector<std::string>& outputs,
 882                                      const std::vector<std::string>& depends,
 883                                      const char* source,
 884                                      const cmCustomCommandLines& commandLines,
 885                                      const char* comment)
 886 {
 887   // Translate the old-style signature to one of the new-style
 888   // signatures.
 889   if(strcmp(source, target) == 0)
 890     {
 891     // In the old-style signature if the source and target were the
 892     // same then it added a post-build rule to the target.  Preserve
 893     // this behavior.
 894     this->AddCustomCommandToTarget(target, depends, commandLines,
 895                                    cmTarget::POST_BUILD, comment, 0);
 896     return;
 897     }
 898
 899   // Each output must get its own copy of this rule.
 900   cmsys::RegularExpression sourceFiles("\\.(C|M|c|c\\+\\+|cc|cpp|cxx|m|mm|"
 901                                        "rc|def|r|odl|idl|hpj|bat|h|h\\+\\+|"
 902                                        "hm|hpp|hxx|in|txx|inl)$");
 903   for(std::vector<std::string>::const_iterator oi = outputs.begin();
 904       oi != outputs.end(); ++oi)
 905     {
 906     // Get the name of this output.
 907     const char* output = oi->c_str();
 908
 909     // Choose whether to use a main dependency.
 910     if(sourceFiles.find(source))
 911       {
 912       // The source looks like a real file.  Use it as the main dependency.
 913       this->AddCustomCommandToOutput(output, depends, source,
 914                                      commandLines, comment, 0);
 915       }
 916     else
 917       {
 918       // The source may not be a real file.  Do not use a main dependency.
 919       const char* no_main_dependency = 0;
 920       std::vector<std::string> depends2 = depends;
 921       depends2.push_back(source);
 922       this->AddCustomCommandToOutput(output, depends2, no_main_dependency,
 923                                      commandLines, comment, 0);
 924       }
 925
 926     // If the rule was added to the source (and not a .rule file),
 927     // then add the source to the target to make sure the rule is
 928     // included.
 929     std::string sname = output;
 930     sname += ".rule";
 931     if(!this->GetSource(sname.c_str()))
 932       {
 933       if (this->Targets.find(target) != this->Targets.end())
 934         {
 935         this->Targets[target].AddSource(source);
 936         }
 937       else
 938         {
 939         cmSystemTools::Error("Attempt to add a custom rule to a target "
 940                              "that does not exist yet for target ", target);
 941         return;
 942         }
 943       }
 944     }
 945 }
 946
 947 //----------------------------------------------------------------------------
 948 void cmMakefile::AddUtilityCommand(const char* utilityName,
 949                                    bool excludeFromAll,
 950                                    const std::vector<std::string>& depends,
 951                                    const char* workingDirectory,
 952                                    const char* command,
 953                                    const char* arg1,
 954                                    const char* arg2,
 955                                    const char* arg3,
 956                                    const char* arg4)
 957 {
 958   // Construct the command line for the custom command.
 959   cmCustomCommandLine commandLine;
 960   commandLine.push_back(command);
 961   if(arg1)
 962     {
 963     commandLine.push_back(arg1);
 964     }
 965   if(arg2)
 966     {
 967     commandLine.push_back(arg2);
 968     }
 969   if(arg3)
 970     {
 971     commandLine.push_back(arg3);
 972     }
 973   if(arg4)
 974     {
 975     commandLine.push_back(arg4);
 976     }
 977   cmCustomCommandLines commandLines;
 978   commandLines.push_back(commandLine);
 979
 980   // Call the real signature of this method.
 981   this->AddUtilityCommand(utilityName, excludeFromAll, workingDirectory,
 982                           depends, commandLines);
 983 }
 984
 985 //----------------------------------------------------------------------------
 986 cmTarget*
 987 cmMakefile::AddUtilityCommand(const char* utilityName,
 988                               bool excludeFromAll,
 989                               const char* workingDirectory,
 990                               const std::vector<std::string>& depends,
 991                               const cmCustomCommandLines& commandLines,
 992                               bool escapeOldStyle, const char* comment)
 993 {
 994   // Create a target instance for this utility.
 995   cmTarget* target = this->AddNewTarget(cmTarget::UTILITY, utilityName);
 996   if (excludeFromAll)
 997     {
 998     target->SetProperty("EXCLUDE_FROM_ALL", "TRUE");
 999     }
1000   if(!comment)
1001     {
1002     // Use an empty comment to avoid generation of default comment.
1003     comment = "";
1004     }
1005
1006   // Store the custom command in the target.
1007   std::string force = this->GetStartOutputDirectory();
1008   force += cmake::GetCMakeFilesDirectory();
1009   force += "/";
1010   force += utilityName;
1011   const char* no_main_dependency = 0;
1012   bool no_replace = false;
1013   this->AddCustomCommandToOutput(force.c_str(), depends,
1014                                  no_main_dependency,
1015                                  commandLines, comment,
1016                                  workingDirectory, no_replace,
1017                                  escapeOldStyle);
1018   cmSourceFile* sf = target->AddSource(force.c_str());
1019
1020   // The output is not actually created so mark it symbolic.
1021   if(sf)
1022     {
1023     sf->SetProperty("SYMBOLIC", "1");
1024     }
1025   else
1026     {
1027     cmSystemTools::Error("Could not get source file entry for ",
1028                          force.c_str());
1029     }
1030   return target;
1031 }
1032
1033 void cmMakefile::AddDefineFlag(const char* flag)
1034 {
1035   if (!flag)
1036     {
1037     return;
1038     }
1039
1040   // Update the string used for the old DEFINITIONS property.
1041   this->AddDefineFlag(flag, this->DefineFlagsOrig);
1042
1043   // If this is really a definition, update COMPILE_DEFINITIONS.
1044   if(this->ParseDefineFlag(flag, false))
1045     {
1046     return;
1047     }
1048
1049   // Add this flag that does not look like a definition.
1050   this->AddDefineFlag(flag, this->DefineFlags);
1051 }
1052
1053 void cmMakefile::AddDefineFlag(const char* flag, std::string& dflags)
1054 {
1055   // remove any \n\r
1056   std::string ret = flag;
1057   std::string::size_type pos = 0;
1058   while((pos = ret.find('\n', pos)) != std::string::npos)
1059     {
1060     ret[pos] = ' ';
1061     pos++;
1062     }
1063   pos = 0;
1064   while((pos = ret.find('\r', pos)) != std::string::npos)
1065     {
1066     ret[pos] = ' ';
1067     pos++;
1068     }
1069
1070   dflags += " ";
1071   dflags += ret;
1072 }
1073
1074
1075 void cmMakefile::RemoveDefineFlag(const char* flag)
1076 {
1077   // Check the length of the flag to remove.
1078   std::string::size_type len = strlen(flag);
1079   if(len < 1)
1080     {
1081     return;
1082     }
1083
1084   // Update the string used for the old DEFINITIONS property.
1085   this->RemoveDefineFlag(flag, len, this->DefineFlagsOrig);
1086
1087   // If this is really a definition, update COMPILE_DEFINITIONS.
1088   if(this->ParseDefineFlag(flag, true))
1089     {
1090     return;
1091     }
1092
1093   // Remove this flag that does not look like a definition.
1094   this->RemoveDefineFlag(flag, len, this->DefineFlags);
1095 }
1096
1097 void cmMakefile::RemoveDefineFlag(const char* flag,
1098                                   std::string::size_type len,
1099                                   std::string& dflags)
1100 {
1101   // Remove all instances of the flag that are surrounded by
1102   // whitespace or the beginning/end of the string.
1103   for(std::string::size_type lpos = dflags.find(flag, 0);
1104       lpos != std::string::npos; lpos = dflags.find(flag, lpos))
1105     {
1106     std::string::size_type rpos = lpos + len;
1107     if((lpos <= 0 || isspace(dflags[lpos-1])) &&
1108        (rpos >= dflags.size() || isspace(dflags[rpos])))
1109       {
1110       dflags.erase(lpos, len);
1111       }
1112     else
1113       {
1114       ++lpos;
1115       }
1116     }
1117 }
1118
1119 bool cmMakefile::ParseDefineFlag(std::string const& def, bool remove)
1120 {
1121   // Create a regular expression to match valid definitions.
1122   static cmsys::RegularExpression
1123     valid("^[-/]D[A-Za-z_][A-Za-z0-9_]*(=.*)?$");
1124
1125   // Make sure the definition matches.
1126   if(!valid.find(def.c_str()))
1127     {
1128     return false;
1129     }
1130
1131   // VS6 IDE does not support definitions with values.
1132   if((strcmp(this->LocalGenerator->GetGlobalGenerator()->GetName(),
1133              "Visual Studio 6") == 0) &&
1134      (def.find("=") != def.npos))
1135     {
1136     return false;
1137     }
1138
1139   // Definitions with non-trivial values require a policy check.
1140   static cmsys::RegularExpression
1141     trivial("^[-/]D[A-Za-z_][A-Za-z0-9_]*(=[A-Za-z0-9_.]+)?$");
1142   if(!trivial.find(def.c_str()))
1143     {
1144     // This definition has a non-trivial value.
1145     switch(this->GetPolicyStatus(cmPolicies::CMP0005))
1146       {
1147       case cmPolicies::WARN:
1148         this->IssueMessage(
1149           cmake::AUTHOR_WARNING,
1150           this->GetPolicies()->GetPolicyWarning(cmPolicies::CMP0005)
1151           );
1152       case cmPolicies::OLD:
1153         // OLD behavior is to not escape the value.  We should not
1154         // convert the definition to use the property.
1155         return false;
1156       case cmPolicies::REQUIRED_IF_USED:
1157       case cmPolicies::REQUIRED_ALWAYS:
1158         this->IssueMessage(
1159           cmake::FATAL_ERROR,
1160           this->GetPolicies()->GetRequiredPolicyError(cmPolicies::CMP0005)
1161           );
1162         return false;
1163       case cmPolicies::NEW:
1164         // NEW behavior is to escape the value.  Proceed to convert it
1165         // to an entry in the property.
1166         break;
1167       }
1168     }
1169
1170   // Get the definition part after the flag.
1171   const char* define = def.c_str() + 2;
1172
1173   if(remove)
1174     {
1175     if(const char* cdefs = this->GetProperty("COMPILE_DEFINITIONS"))
1176       {
1177       // Expand the list.
1178       std::vector<std::string> defs;
1179       cmSystemTools::ExpandListArgument(cdefs, defs);
1180
1181       // Recompose the list without the definition.
1182       std::string ndefs;
1183       const char* sep = "";
1184       for(std::vector<std::string>::const_iterator di = defs.begin();
1185           di != defs.end(); ++di)
1186         {
1187         if(*di != define)
1188           {
1189           ndefs += sep;
1190           sep = ";";
1191           ndefs += *di;
1192           }
1193         }
1194
1195       // Store the new list.
1196       this->SetProperty("COMPILE_DEFINITIONS", ndefs.c_str());
1197       }
1198     }
1199   else
1200     {
1201     // Append the definition to the directory property.
1202     this->AppendProperty("COMPILE_DEFINITIONS", define);
1203     }
1204
1205   return true;
1206 }
1207
1208 void cmMakefile::AddLinkLibrary(const char* lib,
1209                                 cmTarget::LinkLibraryType llt)
1210 {
1211   cmTarget::LibraryID tmp;
1212   tmp.first = lib;
1213   tmp.second = llt;
1214   this->LinkLibraries.push_back(tmp);
1215 }
1216
1217 void cmMakefile::AddLinkLibraryForTarget(const char *target,
1218                                          const char* lib,
1219                                          cmTarget::LinkLibraryType llt)
1220 {
1221   cmTargets::iterator i = this->Targets.find(target);
1222   if ( i != this->Targets.end())
1223     {
1224     cmTarget* tgt =
1225       this->GetCMakeInstance()->GetGlobalGenerator()->FindTarget(0,lib);
1226     if(tgt)
1227       {
1228       // CMake versions below 2.4 allowed linking to modules.
1229       bool allowModules = this->NeedBackwardsCompatibility(2,2);
1230       // if it is not a static or shared library then you can not link to it
1231       if(!((tgt->GetType() == cmTarget::STATIC_LIBRARY) ||
1232            (tgt->GetType() == cmTarget::SHARED_LIBRARY) ||
1233            tgt->IsExecutableWithExports()))
1234         {
1235         cmOStringStream e;
1236         e << "Target \"" << lib << "\" of type "
1237           << cmTarget::TargetTypeNames[static_cast<int>(tgt->GetType())]
1238           << " may not be linked into another target.  "
1239           << "One may link only to STATIC or SHARED libraries, or "
1240           << "to executables with the ENABLE_EXPORTS property set.";
1241         // in older versions of cmake linking to modules was allowed
1242         if( tgt->GetType() == cmTarget::MODULE_LIBRARY )
1243           {
1244           e << "\n"
1245             << "If you are developing a new project, re-organize it to avoid "
1246             << "linking to modules.  "
1247             << "If you are just trying to build an existing project, "
1248             << "set CMAKE_BACKWARDS_COMPATIBILITY to 2.2 or lower to allow "
1249             << "linking to modules.";
1250           }
1251         // if no modules are allowed then this is always an error
1252         if(!allowModules ||
1253            // if we allow modules but the type is not a module then it is
1254            // still an error
1255            (allowModules && tgt->GetType() != cmTarget::MODULE_LIBRARY))
1256           {
1257           this->IssueMessage(cmake::FATAL_ERROR, e.str().c_str());
1258           }
1259         }
1260       }
1261     i->second.AddLinkLibrary( *this, target, lib, llt );
1262     }
1263   else
1264     {
1265     cmOStringStream e;
1266     e << "Attempt to add link library \""
1267       << lib << "\" to target \""
1268       << target << "\" which is not built by this project.";
1269     cmSystemTools::Error(e.str().c_str());
1270     }
1271 }
1272
1273 void cmMakefile::AddLinkDirectoryForTarget(const char *target,
1274                                            const char* d)
1275 {
1276   cmTargets::iterator i = this->Targets.find(target);
1277   if ( i != this->Targets.end())
1278     {
1279     i->second.AddLinkDirectory( d );
1280     }
1281   else
1282     {
1283     cmSystemTools::Error
1284       ("Attempt to add link directories to non-existant target: ",
1285        target, " for directory ", d);
1286     }
1287 }
1288
1289 void cmMakefile::AddLinkLibrary(const char* lib)
1290 {
1291   this->AddLinkLibrary(lib,cmTarget::GENERAL);
1292 }
1293
1294 void cmMakefile::AddLinkDirectory(const char* dir)
1295 {
1296   // Don't add a link directory that is already present.  Yes, this
1297   // linear search results in n^2 behavior, but n won't be getting
1298   // much bigger than 20.  We cannot use a set because of order
1299   // dependency of the link search path.
1300
1301   if(!dir)
1302     {
1303     return;
1304     }
1305   // remove trailing slashes
1306   if(dir[strlen(dir)-1] == '/')
1307     {
1308     std::string newdir = dir;
1309     newdir = newdir.substr(0, newdir.size()-1);
1310     if(std::find(this->LinkDirectories.begin(),
1311                  this->LinkDirectories.end(),
1312                  newdir.c_str()) == this->LinkDirectories.end())
1313       {
1314       this->LinkDirectories.push_back(newdir);
1315       }
1316     }
1317   else
1318     {
1319     if(std::find(this->LinkDirectories.begin(),
1320                  this->LinkDirectories.end(), dir)
1321        == this->LinkDirectories.end())
1322       {
1323       this->LinkDirectories.push_back(dir);
1324       }
1325     }
1326 }
1327
1328 void cmMakefile::InitializeFromParent()
1329 {
1330   cmMakefile *parent = this->LocalGenerator->GetParent()->GetMakefile();
1331
1332   // copy the definitions
1333   this->DefinitionStack.front() = parent->DefinitionStack.back();
1334
1335   // copy include paths
1336   this->IncludeDirectories = parent->IncludeDirectories;
1337   this->SystemIncludeDirectories = parent->SystemIncludeDirectories;
1338
1339   // define flags
1340   this->DefineFlags = parent->DefineFlags;
1341   this->DefineFlagsOrig = parent->DefineFlagsOrig;
1342
1343   // Include transform property.  There is no per-config version.
1344   {
1345   const char* prop = "IMPLICIT_DEPENDS_INCLUDE_TRANSFORM";
1346   this->SetProperty(prop, parent->GetProperty(prop));
1347   }
1348
1349   // compile definitions property and per-config versions
1350   {
1351   this->SetProperty("COMPILE_DEFINITIONS",
1352                     parent->GetProperty("COMPILE_DEFINITIONS"));
1353   std::vector<std::string> configs;
1354   if(const char* configTypes =
1355      this->GetDefinition("CMAKE_CONFIGURATION_TYPES"))
1356     {
1357     cmSystemTools::ExpandListArgument(configTypes, configs);
1358     }
1359   else if(const char* buildType =
1360           this->GetDefinition("CMAKE_BUILD_TYPE"))
1361     {
1362     configs.push_back(buildType);
1363     }
1364   for(std::vector<std::string>::const_iterator ci = configs.begin();
1365       ci != configs.end(); ++ci)
1366     {
1367     std::string defPropName = "COMPILE_DEFINITIONS_";
1368     defPropName += cmSystemTools::UpperCase(*ci);
1369     this->SetProperty(defPropName.c_str(),
1370                       parent->GetProperty(defPropName.c_str()));
1371     }
1372   }
1373
1374   // link libraries
1375   this->LinkLibraries = parent->LinkLibraries;
1376
1377   // link directories
1378   this->LinkDirectories = parent->LinkDirectories;
1379
1380   // the initial project name
1381   this->ProjectName = parent->ProjectName;
1382
1383   // Copy include regular expressions.
1384   this->IncludeFileRegularExpression = parent->IncludeFileRegularExpression;
1385   this->ComplainFileRegularExpression = parent->ComplainFileRegularExpression;
1386
1387   // Imported targets.
1388   this->ImportedTargets = parent->ImportedTargets;
1389 }
1390
1391 void cmMakefile::ConfigureSubDirectory(cmLocalGenerator *lg2)
1392 {
1393   // copy our variables from the child makefile
1394   lg2->GetMakefile()->InitializeFromParent();
1395   lg2->GetMakefile()->MakeStartDirectoriesCurrent();
1396   if (this->GetCMakeInstance()->GetDebugOutput())
1397     {
1398     std::string msg="   Entering             ";
1399     msg += lg2->GetMakefile()->GetCurrentDirectory();
1400     cmSystemTools::Message(msg.c_str());
1401     }
1402   // finally configure the subdir
1403   lg2->Configure();
1404   if (this->GetCMakeInstance()->GetDebugOutput())
1405     {
1406     std::string msg="   Returning to         ";
1407     msg += this->GetCurrentDirectory();
1408     cmSystemTools::Message(msg.c_str());
1409     }
1410 }
1411
1412 void cmMakefile::AddSubDirectory(const char* sub,
1413                                  bool excludeFromAll, bool preorder)
1414 {
1415   // the source path must be made full if it isn't already
1416   std::string srcPath = sub;
1417   if (!cmSystemTools::FileIsFullPath(srcPath.c_str()))
1418     {
1419     srcPath = this->GetCurrentDirectory();
1420     srcPath += "/";
1421     srcPath += sub;
1422     }
1423
1424   // binary path must be made full if it isn't already
1425   std::string binPath = sub;
1426   if (!cmSystemTools::FileIsFullPath(binPath.c_str()))
1427     {
1428     binPath = this->GetCurrentOutputDirectory();
1429     binPath += "/";
1430     binPath += sub;
1431     }
1432
1433
1434   this->AddSubDirectory(srcPath.c_str(), binPath.c_str(),
1435                         excludeFromAll, preorder, false);
1436 }
1437
1438
1439 void cmMakefile::AddSubDirectory(const char* srcPath, const char *binPath,
1440                                  bool excludeFromAll, bool preorder,
1441                                  bool immediate)
1442 {
1443   std::vector<cmLocalGenerator *>& children =
1444     this->LocalGenerator->GetChildren();
1445   // has this directory already been added? If so error
1446   unsigned int i;
1447   for (i = 0; i < children.size(); ++i)
1448     {
1449     if (srcPath == children[i]->GetMakefile()->GetStartDirectory())
1450       {
1451       cmSystemTools::Error
1452         ("Attempt to add subdirectory multiple times for directory.\n",
1453          srcPath);
1454       return;
1455       }
1456     }
1457
1458   // create a new local generator and set its parent
1459   cmLocalGenerator *lg2 =
1460     this->LocalGenerator->GetGlobalGenerator()->CreateLocalGenerator();
1461   lg2->SetParent(this->LocalGenerator);
1462   this->LocalGenerator->GetGlobalGenerator()->AddLocalGenerator(lg2);
1463
1464   // set the subdirs start dirs
1465   lg2->GetMakefile()->SetStartDirectory(srcPath);
1466   lg2->GetMakefile()->SetStartOutputDirectory(binPath);
1467   if(excludeFromAll)
1468     {
1469     lg2->GetMakefile()->SetProperty("EXCLUDE_FROM_ALL", "TRUE");
1470     }
1471   lg2->GetMakefile()->SetPreOrder(preorder);
1472
1473   if (immediate)
1474     {
1475     this->ConfigureSubDirectory(lg2);
1476     }
1477 }
1478
1479 void cmMakefile::AddIncludeDirectory(const char* inc, bool before)
1480 {
1481   // if there is a newline then break it into multiple arguments
1482   if (!inc)
1483     {
1484     return;
1485     }
1486
1487   // Don't add an include directory that is already present.  Yes,
1488   // this linear search results in n^2 behavior, but n won't be
1489   // getting much bigger than 20.  We cannot use a set because of
1490   // order dependency of the include path.
1491   std::vector<std::string>::iterator i =
1492     std::find(this->IncludeDirectories.begin(),
1493               this->IncludeDirectories.end(), inc);
1494   if(i == this->IncludeDirectories.end())
1495     {
1496     if (before)
1497       {
1498       // WARNING: this *is* expensive (linear time) since it's a vector
1499       this->IncludeDirectories.insert(this->IncludeDirectories.begin(), inc);
1500       }
1501     else
1502       {
1503       this->IncludeDirectories.push_back(inc);
1504       }
1505     }
1506   else
1507     {
1508     if(before)
1509       {
1510       // if this before and already in the path then remove it
1511       this->IncludeDirectories.erase(i);
1512       // WARNING: this *is* expensive (linear time) since it's a vector
1513       this->IncludeDirectories.insert(this->IncludeDirectories.begin(), inc);
1514       }
1515     }
1516 }
1517
1518 //----------------------------------------------------------------------------
1519 void cmMakefile::AddSystemIncludeDirectory(const char* dir)
1520 {
1521   this->SystemIncludeDirectories.insert(dir);
1522 }
1523
1524 //----------------------------------------------------------------------------
1525 bool cmMakefile::IsSystemIncludeDirectory(const char* dir)
1526 {
1527   return (this->SystemIncludeDirectories.find(dir) !=
1528           this->SystemIncludeDirectories.end());
1529 }
1530
1531 void cmMakefile::AddDefinition(const char* name, const char* value)
1532 {
1533   if (!value )
1534     {
1535     return;
1536     }
1537
1538 #ifdef CMAKE_STRICT
1539   if (this->GetCMakeInstance())
1540     {
1541     this->GetCMakeInstance()->
1542       RecordPropertyAccess(name,cmProperty::VARIABLE);
1543     }
1544 #endif
1545
1546   this->TemporaryDefinitionKey = name;
1547   this->DefinitionStack.back()[this->TemporaryDefinitionKey] = value;
1548
1549 #ifdef CMAKE_BUILD_WITH_CMAKE
1550   cmVariableWatch* vv = this->GetVariableWatch();
1551   if ( vv )
1552     {
1553     vv->VariableAccessed(this->TemporaryDefinitionKey,
1554                          cmVariableWatch::VARIABLE_MODIFIED_ACCESS,
1555                          value,
1556                          this);
1557     }
1558 #endif
1559 }
1560
1561
1562 void cmMakefile::AddCacheDefinition(const char* name, const char* value,
1563                                     const char* doc,
1564                                     cmCacheManager::CacheEntryType type)
1565 {
1566   const char* val = value;
1567   cmCacheManager::CacheIterator it =
1568     this->GetCacheManager()->GetCacheIterator(name);
1569   if(!it.IsAtEnd() && (it.GetType() == cmCacheManager::UNINITIALIZED) &&
1570      it.Initialized())
1571     {
1572     val = it.GetValue();
1573     if ( type == cmCacheManager::PATH || type == cmCacheManager::FILEPATH )
1574       {
1575       std::vector<std::string>::size_type cc;
1576       std::vector<std::string> files;
1577       std::string nvalue = "";
1578       cmSystemTools::ExpandListArgument(val, files);
1579       for ( cc = 0; cc < files.size(); cc ++ )
1580         {
1581         files[cc] = cmSystemTools::CollapseFullPath(files[cc].c_str());
1582         if ( cc > 0 )
1583           {
1584           nvalue += ";";
1585           }
1586         nvalue += files[cc];
1587         }
1588
1589       this->GetCacheManager()->AddCacheEntry(name, nvalue.c_str(), doc, type);
1590       val = it.GetValue();
1591       }
1592
1593     }
1594   this->GetCacheManager()->AddCacheEntry(name, val, doc, type);
1595   // if there was a definition then remove it
1596   this->DefinitionStack.back().erase( DefinitionMap::key_type(name));
1597 }
1598
1599
1600 void cmMakefile::AddDefinition(const char* name, bool value)
1601 {
1602   if(value)
1603     {
1604     this->DefinitionStack.back()
1605       .erase( DefinitionMap::key_type(name));
1606     this->DefinitionStack.back()
1607       .insert(DefinitionMap::value_type(name, "ON"));
1608     }
1609   else
1610     {
1611     this->DefinitionStack.back()
1612       .erase( DefinitionMap::key_type(name));
1613     this->DefinitionStack.back()
1614       .insert(DefinitionMap::value_type(name, "OFF"));
1615     }
1616 #ifdef CMAKE_BUILD_WITH_CMAKE
1617   cmVariableWatch* vv = this->GetVariableWatch();
1618   if ( vv )
1619     {
1620     vv->VariableAccessed(name, cmVariableWatch::VARIABLE_MODIFIED_ACCESS,
1621       value?"ON":"OFF", this);
1622     }
1623 #endif
1624 }
1625
1626
1627 void cmMakefile::AddCacheDefinition(const char* name,
1628                                     bool value,
1629                                     const char* doc)
1630 {
1631   bool val = value;
1632   cmCacheManager::CacheIterator it =
1633     this->GetCacheManager()->GetCacheIterator(name);
1634   if(!it.IsAtEnd() && (it.GetType() == cmCacheManager::UNINITIALIZED) &&
1635      it.Initialized())
1636     {
1637     val = it.GetValueAsBool();
1638     }
1639   this->GetCacheManager()->AddCacheEntry(name, val, doc);
1640   this->AddDefinition(name, val);
1641 }
1642
1643 void cmMakefile::RemoveDefinition(const char* name)
1644 {
1645   this->DefinitionStack.back().erase(DefinitionMap::key_type(name));
1646 #ifdef CMAKE_BUILD_WITH_CMAKE
1647   cmVariableWatch* vv = this->GetVariableWatch();
1648   if ( vv )
1649     {
1650     vv->VariableAccessed(name, cmVariableWatch::VARIABLE_REMOVED_ACCESS,
1651       0, this);
1652     }
1653 #endif
1654 }
1655
1656 void cmMakefile::RemoveCacheDefinition(const char* name)
1657 {
1658   this->GetCacheManager()->RemoveCacheEntry(name);
1659 }
1660
1661 void cmMakefile::SetProjectName(const char* p)
1662 {
1663   this->ProjectName = p;
1664 }
1665
1666
1667 void cmMakefile::AddGlobalLinkInformation(const char* name, cmTarget& target)
1668 {
1669   // for these targets do not add anything
1670   switch(target.GetType())
1671     {
1672     case cmTarget::UTILITY:
1673     case cmTarget::GLOBAL_TARGET:
1674       return;
1675     default:;
1676     }
1677   std::vector<std::string>::iterator j;
1678   for(j = this->LinkDirectories.begin();
1679       j != this->LinkDirectories.end(); ++j)
1680     {
1681     target.AddLinkDirectory(j->c_str());
1682     }
1683   target.MergeLinkLibraries( *this, name, this->LinkLibraries );
1684 }
1685
1686
1687 void cmMakefile::AddLibrary(const char* lname, cmTarget::TargetType type,
1688                             const std::vector<std::string> &srcs,
1689                             bool excludeFromAll)
1690 {
1691   // wrong type ? default to STATIC
1692   if (    (type != cmTarget::STATIC_LIBRARY)
1693        && (type != cmTarget::SHARED_LIBRARY)
1694        && (type != cmTarget::MODULE_LIBRARY))
1695     {
1696     type = cmTarget::STATIC_LIBRARY;
1697     }
1698
1699   cmTarget* target = this->AddNewTarget(type, lname);
1700   // Clear its dependencies. Otherwise, dependencies might persist
1701   // over changes in CMakeLists.txt, making the information stale and
1702   // hence useless.
1703   target->ClearDependencyInformation( *this, lname );
1704   if(excludeFromAll)
1705     {
1706     target->SetProperty("EXCLUDE_FROM_ALL", "TRUE");
1707     }
1708   target->AddSources(srcs);
1709   this->AddGlobalLinkInformation(lname, *target);
1710 }
1711
1712 cmTarget* cmMakefile::AddExecutable(const char *exeName,
1713                                     const std::vector<std::string> &srcs,
1714                                     bool excludeFromAll)
1715 {
1716   cmTarget* target = this->AddNewTarget(cmTarget::EXECUTABLE, exeName);
1717   if(excludeFromAll)
1718     {
1719     target->SetProperty("EXCLUDE_FROM_ALL", "TRUE");
1720     }
1721   target->AddSources(srcs);
1722   this->AddGlobalLinkInformation(exeName, *target);
1723   return target;
1724 }
1725
1726 //----------------------------------------------------------------------------
1727 cmTarget*
1728 cmMakefile::AddNewTarget(cmTarget::TargetType type, const char* name)
1729 {
1730   cmTargets::iterator it =
1731     this->Targets.insert(cmTargets::value_type(name, cmTarget())).first;
1732   cmTarget& target = it->second;
1733   target.SetType(type, name);
1734   target.SetMakefile(this);
1735   this->LocalGenerator->GetGlobalGenerator()->AddTarget(*it);
1736   return &it->second;
1737 }
1738
1739 cmSourceFile *cmMakefile::GetSourceFileWithOutput(const char *cname)
1740 {
1741   std::string name = cname;
1742   std::string out;
1743
1744   // look through all the source files that have custom commands
1745   // and see if the custom command has the passed source file as an output
1746   // keep in mind the possible .rule extension that may be tacked on
1747   for(std::vector<cmSourceFile*>::const_iterator i =
1748         this->SourceFiles.begin(); i != this->SourceFiles.end(); ++i)
1749     {
1750     // does this source file have a custom command?
1751     if ((*i)->GetCustomCommand())
1752       {
1753       // is the output of the custom command match the source files name
1754       const std::vector<std::string>& outputs =
1755         (*i)->GetCustomCommand()->GetOutputs();
1756       for(std::vector<std::string>::const_iterator o = outputs.begin();
1757           o != outputs.end(); ++o)
1758         {
1759         out = *o;
1760         std::string::size_type pos = out.rfind(name);
1761         // If the output matches exactly
1762         if (pos != out.npos &&
1763             pos == out.size() - name.size() &&
1764             (pos ==0 || out[pos-1] == '/'))
1765           {
1766           return *i;
1767           }
1768         }
1769       }
1770     }
1771
1772   // otherwise return NULL
1773   return 0;
1774 }
1775
1776 #if defined(CMAKE_BUILD_WITH_CMAKE)
1777 cmSourceGroup* cmMakefile::GetSourceGroup(const std::vector<std::string>&name)
1778 {
1779   cmSourceGroup* sg = 0;
1780
1781   // first look for source group starting with the same as the one we wants
1782   for (std::vector<cmSourceGroup>::iterator sgIt = this->SourceGroups.begin();
1783        sgIt != this->SourceGroups.end(); ++sgIt)
1784
1785     {
1786     std::string sgName = sgIt->GetName();
1787     if(sgName == name[0])
1788       {
1789       sg = &(*sgIt);
1790       break;
1791       }
1792     }
1793
1794   if(sg != 0)
1795     {
1796     // iterate through its children to find match source group
1797     for(unsigned int i=1; i<name.size(); ++i)
1798       {
1799       sg = sg->lookupChild(name[i].c_str());
1800       if(sg == 0)
1801         {
1802         break;
1803         }
1804       }
1805     }
1806   return sg;
1807 }
1808
1809  void cmMakefile::AddSourceGroup(const char* name,
1810                                  const char* regex)
1811 {
1812   if (name)
1813     {
1814     std::vector<std::string> nameVector;
1815     nameVector.push_back(name);
1816     AddSourceGroup(nameVector, regex);
1817     }
1818 }
1819
1820 void cmMakefile::AddSourceGroup(const std::vector<std::string>& name,
1821                                 const char* regex)
1822 {
1823   cmSourceGroup* sg = 0;
1824   std::vector<std::string> currentName;
1825   int i = 0;
1826   const int lastElement = static_cast<int>(name.size()-1);
1827   for(i=lastElement; i>=0; --i)
1828     {
1829     currentName.assign(name.begin(), name.begin()+i+1);
1830     sg = this->GetSourceGroup(currentName);
1831     if(sg != 0)
1832       {
1833       break;
1834       }
1835     }
1836
1837   // i now contains the index of the last found component
1838   if(i==lastElement)
1839     {
1840     // group already exists, replace its regular expression
1841     if ( regex )
1842       {
1843       // We only want to set the regular expression.  If there are already
1844       // source files in the group, we don't want to remove them.
1845       sg->SetGroupRegex(regex);
1846       }
1847     return;
1848     }
1849   else if(i==-1)
1850     {
1851     // group does not exists nor belong to any existing group
1852     // add its first component
1853     this->SourceGroups.push_back(cmSourceGroup(name[0].c_str(), regex));
1854     sg = this->GetSourceGroup(currentName);
1855     i = 0; // last component found
1856     }
1857
1858   // build the whole source group path
1859   for(++i; i<=lastElement; ++i)
1860     {
1861     sg->AddChild(cmSourceGroup(name[i].c_str(), 0));
1862     sg = sg->lookupChild(name[i].c_str());
1863     }
1864
1865   sg->SetGroupRegex(regex);
1866 }
1867
1868 #endif
1869
1870 void cmMakefile::AddExtraDirectory(const char* dir)
1871 {
1872   this->AuxSourceDirectories.push_back(dir);
1873 }
1874
1875
1876 // expance CMAKE_BINARY_DIR and CMAKE_SOURCE_DIR in the
1877 // include and library directories.
1878
1879 void cmMakefile::ExpandVariables()
1880 {
1881   // Now expand variables in the include and link strings
1882   for(std::vector<std::string>::iterator d = this->IncludeDirectories.begin();
1883       d != this->IncludeDirectories.end(); ++d)
1884     {
1885     this->ExpandVariablesInString(*d, true, true);
1886     }
1887   for(std::vector<std::string>::iterator d = this->LinkDirectories.begin();
1888       d != this->LinkDirectories.end(); ++d)
1889     {
1890     this->ExpandVariablesInString(*d, true, true);
1891     }
1892   for(cmTarget::LinkLibraryVectorType::iterator l =
1893         this->LinkLibraries.begin();
1894       l != this->LinkLibraries.end(); ++l)
1895     {
1896     this->ExpandVariablesInString(l->first, true, true);
1897     }
1898 }
1899
1900 bool cmMakefile::IsOn(const char* name) const
1901 {
1902   const char* value = this->GetDefinition(name);
1903   return cmSystemTools::IsOn(value);
1904 }
1905
1906 bool cmMakefile::IsSet(const char* name) const
1907 {
1908   const char* value = this->GetDefinition(name);
1909   if ( !value )
1910     {
1911     return false;
1912     }
1913
1914   if ( ! *value )
1915     {
1916     return false;
1917     }
1918
1919   if ( cmSystemTools::IsNOTFOUND(value) )
1920     {
1921     return false;
1922     }
1923
1924   return true;
1925 }
1926
1927 bool cmMakefile::CanIWriteThisFile(const char* fileName)
1928 {
1929   if ( !this->IsOn("CMAKE_DISABLE_SOURCE_CHANGES") )
1930     {
1931     return true;
1932     }
1933   // If we are doing an in-source build, than the test will always fail
1934   if ( cmSystemTools::SameFile(this->GetHomeDirectory(),
1935                                this->GetHomeOutputDirectory()) )
1936     {
1937     if ( this->IsOn("CMAKE_DISABLE_IN_SOURCE_BUILD") )
1938       {
1939       return false;
1940       }
1941     return true;
1942     }
1943
1944   // Check if this is subdirectory of the source tree but not a
1945   // subdirectory of a build tree
1946   if ( cmSystemTools::IsSubDirectory(fileName,
1947       this->GetHomeDirectory()) &&
1948     !cmSystemTools::IsSubDirectory(fileName,
1949       this->GetHomeOutputDirectory()) )
1950     {
1951     return false;
1952     }
1953   return true;
1954 }
1955
1956 const char* cmMakefile::GetRequiredDefinition(const char* name) const
1957 {
1958   const char* ret = this->GetDefinition(name);
1959   if(!ret)
1960     {
1961     cmSystemTools::Error("Error required internal CMake variable not "
1962                          "set, cmake may be not be built correctly.\n",
1963                          "Missing variable is:\n",
1964                          name);
1965     return "";
1966     }
1967   return ret;
1968 }
1969
1970 bool cmMakefile::IsDefinitionSet(const char* name) const
1971 {
1972   const char* def = 0;
1973   DefinitionMap::const_iterator pos =
1974     this->DefinitionStack.back().find(name);
1975   if(pos != this->DefinitionStack.back().end())
1976     {
1977     def = (*pos).second.c_str();
1978     }
1979   else
1980     {
1981     def = this->GetCacheManager()->GetCacheValue(name);
1982     }
1983 #ifdef CMAKE_BUILD_WITH_CMAKE
1984   if(cmVariableWatch* vv = this->GetVariableWatch())
1985     {
1986     if(!def)
1987       {
1988       vv->VariableAccessed
1989         (name, cmVariableWatch::UNKNOWN_VARIABLE_DEFINED_ACCESS,
1990          def, this);
1991       }
1992     }
1993 #endif
1994   return def?true:false;
1995 }
1996
1997 const char* cmMakefile::GetDefinition(const char* name) const
1998 {
1999 #ifdef CMAKE_STRICT
2000   if (this->GetCMakeInstance())
2001     {
2002     this->GetCMakeInstance()->
2003       RecordPropertyAccess(name,cmProperty::VARIABLE);
2004     }
2005 #endif
2006   const char* def = 0;
2007   DefinitionMap::const_iterator pos =
2008     this->DefinitionStack.back().find(name);
2009   if(pos != this->DefinitionStack.back().end())
2010     {
2011     def = (*pos).second.c_str();
2012     }
2013   else
2014     {
2015     def = this->GetCacheManager()->GetCacheValue(name);
2016     }
2017 #ifdef CMAKE_BUILD_WITH_CMAKE
2018   cmVariableWatch* vv = this->GetVariableWatch();
2019   if ( vv )
2020     {
2021     if ( def )
2022       {
2023       vv->VariableAccessed(name, cmVariableWatch::VARIABLE_READ_ACCESS,
2024         def, this);
2025       }
2026     else
2027       {
2028       // are unknown access allowed
2029       DefinitionMap::const_iterator pos2 =
2030         this->DefinitionStack.back()
2031         .find("CMAKE_ALLOW_UNKNOWN_VARIABLE_READ_ACCESS");
2032       if (pos2 != this->DefinitionStack.back().end() &&
2033           cmSystemTools::IsOn((*pos2).second.c_str()))
2034         {
2035         vv->VariableAccessed(name,
2036           cmVariableWatch::ALLOWED_UNKNOWN_VARIABLE_READ_ACCESS, def, this);
2037         }
2038       else
2039         {
2040         vv->VariableAccessed(name,
2041           cmVariableWatch::UNKNOWN_VARIABLE_READ_ACCESS, def, this);
2042         }
2043       }
2044     }
2045 #endif
2046   return def;
2047 }
2048
2049 const char* cmMakefile::GetSafeDefinition(const char* def) const
2050 {
2051   const char* ret = this->GetDefinition(def);
2052   if(!ret)
2053     {
2054     return "";
2055     }
2056   return ret;
2057 }
2058
2059 std::vector<std::string> cmMakefile
2060 ::GetDefinitions(int cacheonly /* = 0 */) const
2061 {
2062   std::map<cmStdString, int> definitions;
2063   if ( !cacheonly )
2064     {
2065     DefinitionMap::const_iterator it;
2066     for ( it = this->DefinitionStack.back().begin();
2067           it != this->DefinitionStack.back().end(); it ++ )
2068       {
2069       definitions[it->first] = 1;
2070       }
2071     }
2072   cmCacheManager::CacheIterator cit =
2073     this->GetCacheManager()->GetCacheIterator();
2074   for ( cit.Begin(); !cit.IsAtEnd(); cit.Next() )
2075     {
2076     definitions[cit.GetName()] = 1;
2077     }
2078
2079   std::vector<std::string> res;
2080
2081   std::map<cmStdString, int>::iterator fit;
2082   for ( fit = definitions.begin(); fit != definitions.end(); fit ++ )
2083     {
2084     res.push_back(fit->first);
2085     }
2086   return res;
2087 }
2088
2089
2090 const char *cmMakefile::ExpandVariablesInString(std::string& source)
2091 {
2092   return this->ExpandVariablesInString(source, false, false);
2093 }
2094
2095 const char *cmMakefile::ExpandVariablesInString(std::string& source,
2096                                                 bool escapeQuotes,
2097                                                 bool noEscapes,
2098                                                 bool atOnly,
2099                                                 const char* filename,
2100                                                 long line,
2101                                                 bool removeEmpty,
2102                                                 bool replaceAt)
2103 {
2104   if ( source.empty() || source.find_first_of("$@\\") == source.npos)
2105     {
2106     return source.c_str();
2107     }
2108
2109   // Special-case the @ONLY mode.
2110   if(atOnly)
2111     {
2112     if(!noEscapes || !removeEmpty || !replaceAt)
2113       {
2114       // This case should never be called.  At-only is for
2115       // configure-file/string which always does no escapes.
2116       this->IssueMessage(cmake::INTERNAL_ERROR,
2117                          "ExpandVariablesInString @ONLY called "
2118                          "on something with escapes.");
2119       }
2120
2121     // Store an original copy of the input.
2122     std::string input = source;
2123
2124     // Start with empty output.
2125     source = "";
2126
2127     // Look for one @VAR@ at a time.
2128     const char* in = input.c_str();
2129     while(this->cmAtVarRegex.find(in))
2130       {
2131       // Get the range of the string to replace.
2132       const char* first = in + this->cmAtVarRegex.start();
2133       const char* last =  in + this->cmAtVarRegex.end();
2134
2135       // Store the unchanged part of the string now.
2136       source.append(in, first-in);
2137
2138       // Lookup the definition of VAR.
2139       std::string var(first+1, last-first-2);
2140       if(const char* val = this->GetDefinition(var.c_str()))
2141         {
2142         // Store the value in the output escaping as requested.
2143         if(escapeQuotes)
2144           {
2145           source.append(cmSystemTools::EscapeQuotes(val));
2146           }
2147         else
2148           {
2149           source.append(val);
2150           }
2151         }
2152
2153       // Continue looking for @VAR@ further along the string.
2154       in = last;
2155       }
2156
2157     // Append the rest of the unchanged part of the string.
2158     source.append(in);
2159
2160     return source.c_str();
2161     }
2162
2163   // This method replaces ${VAR} and @VAR@ where VAR is looked up
2164   // with GetDefinition(), if not found in the map, nothing is expanded.
2165   // It also supports the $ENV{VAR} syntax where VAR is looked up in
2166   // the current environment variables.
2167
2168   cmCommandArgumentParserHelper parser;
2169   parser.SetMakefile(this);
2170   parser.SetLineFile(line, filename);
2171   parser.SetEscapeQuotes(escapeQuotes);
2172   parser.SetNoEscapeMode(noEscapes);
2173   parser.SetReplaceAtSyntax(replaceAt);
2174   parser.SetRemoveEmpty(removeEmpty);
2175   int res = parser.ParseString(source.c_str(), 0);
2176   const char* emsg = parser.GetError();
2177   if ( res && !emsg[0] )
2178     {
2179     source = parser.GetResult();
2180     }
2181   else
2182     {
2183     // Construct the main error message.
2184     cmOStringStream error;
2185     error << "Syntax error in cmake code ";
2186     if(filename && line > 0)
2187       {
2188       // This filename and line number may be more specific than the
2189       // command context because one command invocation can have
2190       // arguments on multiple lines.
2191       error << "at\n"
2192             << "  " << filename << ":" << line << "\n";
2193       }
2194     error << "when parsing string\n"
2195           << "  " << source.c_str() << "\n";
2196     error << emsg;
2197
2198     // If the parser failed ("res" is false) then this is a real
2199     // argument parsing error, so the policy applies.  Otherwise the
2200     // parser reported an error message without failing because the
2201     // helper implementation is unhappy, which has always reported an
2202     // error.
2203     cmake::MessageType mtype = cmake::FATAL_ERROR;
2204     if(!res)
2205       {
2206       // This is a real argument parsing error.  Use policy CMP0010 to
2207       // decide whether it is an error.
2208       switch(this->GetPolicyStatus(cmPolicies::CMP0010))
2209         {
2210         case cmPolicies::WARN:
2211           error << "\n"
2212                 << (this->GetPolicies()
2213                     ->GetPolicyWarning(cmPolicies::CMP0010));
2214         case cmPolicies::OLD:
2215           // OLD behavior is to just warn and continue.
2216           mtype = cmake::AUTHOR_WARNING;
2217           break;
2218         case cmPolicies::REQUIRED_IF_USED:
2219         case cmPolicies::REQUIRED_ALWAYS:
2220           error << "\n"
2221                 << (this->GetPolicies()
2222                     ->GetRequiredPolicyError(cmPolicies::CMP0010));
2223         case cmPolicies::NEW:
2224           // NEW behavior is to report the error.
2225           cmSystemTools::SetFatalErrorOccured();
2226           break;
2227         }
2228       }
2229     this->IssueMessage(mtype, error.str());
2230     }
2231   return source.c_str();
2232 }
2233
2234 void cmMakefile::RemoveVariablesInString(std::string& source,
2235                                          bool atOnly) const
2236 {
2237   if(!atOnly)
2238     {
2239     cmsys::RegularExpression var("(\\${[A-Za-z_0-9]*})");
2240     while (var.find(source))
2241       {
2242       source.erase(var.start(),var.end() - var.start());
2243       }
2244     }
2245
2246   if(!atOnly)
2247     {
2248     cmsys::RegularExpression varb("(\\$ENV{[A-Za-z_0-9]*})");
2249     while (varb.find(source))
2250       {
2251       source.erase(varb.start(),varb.end() - varb.start());
2252       }
2253     }
2254   cmsys::RegularExpression var2("(@[A-Za-z_0-9]*@)");
2255   while (var2.find(source))
2256     {
2257     source.erase(var2.start(),var2.end() - var2.start());
2258     }
2259 }
2260
2261 /**
2262  * Add the default definitions to the makefile.  These values must not
2263  * be dependent on anything that isn't known when this cmMakefile instance
2264  * is constructed.
2265  */
2266 void cmMakefile::AddDefaultDefinitions()
2267 {
2268 /* Up to CMake 2.4 here only WIN32, UNIX and APPLE were set.
2269   With CMake must separate between target and host platform. In most cases
2270   the tests for WIN32, UNIX and APPLE will be for the target system, so an
2271   additional set of variables for the host system is required ->
2272   CMAKE_HOST_WIN32, CMAKE_HOST_UNIX, CMAKE_HOST_APPLE.
2273   WIN32, UNIX and APPLE are now set in the platform files in
2274   Modules/Platforms/.
2275   To keep cmake scripts (-P) and custom language and compiler modules
2276   working, these variables are still also set here in this place, but they
2277   will be reset in CMakeSystemSpecificInformation.cmake before the platform
2278   files are executed. */
2279 #if defined(_WIN32) || defined(__CYGWIN__)
2280   this->AddDefinition("WIN32", "1");
2281   this->AddDefinition("CMAKE_HOST_WIN32", "1");
2282 #else
2283   this->AddDefinition("UNIX", "1");
2284   this->AddDefinition("CMAKE_HOST_UNIX", "1");
2285 #endif
2286   // Cygwin is more like unix so enable the unix commands
2287 #if defined(__CYGWIN__)
2288   this->AddDefinition("UNIX", "1");
2289   this->AddDefinition("CMAKE_HOST_UNIX", "1");
2290 #endif
2291 #if defined(__APPLE__)
2292   this->AddDefinition("APPLE", "1");
2293   this->AddDefinition("CMAKE_HOST_APPLE", "1");
2294 #endif
2295
2296   char temp[1024];
2297   sprintf(temp, "%d", cmVersion::GetMinorVersion());
2298   this->AddDefinition("CMAKE_MINOR_VERSION", temp);
2299   sprintf(temp, "%d", cmVersion::GetMajorVersion());
2300   this->AddDefinition("CMAKE_MAJOR_VERSION", temp);
2301   sprintf(temp, "%d", cmVersion::GetPatchVersion());
2302   this->AddDefinition("CMAKE_PATCH_VERSION", temp);
2303
2304   this->AddDefinition("CMAKE_FILES_DIRECTORY",
2305                       cmake::GetCMakeFilesDirectory());
2306 }
2307
2308 #if defined(CMAKE_BUILD_WITH_CMAKE)
2309 /**
2310  * Find a source group whose regular expression matches the filename
2311  * part of the given source name.  Search backward through the list of
2312  * source groups, and take the first matching group found.  This way
2313  * non-inherited SOURCE_GROUP commands will have precedence over
2314  * inherited ones.
2315  */
2316 cmSourceGroup&
2317 cmMakefile::FindSourceGroup(const char* source,
2318                             std::vector<cmSourceGroup> &groups)
2319 {
2320   // First search for a group that lists the file explicitly.
2321   for(std::vector<cmSourceGroup>::reverse_iterator sg = groups.rbegin();
2322       sg != groups.rend(); ++sg)
2323     {
2324     cmSourceGroup *result = sg->MatchChildrenFiles(source);
2325     if(result)
2326       {
2327       return *result;
2328       }
2329     }
2330
2331   // Now search for a group whose regex matches the file.
2332   for(std::vector<cmSourceGroup>::reverse_iterator sg = groups.rbegin();
2333       sg != groups.rend(); ++sg)
2334     {
2335     cmSourceGroup *result = sg->MatchChildrenRegex(source);
2336     if(result)
2337       {
2338       return *result;
2339       }
2340     }
2341
2342
2343   // Shouldn't get here, but just in case, return the default group.
2344   return groups.front();
2345 }
2346 #endif
2347
2348 bool cmMakefile::IsFunctionBlocked(const cmListFileFunction& lff,
2349                                    cmExecutionStatus &status)
2350 {
2351   // if there are no blockers get out of here
2352   if (this->FunctionBlockers.begin() == this->FunctionBlockers.end())
2353     {
2354     return false;
2355     }
2356
2357   // loop over all function blockers to see if any block this command
2358   // evaluate in reverse, this is critical for balanced IF statements etc
2359   std::list<cmFunctionBlocker *>::reverse_iterator pos;
2360   for (pos = this->FunctionBlockers.rbegin();
2361        pos != this->FunctionBlockers.rend(); ++pos)
2362     {
2363     if((*pos)->IsFunctionBlocked(lff, *this, status))
2364       {
2365       return true;
2366       }
2367     }
2368
2369   return false;
2370 }
2371
2372 bool cmMakefile::ExpandArguments(
2373   std::vector<cmListFileArgument> const& inArgs,
2374   std::vector<std::string>& outArgs)
2375 {
2376   std::vector<cmListFileArgument>::const_iterator i;
2377   std::string value;
2378   outArgs.reserve(inArgs.size());
2379   for(i = inArgs.begin(); i != inArgs.end(); ++i)
2380     {
2381     // Expand the variables in the argument.
2382     value = i->Value;
2383     this->ExpandVariablesInString(value, false, false, false,
2384                                   i->FilePath, i->Line,
2385                                   false, true);
2386
2387     // If the argument is quoted, it should be one argument.
2388     // Otherwise, it may be a list of arguments.
2389     if(i->Quoted)
2390       {
2391       outArgs.push_back(value);
2392       }
2393     else
2394       {
2395       cmSystemTools::ExpandListArgument(value, outArgs);
2396       }
2397     }
2398   return !cmSystemTools::GetFatalErrorOccured();
2399 }
2400
2401 void cmMakefile::RemoveFunctionBlocker(const cmListFileFunction& lff)
2402 {
2403   // loop over all function blockers to see if any block this command
2404   std::list<cmFunctionBlocker *>::reverse_iterator pos;
2405   for (pos = this->FunctionBlockers.rbegin();
2406        pos != this->FunctionBlockers.rend(); ++pos)
2407     {
2408     if ((*pos)->ShouldRemove(lff, *this))
2409       {
2410       cmFunctionBlocker* b = *pos;
2411       this->FunctionBlockers.remove(b);
2412       delete b;
2413       break;
2414       }
2415     }
2416
2417   return;
2418 }
2419
2420 void cmMakefile::SetHomeDirectory(const char* dir)
2421 {
2422   this->cmHomeDirectory = dir;
2423   cmSystemTools::ConvertToUnixSlashes(this->cmHomeDirectory);
2424   this->AddDefinition("CMAKE_SOURCE_DIR", this->GetHomeDirectory());
2425   if ( !this->GetDefinition("CMAKE_CURRENT_SOURCE_DIR") )
2426     {
2427     this->AddDefinition("CMAKE_CURRENT_SOURCE_DIR", this->GetHomeDirectory());
2428     }
2429 }
2430
2431 void cmMakefile::SetHomeOutputDirectory(const char* lib)
2432 {
2433   this->HomeOutputDirectory = lib;
2434   cmSystemTools::ConvertToUnixSlashes(this->HomeOutputDirectory);
2435   this->AddDefinition("CMAKE_BINARY_DIR", this->GetHomeOutputDirectory());
2436   if ( !this->GetDefinition("CMAKE_CURRENT_BINARY_DIR") )
2437     {
2438     this->AddDefinition("CMAKE_CURRENT_BINARY_DIR",
2439                         this->GetHomeOutputDirectory());
2440     }
2441 }
2442
2443
2444 /**
2445  * Register the given cmData instance with its own name.
2446  */
2447 void cmMakefile::RegisterData(cmData* data)
2448 {
2449   std::string name = data->GetName();
2450   DataMapType::const_iterator d = this->DataMap.find(name);
2451   if((d != this->DataMap.end()) && (d->second != 0) && (d->second != data))
2452     {
2453     delete d->second;
2454     }
2455   this->DataMap[name] = data;
2456 }
2457
2458
2459 /**
2460  * Register the given cmData instance with the given name.  This can be used
2461  * to register a NULL pointer.
2462  */
2463 void cmMakefile::RegisterData(const char* name, cmData* data)
2464 {
2465   DataMapType::const_iterator d = this->DataMap.find(name);
2466   if((d != this->DataMap.end()) && (d->second != 0) && (d->second != data))
2467     {
2468     delete d->second;
2469     }
2470   this->DataMap[name] = data;
2471 }
2472
2473
2474 /**
2475  * Lookup a cmData instance previously registered with the given name.  If
2476  * the instance cannot be found, return NULL.
2477  */
2478 cmData* cmMakefile::LookupData(const char* name) const
2479 {
2480   DataMapType::const_iterator d = this->DataMap.find(name);
2481   if(d != this->DataMap.end())
2482     {
2483     return d->second;
2484     }
2485   else
2486     {
2487     return 0;
2488     }
2489 }
2490
2491 //----------------------------------------------------------------------------
2492 cmSourceFile* cmMakefile::GetSource(const char* sourceName)
2493 {
2494   cmSourceFileLocation sfl(this, sourceName);
2495   for(std::vector<cmSourceFile*>::const_iterator
2496         sfi = this->SourceFiles.begin();
2497       sfi != this->SourceFiles.end(); ++sfi)
2498     {
2499     cmSourceFile* sf = *sfi;
2500     if(sf->Matches(sfl))
2501       {
2502       return sf;
2503       }
2504     }
2505   return 0;
2506 }
2507
2508 //----------------------------------------------------------------------------
2509 cmSourceFile* cmMakefile::GetOrCreateSource(const char* sourceName,
2510                                             bool generated)
2511 {
2512   if(cmSourceFile* esf = this->GetSource(sourceName))
2513     {
2514     return esf;
2515     }
2516   else
2517     {
2518     cmSourceFile* sf = new cmSourceFile(this, sourceName);
2519     if(generated)
2520       {
2521       sf->SetProperty("GENERATED", "1");
2522       }
2523     this->SourceFiles.push_back(sf);
2524     return sf;
2525     }
2526 }
2527
2528 void cmMakefile::EnableLanguage(std::vector<std::string> const &  lang,
2529                                bool optional)
2530 {
2531   this->AddDefinition("CMAKE_CFG_INTDIR",
2532   this->LocalGenerator->GetGlobalGenerator()->GetCMakeCFGInitDirectory());
2533   this->LocalGenerator->GetGlobalGenerator()->EnableLanguage(lang, this,
2534                                                              optional);
2535 }
2536
2537 void cmMakefile::ExpandSourceListArguments(
2538   std::vector<std::string> const& arguments,
2539   std::vector<std::string>& newargs, unsigned int /* start */)
2540 {
2541   // now expand the args
2542   unsigned int i;
2543   for(i = 0; i < arguments.size(); ++i)
2544     {
2545     // List expansion will have been done already.
2546     newargs.push_back(arguments[i]);
2547     }
2548 }
2549
2550 int cmMakefile::TryCompile(const char *srcdir, const char *bindir,
2551                            const char *projectName, const char *targetName,
2552                            const std::vector<std::string> *cmakeArgs,
2553                            std::string *output)
2554 {
2555   // does the binary directory exist ? If not create it...
2556   if (!cmSystemTools::FileIsDirectory(bindir))
2557     {
2558     cmSystemTools::MakeDirectory(bindir);
2559     }
2560
2561   // change to the tests directory and run cmake
2562   // use the cmake object instead of calling cmake
2563   std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
2564   cmSystemTools::ChangeDirectory(bindir);
2565
2566   // make sure the same generator is used
2567   // use this program as the cmake to be run, it should not
2568   // be run that way but the cmake object requires a vailid path
2569   std::string cmakeCommand = this->GetDefinition("CMAKE_COMMAND");
2570   cmake cm;
2571   cm.SetIsInTryCompile(true);
2572   cmGlobalGenerator *gg = cm.CreateGlobalGenerator
2573     (this->LocalGenerator->GetGlobalGenerator()->GetName());
2574   if (!gg)
2575     {
2576     cmSystemTools::Error(
2577       "Internal CMake error, TryCompile bad GlobalGenerator");
2578     // return to the original directory
2579     cmSystemTools::ChangeDirectory(cwd.c_str());
2580     return 1;
2581     }
2582   cm.SetGlobalGenerator(gg);
2583
2584   // do a configure
2585   cm.SetHomeDirectory(srcdir);
2586   cm.SetHomeOutputDirectory(bindir);
2587   cm.SetStartDirectory(srcdir);
2588   cm.SetStartOutputDirectory(bindir);
2589   cm.SetCMakeCommand(cmakeCommand.c_str());
2590   cm.LoadCache();
2591   // if cmake args were provided then pass them in
2592   if (cmakeArgs)
2593     {
2594     cm.SetCacheArgs(*cmakeArgs);
2595     }
2596   // to save time we pass the EnableLanguage info directly
2597   gg->EnableLanguagesFromGenerator
2598     (this->LocalGenerator->GetGlobalGenerator());
2599   if(this->IsOn("CMAKE_SUPPRESS_DEVELOPER_WARNINGS"))
2600     {
2601     cm.AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS",
2602                      "TRUE", "", cmCacheManager::INTERNAL);
2603     }
2604   else
2605     {
2606     cm.AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS",
2607                      "FALSE", "", cmCacheManager::INTERNAL);
2608     }
2609   if (cm.Configure() != 0)
2610     {
2611     cmSystemTools::Error(
2612       "Internal CMake error, TryCompile configure of cmake failed");
2613     // return to the original directory
2614     cmSystemTools::ChangeDirectory(cwd.c_str());
2615     return 1;
2616     }
2617
2618   if (cm.Generate() != 0)
2619     {
2620     cmSystemTools::Error(
2621       "Internal CMake error, TryCompile generation of cmake failed");
2622     // return to the original directory
2623     cmSystemTools::ChangeDirectory(cwd.c_str());
2624     return 1;
2625     }
2626
2627   // finally call the generator to actually build the resulting project
2628   int ret =
2629     this->LocalGenerator->GetGlobalGenerator()->TryCompile(srcdir,bindir,
2630                                                            projectName,
2631                                                            targetName,
2632                                                            output,
2633                                                            this);
2634
2635   cmSystemTools::ChangeDirectory(cwd.c_str());
2636   return ret;
2637 }
2638
2639 cmake *cmMakefile::GetCMakeInstance() const
2640 {
2641   if ( this->LocalGenerator && this->LocalGenerator->GetGlobalGenerator() )
2642     {
2643     return this->LocalGenerator->GetGlobalGenerator()->GetCMakeInstance();
2644     }
2645   return 0;
2646 }
2647
2648 #ifdef CMAKE_BUILD_WITH_CMAKE
2649 cmVariableWatch *cmMakefile::GetVariableWatch() const
2650 {
2651   if ( this->GetCMakeInstance() &&
2652        this->GetCMakeInstance()->GetVariableWatch() )
2653     {
2654     return this->GetCMakeInstance()->GetVariableWatch();
2655     }
2656   return 0;
2657 }
2658 #endif
2659
2660 void cmMakefile::AddMacro(const char* name, const char* signature)
2661 {
2662   if ( !name || !signature )
2663     {
2664     return;
2665     }
2666   this->MacrosMap[name] = signature;
2667 }
2668
2669 void cmMakefile::GetListOfMacros(std::string& macros)
2670 {
2671   StringStringMap::iterator it;
2672   macros = "";
2673   int cc = 0;
2674   for ( it = this->MacrosMap.begin(); it != this->MacrosMap.end(); ++it )
2675     {
2676     if ( cc > 0 )
2677       {
2678       macros += ";";
2679       }
2680     macros += it->first;
2681     cc ++;
2682     }
2683 }
2684
2685 cmCacheManager *cmMakefile::GetCacheManager() const
2686 {
2687   return this->GetCMakeInstance()->GetCacheManager();
2688 }
2689
2690 void cmMakefile::DisplayStatus(const char* message, float s)
2691 {
2692   this->GetLocalGenerator()->GetGlobalGenerator()
2693     ->GetCMakeInstance()->UpdateProgress(message, s);
2694 }
2695
2696 std::string cmMakefile::GetModulesFile(const char* filename)
2697 {
2698   std::vector<std::string> modulePath;
2699   const char* def = this->GetDefinition("CMAKE_MODULE_PATH");
2700   if(def)
2701     {
2702     cmSystemTools::ExpandListArgument(def, modulePath);
2703     }
2704
2705   // Also search in the standard modules location.
2706   def = this->GetDefinition("CMAKE_ROOT");
2707   if(def)
2708     {
2709     std::string rootModules = def;
2710     rootModules += "/Modules";
2711     modulePath.push_back(rootModules);
2712     }
2713   //std::string  Look through the possible module directories.
2714   for(std::vector<std::string>::iterator i = modulePath.begin();
2715       i != modulePath.end(); ++i)
2716     {
2717     std::string itempl = *i;
2718     cmSystemTools::ConvertToUnixSlashes(itempl);
2719     itempl += "/";
2720     itempl += filename;
2721     if(cmSystemTools::FileExists(itempl.c_str()))
2722       {
2723       return itempl;
2724       }
2725     }
2726   return "";
2727 }
2728
2729 void cmMakefile::ConfigureString(const std::string& input,
2730                                  std::string& output, bool atOnly,
2731                                  bool escapeQuotes)
2732 {
2733   // Split input to handle one line at a time.
2734   std::string::const_iterator lineStart = input.begin();
2735   while(lineStart != input.end())
2736     {
2737     // Find the end of this line.
2738     std::string::const_iterator lineEnd = lineStart;
2739     while(lineEnd != input.end() && *lineEnd != '\n')
2740       {
2741       ++lineEnd;
2742       }
2743
2744     // Copy the line.
2745     std::string line(lineStart, lineEnd);
2746
2747     // Skip the newline character.
2748     bool haveNewline = (lineEnd != input.end());
2749     if(haveNewline)
2750       {
2751       ++lineEnd;
2752       }
2753
2754     // Replace #cmakedefine instances.
2755     if(this->cmDefineRegex.find(line))
2756       {
2757       const char* def =
2758         this->GetDefinition(this->cmDefineRegex.match(1).c_str());
2759       if(!cmSystemTools::IsOff(def))
2760         {
2761         cmSystemTools::ReplaceString(line, "#cmakedefine", "#define");
2762         output += line;
2763         }
2764       else
2765         {
2766         output += "/* #undef ";
2767         output += this->cmDefineRegex.match(1);
2768         output += " */";
2769         }
2770       }
2771     else if(this->cmDefine01Regex.find(line))
2772       {
2773       const char* def =
2774         this->GetDefinition(this->cmDefine01Regex.match(1).c_str());
2775       cmSystemTools::ReplaceString(line, "#cmakedefine01", "#define");
2776       output += line;
2777       if(!cmSystemTools::IsOff(def))
2778         {
2779         output += " 1";
2780         }
2781       else
2782         {
2783         output += " 0";
2784         }
2785       }
2786     else
2787       {
2788       output += line;
2789       }
2790
2791     if(haveNewline)
2792       {
2793       output += "\n";
2794       }
2795
2796     // Move to the next line.
2797     lineStart = lineEnd;
2798     }
2799
2800   // Perform variable replacements.
2801   this->ExpandVariablesInString(output, escapeQuotes, true,
2802                                 atOnly, 0, -1, true);
2803 }
2804
2805 int cmMakefile::ConfigureFile(const char* infile, const char* outfile,
2806                               bool copyonly, bool atOnly, bool escapeQuotes)
2807 {
2808   int res = 1;
2809   if ( !this->CanIWriteThisFile(outfile) )
2810     {
2811     cmSystemTools::Error("Attempt to write file: ",
2812                          outfile, " into a source directory.");
2813     return 0;
2814     }
2815   if ( !cmSystemTools::FileExists(infile) )
2816     {
2817     cmSystemTools::Error("File ", infile, " does not exist.");
2818     return 0;
2819     }
2820   std::string soutfile = outfile;
2821   std::string sinfile = infile;
2822   this->AddCMakeDependFile(infile);
2823   cmSystemTools::ConvertToUnixSlashes(soutfile);
2824   mode_t perm = 0;
2825   cmSystemTools::GetPermissions(sinfile.c_str(), perm);
2826   std::string::size_type pos = soutfile.rfind('/');
2827   if(pos != std::string::npos)
2828     {
2829     std::string path = soutfile.substr(0, pos);
2830     cmSystemTools::MakeDirectory(path.c_str());
2831     }
2832
2833   if(copyonly)
2834     {
2835     if ( !cmSystemTools::CopyFileIfDifferent(sinfile.c_str(),
2836                                              soutfile.c_str()))
2837       {
2838       return 0;
2839       }
2840     }
2841   else
2842     {
2843     std::string tempOutputFile = soutfile;
2844     tempOutputFile += ".tmp";
2845     std::ofstream fout(tempOutputFile.c_str());
2846     if(!fout)
2847       {
2848       cmSystemTools::Error(
2849         "Could not open file for write in copy operation ",
2850         tempOutputFile.c_str());
2851       cmSystemTools::ReportLastSystemError("");
2852       return 0;
2853       }
2854     std::ifstream fin(sinfile.c_str());
2855     if(!fin)
2856       {
2857       cmSystemTools::Error("Could not open file for read in copy operation ",
2858                            sinfile.c_str());
2859       return 0;
2860       }
2861
2862     // now copy input to output and expand variables in the
2863     // input file at the same time
2864     std::string inLine;
2865     std::string outLine;
2866     while( cmSystemTools::GetLineFromStream(fin, inLine) )
2867       {
2868       outLine = "";
2869       this->ConfigureString(inLine, outLine, atOnly, escapeQuotes);
2870       fout << outLine.c_str() << "\n";
2871       }
2872     // close the files before attempting to copy
2873     fin.close();
2874     fout.close();
2875     if ( !cmSystemTools::CopyFileIfDifferent(tempOutputFile.c_str(),
2876                                              soutfile.c_str()) )
2877       {
2878       res = 0;
2879       }
2880     else
2881       {
2882       cmSystemTools::SetPermissions(soutfile.c_str(), perm);
2883       }
2884     cmSystemTools::RemoveFile(tempOutputFile.c_str());
2885     }
2886   return res;
2887 }
2888
2889 void cmMakefile::SetProperty(const char* prop, const char* value)
2890 {
2891   if (!prop)
2892     {
2893     return;
2894     }
2895
2896   // handle special props
2897   std::string propname = prop;
2898   if ( propname == "INCLUDE_DIRECTORIES" )
2899     {
2900     std::vector<std::string> varArgsExpanded;
2901     cmSystemTools::ExpandListArgument(value, varArgsExpanded);
2902     this->SetIncludeDirectories(varArgsExpanded);
2903     return;
2904     }
2905
2906   if ( propname == "LINK_DIRECTORIES" )
2907     {
2908     std::vector<std::string> varArgsExpanded;
2909     cmSystemTools::ExpandListArgument(value, varArgsExpanded);
2910     this->SetLinkDirectories(varArgsExpanded);
2911     return;
2912     }
2913
2914   if ( propname == "INCLUDE_REGULAR_EXPRESSION" )
2915     {
2916     this->SetIncludeRegularExpression(value);
2917     return;
2918     }
2919
2920   if ( propname == "ADDITIONAL_MAKE_CLEAN_FILES" )
2921     {
2922     // This property is not inherrited
2923     if ( strcmp(this->GetCurrentDirectory(),
2924                 this->GetStartDirectory()) != 0 )
2925       {
2926       return;
2927       }
2928     }
2929
2930   this->Properties.SetProperty(prop,value,cmProperty::DIRECTORY);
2931 }
2932
2933 void cmMakefile::AppendProperty(const char* prop, const char* value)
2934 {
2935   if (!prop)
2936     {
2937     return;
2938     }
2939
2940   // handle special props
2941   std::string propname = prop;
2942   if ( propname == "INCLUDE_DIRECTORIES" )
2943     {
2944     std::vector<std::string> varArgsExpanded;
2945     cmSystemTools::ExpandListArgument(value, varArgsExpanded);
2946     for(std::vector<std::string>::const_iterator vi = varArgsExpanded.begin();
2947         vi != varArgsExpanded.end(); ++vi)
2948       {
2949       this->AddIncludeDirectory(vi->c_str());
2950       }
2951     return;
2952     }
2953
2954   if ( propname == "LINK_DIRECTORIES" )
2955     {
2956     std::vector<std::string> varArgsExpanded;
2957     cmSystemTools::ExpandListArgument(value, varArgsExpanded);
2958     for(std::vector<std::string>::const_iterator vi = varArgsExpanded.begin();
2959         vi != varArgsExpanded.end(); ++vi)
2960       {
2961       this->AddLinkDirectory(vi->c_str());
2962       }
2963     return;
2964     }
2965
2966   this->Properties.AppendProperty(prop,value,cmProperty::DIRECTORY);
2967 }
2968
2969 const char *cmMakefile::GetPropertyOrDefinition(const char* prop)
2970 {
2971   const char *ret = this->GetProperty(prop, cmProperty::DIRECTORY);
2972   if (!ret)
2973     {
2974     ret = this->GetDefinition(prop);
2975     }
2976   return ret;
2977 }
2978
2979 const char *cmMakefile::GetProperty(const char* prop)
2980 {
2981   return this->GetProperty(prop, cmProperty::DIRECTORY);
2982 }
2983
2984 const char *cmMakefile::GetProperty(const char* prop,
2985                                     cmProperty::ScopeType scope)
2986 {
2987   // watch for specific properties
2988   static std::string output;
2989   output = "";
2990   if (!strcmp("PARENT_DIRECTORY",prop))
2991     {
2992     if(cmLocalGenerator* plg = this->LocalGenerator->GetParent())
2993       {
2994       output = plg->GetMakefile()->GetStartDirectory();
2995       }
2996     return output.c_str();
2997     }
2998   else if (!strcmp("INCLUDE_REGULAR_EXPRESSION",prop) )
2999     {
3000     output = this->GetIncludeRegularExpression();
3001     return output.c_str();
3002     }
3003   else if (!strcmp("LISTFILE_STACK",prop))
3004     {
3005     for (std::deque<cmStdString>::iterator i = this->ListFileStack.begin();
3006          i != this->ListFileStack.end(); ++i)
3007       {
3008       if (i != this->ListFileStack.begin())
3009         {
3010         output += ";";
3011         }
3012       output += *i;
3013       }
3014     return output.c_str();
3015     }
3016   else if (!strcmp("VARIABLES",prop) || !strcmp("CACHE_VARIABLES",prop))
3017     {
3018     int cacheonly = 0;
3019     if ( !strcmp("CACHE_VARIABLES",prop) )
3020       {
3021       cacheonly = 1;
3022       }
3023     std::vector<std::string> vars = this->GetDefinitions(cacheonly);
3024     for (unsigned int cc = 0; cc < vars.size(); cc ++ )
3025       {
3026       if ( cc > 0 )
3027         {
3028         output += ";";
3029         }
3030       output += vars[cc];
3031       }
3032     return output.c_str();
3033     }
3034   else if (!strcmp("MACROS",prop))
3035     {
3036     this->GetListOfMacros(output);
3037     return output.c_str();
3038     }
3039   else if (!strcmp("DEFINITIONS",prop))
3040     {
3041     output += this->DefineFlagsOrig;
3042     return output.c_str();
3043     }
3044   else if (!strcmp("INCLUDE_DIRECTORIES",prop) )
3045     {
3046     cmOStringStream str;
3047     for (std::vector<std::string>::const_iterator
3048          it = this->GetIncludeDirectories().begin();
3049          it != this->GetIncludeDirectories().end();
3050          ++ it )
3051       {
3052       if ( it != this->GetIncludeDirectories().begin())
3053         {
3054         str << ";";
3055         }
3056       str << it->c_str();
3057       }
3058     output = str.str();
3059     return output.c_str();
3060     }
3061   else if (!strcmp("LINK_DIRECTORIES",prop))
3062     {
3063     cmOStringStream str;
3064     for (std::vector<std::string>::const_iterator
3065          it = this->GetLinkDirectories().begin();
3066          it != this->GetLinkDirectories().end();
3067          ++ it )
3068       {
3069       if ( it != this->GetLinkDirectories().begin())
3070         {
3071         str << ";";
3072         }
3073       str << it->c_str();
3074       }
3075     output = str.str();
3076     return output.c_str();
3077     }
3078
3079   bool chain = false;
3080   const char *retVal =
3081     this->Properties.GetPropertyValue(prop, scope, chain);
3082   if (chain)
3083     {
3084     if(this->LocalGenerator->GetParent())
3085       {
3086       return this->LocalGenerator->GetParent()->GetMakefile()->
3087         GetProperty(prop, scope);
3088       }
3089     return this->GetCMakeInstance()->GetProperty(prop,scope);
3090     }
3091
3092   return retVal;
3093 }
3094
3095 bool cmMakefile::GetPropertyAsBool(const char* prop)
3096 {
3097   return cmSystemTools::IsOn(this->GetProperty(prop));
3098 }
3099
3100
3101 cmTarget* cmMakefile::FindTarget(const char* name)
3102 {
3103   cmTargets& tgts = this->GetTargets();
3104
3105   cmTargets::iterator i = tgts.find ( name );
3106   if ( i != tgts.end() )
3107     {
3108     return &i->second;
3109     }
3110
3111   return 0;
3112 }
3113
3114 cmTest* cmMakefile::CreateTest(const char* testName)
3115 {
3116   if ( !testName )
3117     {
3118     return 0;
3119     }
3120   cmTest* test = this->GetTest(testName);
3121   if ( test )
3122     {
3123     return test;
3124     }
3125   test = new cmTest;
3126   test->SetName(testName);
3127   test->SetMakefile(this);
3128   this->Tests.push_back(test);
3129   return test;
3130 }
3131
3132 cmTest* cmMakefile::GetTest(const char* testName) const
3133 {
3134   if ( !testName )
3135     {
3136     return 0;
3137     }
3138   std::vector<cmTest*>::const_iterator it;
3139   for ( it = this->Tests.begin(); it != this->Tests.end(); ++ it )
3140     {
3141     if ( strcmp((*it)->GetName(), testName) == 0 )
3142       {
3143       return *it;
3144       }
3145     }
3146   return 0;
3147 }
3148
3149 const std::vector<cmTest*> *cmMakefile::GetTests() const
3150 {
3151   return &this->Tests;
3152 }
3153
3154 std::vector<cmTest*> *cmMakefile::GetTests()
3155 {
3156   return &this->Tests;
3157 }
3158
3159 std::string cmMakefile::GetListFileStack()
3160 {
3161   cmOStringStream tmp;
3162   size_t depth = this->ListFileStack.size();
3163   if (depth > 0)
3164     {
3165     std::deque<cmStdString>::iterator it = this->ListFileStack.end();
3166     do
3167       {
3168       if (depth != this->ListFileStack.size())
3169         {
3170         tmp << "\n                ";
3171         }
3172       --it;
3173       tmp << "[";
3174       tmp << depth;
3175       tmp << "]\t";
3176       tmp << *it;
3177       depth--;
3178       }
3179     while (it != this->ListFileStack.begin());
3180     }
3181   return tmp.str();
3182 }
3183
3184
3185 void cmMakefile::PushScope()
3186 {
3187   // Get the index of the next stack entry.
3188   std::vector<DefinitionMap>::size_type index = this->DefinitionStack.size();
3189
3190   // Allocate a new stack entry.
3191   this->DefinitionStack.push_back(DefinitionMap());
3192
3193   // Copy the previous top to the new top.
3194   this->DefinitionStack[index] = this->DefinitionStack[index-1];
3195 }
3196
3197 void cmMakefile::PopScope()
3198 {
3199   this->DefinitionStack.pop_back();
3200 }
3201
3202 void cmMakefile::RaiseScope(const char *var, const char *varDef)
3203 {
3204   if (!var || !strlen(var))
3205     {
3206     return;
3207     }
3208
3209   // multiple scopes in this directory?
3210   if (this->DefinitionStack.size() > 1)
3211     {
3212     if(varDef)
3213       {
3214       this->DefinitionStack[this->DefinitionStack.size()-2][var] = varDef;
3215       }
3216     else
3217       {
3218       this->DefinitionStack[this->DefinitionStack.size()-2].erase(var);
3219       }
3220     }
3221   // otherwise do the parent (if one exists)
3222   else if (this->LocalGenerator->GetParent())
3223     {
3224     cmMakefile *parent = this->LocalGenerator->GetParent()->GetMakefile();
3225     if (parent)
3226       {
3227       if(varDef)
3228         {
3229         parent->AddDefinition(var,varDef);
3230         }
3231       else
3232         {
3233         parent->RemoveDefinition(var);
3234         }
3235       }
3236     }
3237 }
3238
3239
3240 // define properties
3241 void cmMakefile::DefineProperties(cmake *cm)
3242 {
3243   cm->DefineProperty
3244     ("ADDITIONAL_MAKE_CLEAN_FILES", cmProperty::DIRECTORY,
3245      "Additional files to clean during the make clean stage.",
3246      "A list of files that will be cleaned as a part of the "
3247      "\"make clean\" stage. ");
3248
3249   cm->DefineProperty
3250     ("CLEAN_NO_CUSTOM", cmProperty::DIRECTORY,
3251      "Should the output of custom commands be left.",
3252      "If this is true then the outputs of custom commands for this "
3253      "directory will not be removed during the \"make clean\" stage. ");
3254
3255   cm->DefineProperty
3256     ("LISTFILE_STACK", cmProperty::DIRECTORY,
3257      "The current stack of listfiles being processed.",
3258      "This property is mainly useful when trying to debug errors "
3259      "in your CMake scripts. It returns a list of what list files "
3260      "are currently being processed, in order. So if one listfile "
3261      "does an INCLUDE command then that is effectively pushing "
3262      "the included listfile onto the stack.", false);
3263
3264   cm->DefineProperty
3265     ("TEST_INCLUDE_FILE", cmProperty::DIRECTORY,
3266      "A cmake file that will be included when ctest is run.",
3267      "If you specify TEST_INCLUDE_FILE, that file will be "
3268      "included and processed when ctest is run on the directory.");
3269
3270   cm->DefineProperty
3271     ("COMPILE_DEFINITIONS", cmProperty::DIRECTORY,
3272      "Preprocessor definitions for compiling a directory's sources.",
3273      "The COMPILE_DEFINITIONS property may be set to a list of preprocessor "
3274      "definitions using the syntax VAR or VAR=value.  Function-style "
3275      "definitions are not supported.  CMake will automatically escape "
3276      "the value correctly for the native build system (note that CMake "
3277      "language syntax may require escapes to specify some values).  "
3278      "This property may be set on a per-configuration basis using the name "
3279      "COMPILE_DEFINITIONS_<CONFIG> where <CONFIG> is an upper-case name "
3280      "(ex. \"COMPILE_DEFINITIONS_DEBUG\").  "
3281      "This property will be initialized in each directory by its value "
3282      "in the directory's parent.\n"
3283      "CMake will automatically drop some definitions that "
3284      "are not supported by the native build tool.  "
3285      "The VS6 IDE does not support definitions with values "
3286      "(but NMake does).\n"
3287      "Dislaimer: Most native build tools have poor support for escaping "
3288      "certain values.  CMake has work-arounds for many cases but some "
3289      "values may just not be possible to pass correctly.  If a value "
3290      "does not seem to be escaped correctly, do not attempt to "
3291      "work-around the problem by adding escape sequences to the value.  "
3292      "Your work-around may break in a future version of CMake that "
3293      "has improved escape support.  Instead consider defining the macro "
3294      "in a (configured) header file.  Then report the limitation.");
3295
3296   cm->DefineProperty
3297     ("COMPILE_DEFINITIONS_<CONFIG>", cmProperty::DIRECTORY,
3298      "Per-configuration preprocessor definitions in a directory.",
3299      "This is the configuration-specific version of COMPILE_DEFINITIONS.  "
3300      "This property will be initialized in each directory by its value "
3301      "in the directory's parent.\n");
3302
3303   cm->DefineProperty
3304     ("IMPLICIT_DEPENDS_INCLUDE_TRANSFORM", cmProperty::DIRECTORY,
3305      "Specify #include line transforms for dependencies in a directory.",
3306      "This property specifies rules to transform macro-like #include lines "
3307      "during implicit dependency scanning of C and C++ source files.  "
3308      "The list of rules must be semicolon-separated with each entry of "
3309      "the form \"A_MACRO(%)=value-with-%\" (the % must be literal).  "
3310      "During dependency scanning occurrences of A_MACRO(...) on #include "
3311      "lines will be replaced by the value given with the macro argument "
3312      "substituted for '%'.  For example, the entry\n"
3313      "  MYDIR(%)=<mydir/%>\n"
3314      "will convert lines of the form\n"
3315      "  #include MYDIR(myheader.h)\n"
3316      "to\n"
3317      "  #include <mydir/myheader.h>\n"
3318      "allowing the dependency to be followed.\n"
3319      "This property applies to sources in all targets within a directory.  "
3320      "The property value is initialized in each directory by its value "
3321      "in the directory's parent.");
3322
3323   cm->DefineProperty
3324     ("EXCLUDE_FROM_ALL", cmProperty::DIRECTORY,
3325      "Exclude the directory from the all target of its parent.",
3326      "A property on a directory that indicates if its targets are excluded "
3327      "from the default build target. If it is not, then with a Makefile "
3328      "for example typing make will cause the targets to be built. "
3329      "The same concept applies to the default build of other generators.",
3330      false);
3331
3332   cm->DefineProperty
3333     ("PARENT_DIRECTORY", cmProperty::DIRECTORY,
3334      "Source directory that added current subdirectory.",
3335      "This read-only property specifies the source directory that "
3336      "added the current source directory as a subdirectory of the build.  "
3337      "In the top-level directory the value is the empty-string.", false);
3338
3339   cm->DefineProperty
3340     ("INCLUDE_REGULAR_EXPRESSION", cmProperty::DIRECTORY,
3341      "Include file scanning regular expression.",
3342      "This read-only property specifies the regular expression used "
3343      "during dependency scanning to match include files that should "
3344      "be followed.  See the include_regular_expression command.", false);
3345
3346   cm->DefineProperty
3347     ("VARIABLES", cmProperty::DIRECTORY,
3348      "List of variables defined in the current directory.",
3349      "This read-only property specifies the list of CMake variables "
3350      "currently defined.  "
3351      "It is intended for debugging purposes.", false);
3352
3353   cm->DefineProperty
3354     ("CACHE_VARIABLES", cmProperty::DIRECTORY,
3355      "List of cache variables available in the current directory.",
3356      "This read-only property specifies the list of CMake cache "
3357      "variables currently defined.  "
3358      "It is intended for debugging purposes.", false);
3359
3360   cm->DefineProperty
3361     ("MACROS", cmProperty::DIRECTORY,
3362      "List of macro commands available in the current directory.",
3363      "This read-only property specifies the list of CMake macros "
3364      "currently defined.  "
3365      "It is intended for debugging purposes.  "
3366      "See the macro command.", false);
3367
3368   cm->DefineProperty
3369     ("DEFINITIONS", cmProperty::DIRECTORY,
3370      "For CMake 2.4 compatibility only.  Use COMPILE_DEFINITIONS instead.",
3371      "This read-only property specifies the list of flags given so far "
3372      "to the add_definitions command.  "
3373      "It is intended for debugging purposes.  "
3374      "Use the COMPILE_DEFINITIONS instead.", false);
3375
3376   cm->DefineProperty
3377     ("INCLUDE_DIRECTORIES", cmProperty::DIRECTORY,
3378      "List of preprocessor include file search directories.",
3379      "This read-only property specifies the list of directories given "
3380      "so far to the include_directories command.  "
3381      "It is intended for debugging purposes.", false);
3382
3383   cm->DefineProperty
3384     ("LINK_DIRECTORIES", cmProperty::DIRECTORY,
3385      "List of linker search directories.",
3386      "This read-only property specifies the list of directories given "
3387      "so far to the link_directories command.  "
3388      "It is intended for debugging purposes.", false);
3389 }
3390
3391 //----------------------------------------------------------------------------
3392 cmTarget*
3393 cmMakefile::AddImportedTarget(const char* name, cmTarget::TargetType type)
3394 {
3395   // Create the target.
3396   cmsys::auto_ptr<cmTarget> target(new cmTarget);
3397   target->SetType(type, name);
3398   target->SetMakefile(this);
3399   target->MarkAsImported();
3400
3401   // Add to the set of available imported targets.
3402   this->ImportedTargets[name] = target.get();
3403
3404   // Transfer ownership to this cmMakefile object.
3405   this->ImportedTargetsOwned.push_back(target.get());
3406   return target.release();
3407 }
3408
3409 //----------------------------------------------------------------------------
3410 cmTarget* cmMakefile::FindTargetToUse(const char* name)
3411 {
3412   // Look for an imported target.  These take priority because they
3413   // are more local in scope and do not have to be globally unique.
3414   std::map<cmStdString, cmTarget*>::const_iterator
3415     imported = this->ImportedTargets.find(name);
3416   if(imported != this->ImportedTargets.end())
3417     {
3418     return imported->second;
3419     }
3420
3421   // Look for a target built in this project.
3422   return this->LocalGenerator->GetGlobalGenerator()->FindTarget(0, name);
3423 }
3424
3425 //----------------------------------------------------------------------------
3426 bool cmMakefile::EnforceUniqueName(std::string const& name, std::string& msg,
3427                                    bool isCustom)
3428 {
3429   if(cmTarget* existing = this->FindTargetToUse(name.c_str()))
3430     {
3431     // The name given conflicts with an existing target.  Produce an
3432     // error in a compatible way.
3433     if(existing->IsImported())
3434       {
3435       // Imported targets were not supported in previous versions.
3436       // This is new code, so we can make it an error.
3437       cmOStringStream e;
3438       e << "cannot create target \"" << name
3439         << "\" because an imported target with the same name already exists.";
3440       msg = e.str();
3441       return false;
3442       }
3443     else
3444       {
3445       // target names must be globally unique
3446       switch (this->GetPolicyStatus(cmPolicies::CMP0002))
3447         {
3448         case cmPolicies::WARN:
3449           this->IssueMessage(cmake::AUTHOR_WARNING, this->GetPolicies()->
3450                              GetPolicyWarning(cmPolicies::CMP0002));
3451         case cmPolicies::OLD:
3452           return true;
3453         case cmPolicies::REQUIRED_IF_USED:
3454         case cmPolicies::REQUIRED_ALWAYS:
3455           this->IssueMessage(cmake::FATAL_ERROR,
3456             this->GetPolicies()->GetRequiredPolicyError(cmPolicies::CMP0002)
3457             );
3458           return true;
3459         case cmPolicies::NEW:
3460           break;
3461         }
3462
3463       // The conflict is with a non-imported target.
3464       // Allow this if the user has requested support.
3465       cmake* cm =
3466         this->LocalGenerator->GetGlobalGenerator()->GetCMakeInstance();
3467       if(isCustom && existing->GetType() == cmTarget::UTILITY &&
3468          this != existing->GetMakefile() &&
3469          cm->GetPropertyAsBool("ALLOW_DUPLICATE_CUSTOM_TARGETS"))
3470         {
3471         return true;
3472         }
3473
3474       // Produce an error that tells the user how to work around the
3475       // problem.
3476       cmOStringStream e;
3477       e << "cannot create target \"" << name
3478         << "\" because another target with the same name already exists.  "
3479         << "The existing target is ";
3480       switch(existing->GetType())
3481         {
3482         case cmTarget::EXECUTABLE:
3483           e << "an executable ";
3484           break;
3485         case cmTarget::STATIC_LIBRARY:
3486           e << "a static library ";
3487           break;
3488         case cmTarget::SHARED_LIBRARY:
3489           e << "a shared library ";
3490           break;
3491         case cmTarget::MODULE_LIBRARY:
3492           e << "a module library ";
3493           break;
3494         case cmTarget::UTILITY:
3495           e << "a custom target ";
3496           break;
3497         default: break;
3498         }
3499       e << "created in source directory \""
3500         << existing->GetMakefile()->GetCurrentDirectory() << "\".  "
3501         << "See documentation for policy CMP0002 for more details.";
3502       msg = e.str();
3503       return false;
3504       }
3505     }
3506   return true;
3507 }
3508
3509 //----------------------------------------------------------------------------
3510 cmPolicies::PolicyStatus
3511 cmMakefile::GetPolicyStatus(cmPolicies::PolicyID id)
3512 {
3513   // Get the current setting of the policy.
3514   cmPolicies::PolicyStatus cur = this->GetPolicyStatusInternal(id);
3515
3516   // If the policy is required to be set to NEW but is not, ignore the
3517   // current setting and tell the caller.
3518   if(cur != cmPolicies::NEW)
3519     {
3520     if(cur == cmPolicies::REQUIRED_ALWAYS ||
3521        cur == cmPolicies::REQUIRED_IF_USED)
3522       {
3523       return cur;
3524       }
3525     cmPolicies::PolicyStatus def = this->GetPolicies()->GetPolicyStatus(id);
3526     if(def == cmPolicies::REQUIRED_ALWAYS ||
3527        def == cmPolicies::REQUIRED_IF_USED)
3528       {
3529       return def;
3530       }
3531     }
3532
3533   // The current setting is okay.
3534   return cur;
3535 }
3536
3537 //----------------------------------------------------------------------------
3538 cmPolicies::PolicyStatus
3539 cmMakefile::GetPolicyStatusInternal(cmPolicies::PolicyID id)
3540 {
3541   // Is the policy set in our stack?
3542   for(std::vector<PolicyMap>::reverse_iterator
3543         psi = this->PolicyStack.rbegin();
3544       psi != this->PolicyStack.rend(); ++psi)
3545     {
3546     PolicyMap::const_iterator pse = psi->find(id);
3547     if(pse != psi->end())
3548       {
3549       return pse->second;
3550       }
3551     }
3552
3553   // If we have a parent directory, recurse up to it.
3554   if(this->LocalGenerator->GetParent())
3555     {
3556     cmMakefile* parent = this->LocalGenerator->GetParent()->GetMakefile();
3557     return parent->GetPolicyStatusInternal(id);
3558     }
3559
3560   // The policy is not set.  Use the default for this CMake version.
3561   return this->GetPolicies()->GetPolicyStatus(id);
3562 }
3563
3564 bool cmMakefile::SetPolicy(const char *id,
3565                            cmPolicies::PolicyStatus status)
3566 {
3567   cmPolicies::PolicyID pid;
3568   if (!this->GetPolicies()->GetPolicyID(id, /* out */ pid))
3569     {
3570     cmOStringStream e;
3571     e << "Policy \"" << id << "\" is not known to this version of CMake.";
3572     this->IssueMessage(cmake::FATAL_ERROR, e.str());
3573     return false;
3574     }
3575   return this->SetPolicy(pid,status);
3576 }
3577
3578 //----------------------------------------------------------------------------
3579 bool cmMakefile::SetPolicy(cmPolicies::PolicyID id,
3580                            cmPolicies::PolicyStatus status)
3581 {
3582   // A REQUIRED_ALWAYS policy may be set only to NEW.
3583   if(status != cmPolicies::NEW &&
3584      this->GetPolicies()->GetPolicyStatus(id) ==
3585      cmPolicies::REQUIRED_ALWAYS)
3586     {
3587     std::string msg =
3588       this->GetPolicies()->GetRequiredAlwaysPolicyError(id);
3589     this->IssueMessage(cmake::FATAL_ERROR, msg.c_str());
3590     return false;
3591     }
3592
3593   // Store the setting.
3594   this->PolicyStack.back()[id] = status;
3595
3596   // Special hook for presenting compatibility variable as soon as
3597   // the user requests it.
3598   if(id == cmPolicies::CMP0001 &&
3599      (status == cmPolicies::WARN || status == cmPolicies::OLD))
3600     {
3601     if(!(this->GetCacheManager()
3602          ->GetCacheValue("CMAKE_BACKWARDS_COMPATIBILITY")))
3603       {
3604       // Set it to 2.4 because that is the last version where the
3605       // variable had meaning.
3606       this->AddCacheDefinition
3607         ("CMAKE_BACKWARDS_COMPATIBILITY", "2.4",
3608          "For backwards compatibility, what version of CMake "
3609          "commands and "
3610          "syntax should this version of CMake try to support.",
3611          cmCacheManager::STRING);
3612       }
3613     }
3614
3615   return true;
3616 }
3617
3618 bool cmMakefile::PushPolicy()
3619 {
3620   // Allocate a new stack entry.
3621   this->PolicyStack.push_back(PolicyMap());
3622   return true;
3623 }
3624
3625 bool cmMakefile::PopPolicy(bool reportError)
3626 {
3627   if(this->PolicyStack.size() == 1)
3628     {
3629     if(reportError)
3630       {
3631       cmSystemTools::Error("Attempt to pop the policy stack past "
3632                            "it's beginning.");
3633       }
3634     return false;
3635     }
3636   this->PolicyStack.pop_back();
3637   return true;
3638 }
3639
3640 bool cmMakefile::SetPolicyVersion(const char *version)
3641 {
3642   return this->GetCMakeInstance()->GetPolicies()->
3643     ApplyPolicyVersion(this,version);
3644 }
3645
3646 cmPolicies *cmMakefile::GetPolicies()
3647 {
3648   if (!this->GetCMakeInstance())
3649   {
3650     return 0;
3651   }
3652   return this->GetCMakeInstance()->GetPolicies();
3653 }