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