Source/cmGlobalXCodeGenerator.cxx

   1 /*=========================================================================
   2
   3 Program:   CMake - Cross-Platform Makefile Generator
   4 Module:    $RCSfile: cmGlobalXCodeGenerator.cxx,v $
   5 Language:  C++
   6 Date:      $Date: 2008-10-09 15:01:47 $
   7 Version:   $Revision: 1.203 $
   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 "cmGlobalXCodeGenerator.h"
  18 #include "cmGlobalXCode21Generator.h"
  19 #include "cmLocalXCodeGenerator.h"
  20 #include "cmMakefile.h"
  21 #include "cmXCodeObject.h"
  22 #include "cmXCode21Object.h"
  23 #include "cmake.h"
  24 #include "cmGeneratedFileStream.h"
  25 #include "cmComputeLinkInformation.h"
  26 #include "cmSourceFile.h"
  27
  28 //----------------------------------------------------------------------------
  29 #if defined(CMAKE_BUILD_WITH_CMAKE)
  30 #include "cmXMLParser.h"
  31
  32 // parse the xml file storing the installed version of Xcode on
  33 // the machine
  34 class cmXcodeVersionParser : public cmXMLParser
  35 {
  36 public:
  37   void StartElement(const char* , const char** )
  38     {
  39       this->Data = "";
  40     }
  41   void EndElement(const char* name)
  42     {
  43       if(strcmp(name, "key") == 0)
  44         {
  45         this->Key = this->Data;
  46         }
  47       else if(strcmp(name, "string") == 0)
  48         {
  49         if(this->Key == "CFBundleShortVersionString")
  50           {
  51           this->Version = (int)(10.0 * atof(this->Data.c_str()));
  52           }
  53         }
  54     }
  55   void CharacterDataHandler(const char* data, int length)
  56     {
  57       this->Data.append(data, length);
  58     }
  59   int Version;
  60   std::string Key;
  61   std::string Data;
  62 };
  63 #endif
  64
  65 //----------------------------------------------------------------------------
  66 cmGlobalXCodeGenerator::cmGlobalXCodeGenerator()
  67 {
  68   this->FindMakeProgramFile = "CMakeFindXCode.cmake";
  69   this->RootObject = 0;
  70   this->MainGroupChildren = 0;
  71   this->SourcesGroupChildren = 0;
  72   this->ResourcesGroupChildren = 0;
  73   this->CurrentMakefile = 0;
  74   this->CurrentLocalGenerator = 0;
  75   this->XcodeVersion = 15;
  76 }
  77
  78 //----------------------------------------------------------------------------
  79 cmGlobalGenerator* cmGlobalXCodeGenerator::New()
  80 {
  81 #if defined(CMAKE_BUILD_WITH_CMAKE)
  82   cmXcodeVersionParser parser;
  83   parser.ParseFile
  84     ("/Developer/Applications/Xcode.app/Contents/version.plist");
  85   if(parser.Version == 15)
  86     {
  87     return new cmGlobalXCodeGenerator;
  88     }
  89   else if (parser.Version == 20)
  90     {
  91     cmSystemTools::Message("Xcode 2.0 not really supported by cmake, "
  92                            "using Xcode 15 generator\n");
  93     return new cmGlobalXCodeGenerator;
  94     }
  95   cmGlobalXCodeGenerator* ret = new cmGlobalXCode21Generator;
  96   ret->SetVersion(parser.Version);
  97   return ret;
  98 #else
  99   std::cerr << "CMake should be built with cmake to use XCode, "
 100     "default to Xcode 1.5\n";
 101   return new cmGlobalXCodeGenerator;
 102 #endif
 103 }
 104
 105 //----------------------------------------------------------------------------
 106 void cmGlobalXCodeGenerator::EnableLanguage(std::vector<std::string>const&
 107                                             lang,
 108                                             cmMakefile * mf, bool optional)
 109 {
 110   mf->AddDefinition("XCODE","1");
 111   if(this->XcodeVersion == 15)
 112     {
 113     }
 114   else
 115     {
 116     mf->AddCacheDefinition(
 117       "CMAKE_CONFIGURATION_TYPES",
 118       "Debug;Release;MinSizeRel;RelWithDebInfo",
 119       "Semicolon separated list of supported configuration types, "
 120       "only supports Debug, Release, MinSizeRel, and RelWithDebInfo, "
 121       "anything else will be ignored.",
 122       cmCacheManager::STRING);
 123     }
 124   mf->AddDefinition("CMAKE_GENERATOR_CC", "gcc");
 125   mf->AddDefinition("CMAKE_GENERATOR_CXX", "g++");
 126   mf->AddDefinition("CMAKE_GENERATOR_NO_COMPILER_ENV", "1");
 127   // initialize Architectures so it can be used by
 128   //  GetTargetObjectFileDirectories
 129   this->cmGlobalGenerator::EnableLanguage(lang, mf, optional);
 130     const char* osxArch =
 131       mf->GetDefinition("CMAKE_OSX_ARCHITECTURES");
 132   const char* sysroot =
 133       mf->GetDefinition("CMAKE_OSX_SYSROOT");
 134   if(osxArch && sysroot)
 135     {
 136     this->Architectures.clear();
 137     cmSystemTools::ExpandListArgument(std::string(osxArch),
 138                                       this->Architectures);
 139     }
 140 }
 141
 142 //----------------------------------------------------------------------------
 143 std::string cmGlobalXCodeGenerator
 144 ::GenerateBuildCommand(const char* makeProgram,
 145                        const char *projectName,
 146                        const char* additionalOptions,
 147                        const char *targetName,
 148                        const char* config,
 149                        bool ignoreErrors,
 150                        bool)
 151 {
 152   // Config is not used yet
 153   (void) ignoreErrors;
 154
 155   // now build the test
 156   if(makeProgram == 0 || !strlen(makeProgram))
 157     {
 158     cmSystemTools::Error(
 159       "Generator cannot find the appropriate make command.");
 160     return "";
 161     }
 162   std::string makeCommand =
 163     cmSystemTools::ConvertToOutputPath(makeProgram);
 164   std::string lowerCaseCommand = makeCommand;
 165   cmSystemTools::LowerCase(lowerCaseCommand);
 166
 167   makeCommand += " -project ";
 168   makeCommand += projectName;
 169   makeCommand += ".xcode";
 170   if(this->XcodeVersion > 20)
 171     {
 172     makeCommand += "proj";
 173     }
 174
 175   bool clean = false;
 176   if ( targetName && strcmp(targetName, "clean") == 0 )
 177     {
 178     clean = true;
 179     targetName = "ALL_BUILD";
 180     }
 181   if(clean)
 182     {
 183     makeCommand += " clean";
 184     }
 185   else
 186     {
 187     makeCommand += " build";
 188     }
 189   makeCommand += " -target ";
 190   // if it is a null string for config don't use it
 191   if(config && *config == 0)
 192     {
 193     config = 0;
 194     }
 195   if (targetName && strlen(targetName))
 196     {
 197     makeCommand += targetName;
 198     }
 199   else
 200     {
 201     makeCommand += "ALL_BUILD";
 202     }
 203   if(this->XcodeVersion == 15)
 204     {
 205     makeCommand += " -buildstyle Development ";
 206     }
 207   else
 208     {
 209     makeCommand += " -configuration ";
 210     makeCommand += config?config:"Debug";
 211     }
 212   if ( additionalOptions )
 213     {
 214     makeCommand += " ";
 215     makeCommand += additionalOptions;
 216     }
 217   return makeCommand;
 218 }
 219
 220 //----------------------------------------------------------------------------
 221 ///! Create a local generator appropriate to this Global Generator
 222 cmLocalGenerator *cmGlobalXCodeGenerator::CreateLocalGenerator()
 223 {
 224   cmLocalGenerator *lg = new cmLocalXCodeGenerator;
 225   lg->SetGlobalGenerator(this);
 226   return lg;
 227 }
 228
 229 //----------------------------------------------------------------------------
 230 void cmGlobalXCodeGenerator::Generate()
 231 {
 232   std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it;
 233   // make sure extra targets are added before calling
 234   // the parent generate which will call trace depends
 235   for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
 236     {
 237     cmLocalGenerator* root = it->second[0];
 238     this->SetGenerationRoot(root);
 239     // add ALL_BUILD, INSTALL, etc
 240     this->AddExtraTargets(root, it->second);
 241     }
 242   this->cmGlobalGenerator::Generate();
 243   for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
 244     {
 245     cmLocalGenerator* root = it->second[0];
 246     this->SetGenerationRoot(root);
 247     // now create the project
 248     this->OutputXCodeProject(root, it->second);
 249     }
 250 }
 251
 252 //----------------------------------------------------------------------------
 253 void cmGlobalXCodeGenerator::SetGenerationRoot(cmLocalGenerator* root)
 254 {
 255   this->CurrentProject = root->GetMakefile()->GetProjectName();
 256   this->SetCurrentLocalGenerator(root);
 257   std::string outDir = this->CurrentMakefile->GetHomeOutputDirectory();
 258   outDir =cmSystemTools::CollapseFullPath(outDir.c_str());
 259   cmSystemTools::SplitPath(outDir.c_str(),
 260                            this->ProjectOutputDirectoryComponents);
 261
 262   this->CurrentXCodeHackMakefile =
 263     root->GetMakefile()->GetCurrentOutputDirectory();
 264   this->CurrentXCodeHackMakefile += "/CMakeScripts";
 265   cmSystemTools::MakeDirectory(this->CurrentXCodeHackMakefile.c_str());
 266   this->CurrentXCodeHackMakefile += "/XCODE_DEPEND_HELPER.make";
 267 }
 268
 269 //----------------------------------------------------------------------------
 270 void
 271 cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root,
 272                                         std::vector<cmLocalGenerator*>& gens)
 273 {
 274   cmMakefile* mf = root->GetMakefile();
 275
 276   // Add ALL_BUILD
 277   const char* no_working_directory = 0;
 278   std::vector<std::string> no_depends;
 279   mf->AddUtilityCommand("ALL_BUILD", true, no_depends,
 280                         no_working_directory,
 281                         "echo", "Build all projects");
 282   cmTarget* allbuild = mf->FindTarget("ALL_BUILD");
 283
 284   // Refer to the main build configuration file for easy editing.
 285   std::string listfile = mf->GetStartDirectory();
 286   listfile += "/";
 287   listfile += "CMakeLists.txt";
 288   allbuild->AddSource(listfile.c_str());
 289
 290   // Add XCODE depend helper
 291   std::string dir = mf->GetCurrentOutputDirectory();
 292   cmCustomCommandLine makecommand;
 293   makecommand.push_back("make");
 294   makecommand.push_back("-C");
 295   makecommand.push_back(dir.c_str());
 296   makecommand.push_back("-f");
 297   makecommand.push_back(this->CurrentXCodeHackMakefile.c_str());
 298   if(this->XcodeVersion > 20)
 299     {
 300     makecommand.push_back("all.$(CONFIGURATION)");
 301     }
 302   cmCustomCommandLines commandLines;
 303   commandLines.push_back(makecommand);
 304   // Add Re-Run CMake rules
 305   this->CreateReRunCMakeFile(root);
 306
 307   // now make the allbuild depend on all the non-utility targets
 308   // in the project
 309   for(std::vector<cmLocalGenerator*>::iterator i = gens.begin();
 310       i != gens.end(); ++i)
 311     {
 312     cmLocalGenerator* lg = *i;
 313     if(this->IsExcluded(root, *i))
 314       {
 315       continue;
 316       }
 317     cmTargets& tgts = lg->GetMakefile()->GetTargets();
 318     for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); l++)
 319       {
 320       cmTarget& target = l->second;
 321       // make all exe, shared libs and modules
 322       // run the depend check makefile as a post build rule
 323       // this will make sure that when the next target is built
 324       // things are up-to-date
 325       if((target.GetType() == cmTarget::EXECUTABLE ||
 326           target.GetType() == cmTarget::STATIC_LIBRARY ||
 327           target.GetType() == cmTarget::SHARED_LIBRARY ||
 328           target.GetType() == cmTarget::MODULE_LIBRARY))
 329         {
 330         lg->GetMakefile()->AddCustomCommandToTarget(target.GetName(),
 331                                                     no_depends,
 332                                                     commandLines,
 333                                                     cmTarget::POST_BUILD,
 334                                                     "Depend check for xcode",
 335                                                     dir.c_str());
 336
 337         }
 338       if(!target.GetPropertyAsBool("EXCLUDE_FROM_ALL"))
 339         {
 340         allbuild->AddUtility(target.GetName());
 341         }
 342
 343       // Refer to the build configuration file for easy editing.
 344       listfile = lg->GetMakefile()->GetStartDirectory();
 345       listfile += "/";
 346       listfile += "CMakeLists.txt";
 347       target.AddSource(listfile.c_str());
 348       }
 349     }
 350 }
 351
 352 //----------------------------------------------------------------------------
 353 void cmGlobalXCodeGenerator::CreateReRunCMakeFile(cmLocalGenerator* root)
 354 {
 355   cmMakefile* mf = root->GetMakefile();
 356   std::vector<std::string> lfiles = mf->GetListFiles();
 357   // sort the array
 358   std::sort(lfiles.begin(), lfiles.end(), std::less<std::string>());
 359   std::vector<std::string>::iterator new_end =
 360     std::unique(lfiles.begin(), lfiles.end());
 361   lfiles.erase(new_end, lfiles.end());
 362   std::string dir = mf->GetHomeOutputDirectory();
 363   this->CurrentReRunCMakeMakefile = dir;
 364   this->CurrentReRunCMakeMakefile += "/CMakeScripts";
 365   cmSystemTools::MakeDirectory(this->CurrentReRunCMakeMakefile.c_str());
 366   this->CurrentReRunCMakeMakefile += "/ReRunCMake.make";
 367   cmGeneratedFileStream makefileStream
 368     (this->CurrentReRunCMakeMakefile.c_str());
 369   makefileStream.SetCopyIfDifferent(true);
 370   makefileStream << "# Generated by CMake, DO NOT EDIT\n";
 371   makefileStream << cmake::GetCMakeFilesDirectoryPostSlash();
 372   makefileStream << "cmake.check_cache: ";
 373   for(std::vector<std::string>::const_iterator i = lfiles.begin();
 374       i !=  lfiles.end(); ++i)
 375     {
 376     makefileStream << "\\\n" << this->ConvertToRelativeForMake(i->c_str());
 377     }
 378   std::string cmake = mf->GetRequiredDefinition("CMAKE_COMMAND");
 379   makefileStream << "\n\t" << this->ConvertToRelativeForMake(cmake.c_str())
 380                  << " -H" << this->ConvertToRelativeForMake(
 381                    mf->GetHomeDirectory())
 382                  << " -B" << this->ConvertToRelativeForMake(
 383                    mf->GetHomeOutputDirectory()) << "\n";
 384 }
 385
 386 //----------------------------------------------------------------------------
 387 void cmGlobalXCodeGenerator::ClearXCodeObjects()
 388 {
 389   this->TargetDoneSet.clear();
 390   for(unsigned int i = 0; i < this->XCodeObjects.size(); ++i)
 391     {
 392     delete this->XCodeObjects[i];
 393     }
 394   this->XCodeObjects.clear();
 395   this->GroupMap.clear();
 396   this->GroupNameMap.clear();
 397   this->TargetGroup.clear();
 398   this->FileRefs.clear();
 399 }
 400
 401 //----------------------------------------------------------------------------
 402 cmXCodeObject*
 403 cmGlobalXCodeGenerator::CreateObject(cmXCodeObject::PBXType ptype)
 404 {
 405   cmXCodeObject* obj;
 406   if(this->XcodeVersion == 15)
 407     {
 408     obj = new cmXCodeObject(ptype, cmXCodeObject::OBJECT);
 409     }
 410   else
 411     {
 412     obj = new cmXCode21Object(ptype, cmXCodeObject::OBJECT);
 413     }
 414   this->XCodeObjects.push_back(obj);
 415   return obj;
 416 }
 417
 418 //----------------------------------------------------------------------------
 419 cmXCodeObject*
 420 cmGlobalXCodeGenerator::CreateObject(cmXCodeObject::Type type)
 421 {
 422   cmXCodeObject* obj = new cmXCodeObject(cmXCodeObject::None, type);
 423   this->XCodeObjects.push_back(obj);
 424   return obj;
 425 }
 426
 427 //----------------------------------------------------------------------------
 428 cmXCodeObject*
 429 cmGlobalXCodeGenerator::CreateString(const char* s)
 430 {
 431   cmXCodeObject* obj = this->CreateObject(cmXCodeObject::STRING);
 432   obj->SetString(s);
 433   return obj;
 434 }
 435
 436 //----------------------------------------------------------------------------
 437 cmXCodeObject* cmGlobalXCodeGenerator
 438 ::CreateObjectReference(cmXCodeObject* ref)
 439 {
 440   cmXCodeObject* obj = this->CreateObject(cmXCodeObject::OBJECT_REF);
 441   obj->SetObject(ref);
 442   return obj;
 443 }
 444
 445 //----------------------------------------------------------------------------
 446 cmStdString GetGroupMapKey(cmTarget& cmtarget, cmSourceFile* sf)
 447 {
 448   cmStdString key(cmtarget.GetName());
 449   key += "-";
 450   key += sf->GetFullPath();
 451   return key;
 452 }
 453
 454 //----------------------------------------------------------------------------
 455 cmXCodeObject*
 456 cmGlobalXCodeGenerator::CreateXCodeSourceFile(cmLocalGenerator* lg,
 457                                               cmSourceFile* sf,
 458                                               cmTarget& cmtarget)
 459 {
 460   // Add flags from target and source file properties.
 461   std::string flags;
 462   if(cmtarget.GetProperty("COMPILE_FLAGS"))
 463     {
 464     lg->AppendFlags(flags, cmtarget.GetProperty("COMPILE_FLAGS"));
 465     }
 466   lg->AppendFlags(flags, sf->GetProperty("COMPILE_FLAGS"));
 467
 468   // Add per-source definitions.
 469   this->AppendDefines(flags, sf->GetProperty("COMPILE_DEFINITIONS"), true);
 470
 471   // Using a map and the full path guarantees that we will always get the same
 472   // fileRef object for any given full path.
 473   //
 474   cmXCodeObject* fileRef = this->CreateXCodeFileReference(sf, cmtarget);
 475
 476   cmXCodeObject* buildFile = this->CreateObject(cmXCodeObject::PBXBuildFile);
 477   buildFile->SetComment(fileRef->GetComment());
 478   buildFile->AddAttribute("fileRef", this->CreateObjectReference(fileRef));
 479
 480   cmXCodeObject* settings =
 481     this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
 482   settings->AddAttribute("COMPILER_FLAGS", this->CreateString(flags.c_str()));
 483
 484   // Is this a resource file in this target? Add it to the resources group...
 485   //
 486   cmTarget::SourceFileFlags tsFlags = cmtarget.GetTargetSourceFileFlags(sf);
 487   bool isResource = (tsFlags.Type == cmTarget::SourceFileTypeResource);
 488
 489   // Is this a "private" or "public" framework header file?
 490   // Set the ATTRIBUTES attribute appropriately...
 491   //
 492   if(cmtarget.IsFrameworkOnApple())
 493     {
 494     if(tsFlags.Type == cmTarget::SourceFileTypePrivateHeader)
 495       {
 496       cmXCodeObject* attrs = this->CreateObject(cmXCodeObject::OBJECT_LIST);
 497       attrs->AddObject(this->CreateString("Private"));
 498       settings->AddAttribute("ATTRIBUTES", attrs);
 499       isResource = true;
 500       }
 501     else if(tsFlags.Type == cmTarget::SourceFileTypePublicHeader)
 502       {
 503       cmXCodeObject* attrs = this->CreateObject(cmXCodeObject::OBJECT_LIST);
 504       attrs->AddObject(this->CreateString("Public"));
 505       settings->AddAttribute("ATTRIBUTES", attrs);
 506       isResource = true;
 507       }
 508     }
 509
 510   // Add the fileRef to the top level Resources group/folder if it is not
 511   // already there.
 512   //
 513   if(isResource && this->ResourcesGroupChildren &&
 514     !this->ResourcesGroupChildren->HasObject(fileRef))
 515     {
 516     this->ResourcesGroupChildren->AddObject(fileRef);
 517     }
 518
 519   buildFile->AddAttribute("settings", settings);
 520   return buildFile;
 521 }
 522
 523 //----------------------------------------------------------------------------
 524 cmXCodeObject*
 525 cmGlobalXCodeGenerator::CreateXCodeFileReference(cmSourceFile* sf,
 526                                                  cmTarget& cmtarget)
 527 {
 528   std::string fname = sf->GetFullPath();
 529   cmXCodeObject* fileRef = this->FileRefs[fname];
 530   if(!fileRef)
 531     {
 532     fileRef = this->CreateObject(cmXCodeObject::PBXFileReference);
 533     std::string comment = fname;
 534     //comment += " in ";
 535     //std::string gname = group->GetObject("name")->GetString();
 536     //comment += gname.substr(1, gname.size()-2);
 537     fileRef->SetComment(fname.c_str());
 538     this->FileRefs[fname] = fileRef;
 539     }
 540   cmStdString key = GetGroupMapKey(cmtarget, sf);
 541   cmXCodeObject* group = this->GroupMap[key];
 542   cmXCodeObject* children = group->GetObject("children");
 543   if (!children->HasObject(fileRef))
 544     {
 545     children->AddObject(fileRef);
 546     }
 547   fileRef->AddAttribute("fileEncoding", this->CreateString("4"));
 548
 549   const char* lang =
 550     this->CurrentLocalGenerator->GetSourceFileLanguage(*sf);
 551   std::string sourcecode = "sourcecode";
 552   std::string ext = sf->GetExtension();
 553   ext = cmSystemTools::LowerCase(ext);
 554
 555   if(ext == "o")
 556     {
 557     sourcecode = "compiled.mach-o.objfile";
 558     }
 559   else if(ext == "mm")
 560     {
 561     sourcecode += ".cpp.objcpp";
 562     }
 563   else if(ext == "m")
 564     {
 565     sourcecode += ".c.objc";
 566     }
 567   else if(ext == "plist")
 568     {
 569     sourcecode += ".text.plist";
 570     }
 571   else if(ext == "h" || ext == "hxx" || ext == "hpp")
 572     {
 573     const char* linkLanguage = cmtarget.GetLinkerLanguage(this);
 574     if(linkLanguage && (std::string(linkLanguage) == "CXX"))
 575       {
 576       sourcecode += ".cpp.h";
 577       }
 578     else
 579       {
 580       sourcecode += ".c.h";
 581       }
 582     }
 583   else if(lang && strcmp(lang, "CXX") == 0)
 584     {
 585     sourcecode += ".cpp.cpp";
 586     }
 587   else if(lang && strcmp(lang, "C") == 0)
 588     {
 589     sourcecode += ".c.c";
 590     }
 591   else if(ext == "txt")
 592     {
 593     sourcecode += ".text";
 594     }
 595   //else
 596   //  {
 597   //  // Already specialized above or we leave sourcecode == "sourcecode"
 598   //  // which is probably the most correct choice. Extensionless headers,
 599   //  // for example... Or file types unknown to Xcode that do not map to a
 600   //  // valid lastKnownFileType value.
 601   //  }
 602
 603   fileRef->AddAttribute("lastKnownFileType",
 604                         this->CreateString(sourcecode.c_str()));
 605
 606   std::string path =
 607     this->ConvertToRelativeForXCode(sf->GetFullPath().c_str());
 608   std::string dir;
 609   std::string file;
 610   cmSystemTools::SplitProgramPath(sf->GetFullPath().c_str(),
 611                                   dir, file);
 612
 613   fileRef->AddAttribute("name", this->CreateString(file.c_str()));
 614   fileRef->AddAttribute("path", this->CreateString(path.c_str()));
 615   if(this->XcodeVersion == 15)
 616     {
 617     fileRef->AddAttribute("refType", this->CreateString("4"));
 618     }
 619   if(path.size() > 1 && path[0] == '.' && path[1] == '.')
 620     {
 621     fileRef->AddAttribute("sourceTree", this->CreateString("<group>"));
 622     }
 623   else
 624     {
 625     fileRef->AddAttribute("sourceTree", this->CreateString("<absolute>"));
 626     }
 627
 628   return fileRef;
 629 }
 630
 631 //----------------------------------------------------------------------------
 632 bool cmGlobalXCodeGenerator::SpecialTargetEmitted(std::string const& tname)
 633 {
 634   if(tname == "ALL_BUILD" || tname == "XCODE_DEPEND_HELPER" ||
 635      tname == "install" || tname == "package" || tname == "RUN_TESTS" )
 636     {
 637     if(this->TargetDoneSet.find(tname) != this->TargetDoneSet.end())
 638       {
 639       return true;
 640       }
 641     this->TargetDoneSet.insert(tname);
 642     return false;
 643     }
 644   return false;
 645 }
 646
 647 //----------------------------------------------------------------------------
 648 void cmGlobalXCodeGenerator::SetCurrentLocalGenerator(cmLocalGenerator* gen)
 649 {
 650   this->CurrentLocalGenerator = gen;
 651   this->CurrentMakefile = gen->GetMakefile();
 652   std::string outdir =
 653     cmSystemTools::CollapseFullPath(this->CurrentMakefile->
 654                                     GetCurrentOutputDirectory());
 655   cmSystemTools::SplitPath(outdir.c_str(),
 656                            this->CurrentOutputDirectoryComponents);
 657
 658   // Select the current set of configuration types.
 659   this->CurrentConfigurationTypes.clear();
 660   if(this->XcodeVersion > 20)
 661     {
 662     if(const char* types =
 663        this->CurrentMakefile->GetDefinition("CMAKE_CONFIGURATION_TYPES"))
 664       {
 665       cmSystemTools::ExpandListArgument(types,
 666                                         this->CurrentConfigurationTypes);
 667       }
 668     }
 669   if(this->CurrentConfigurationTypes.empty())
 670     {
 671     if(const char* buildType =
 672        this->CurrentMakefile->GetDefinition("CMAKE_BUILD_TYPE"))
 673       {
 674       this->CurrentConfigurationTypes.push_back(buildType);
 675       }
 676     else
 677       {
 678       this->CurrentConfigurationTypes.push_back("");
 679       }
 680     }
 681 }
 682
 683 //----------------------------------------------------------------------------
 684 void
 685 cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
 686                                            std::vector<cmXCodeObject*>&
 687                                            targets)
 688 {
 689   this->SetCurrentLocalGenerator(gen);
 690   cmTargets &tgts = this->CurrentMakefile->GetTargets();
 691   for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); l++)
 692     {
 693     cmTarget& cmtarget = l->second;
 694
 695     // make sure ALL_BUILD, INSTALL, etc are only done once
 696     if(this->SpecialTargetEmitted(l->first.c_str()))
 697       {
 698       continue;
 699       }
 700
 701     if(cmtarget.GetType() == cmTarget::UTILITY ||
 702        cmtarget.GetType() == cmTarget::GLOBAL_TARGET)
 703       {
 704       targets.push_back(this->CreateUtilityTarget(cmtarget));
 705       continue;
 706       }
 707
 708     // organize the sources
 709     std::vector<cmSourceFile*> const &classes = cmtarget.GetSourceFiles();
 710     std::vector<cmXCodeObject*> externalObjFiles;
 711     std::vector<cmXCodeObject*> headerFiles;
 712     std::vector<cmXCodeObject*> resourceFiles;
 713     std::vector<cmXCodeObject*> sourceFiles;
 714     for(std::vector<cmSourceFile*>::const_iterator i = classes.begin();
 715         i != classes.end(); ++i)
 716       {
 717       cmXCodeObject* xsf =
 718         this->CreateXCodeSourceFile(this->CurrentLocalGenerator,
 719                                     *i, cmtarget);
 720       cmXCodeObject* fr = xsf->GetObject("fileRef");
 721       cmXCodeObject* filetype =
 722         fr->GetObject()->GetObject("lastKnownFileType");
 723
 724       cmTarget::SourceFileFlags tsFlags =
 725         cmtarget.GetTargetSourceFileFlags(*i);
 726
 727       if(strcmp(filetype->GetString(), "compiled.mach-o.objfile") == 0)
 728         {
 729         externalObjFiles.push_back(xsf);
 730         }
 731       else if((*i)->GetPropertyAsBool("HEADER_FILE_ONLY") ||
 732         (tsFlags.Type == cmTarget::SourceFileTypePrivateHeader) ||
 733         (tsFlags.Type == cmTarget::SourceFileTypePublicHeader))
 734         {
 735         headerFiles.push_back(xsf);
 736         }
 737       else if(tsFlags.Type == cmTarget::SourceFileTypeResource)
 738         {
 739         resourceFiles.push_back(xsf);
 740         }
 741       else
 742         {
 743         // Include this file in the build if it has a known language
 744         // and has not been listed as an ignored extension for this
 745         // generator.
 746         if(this->CurrentLocalGenerator->GetSourceFileLanguage(**i) &&
 747            !this->IgnoreFile((*i)->GetExtension().c_str()))
 748           {
 749           sourceFiles.push_back(xsf);
 750           }
 751         }
 752       }
 753
 754     // some build phases only apply to bundles and/or frameworks
 755     bool isFrameworkTarget = cmtarget.IsFrameworkOnApple();
 756     bool isBundleTarget = cmtarget.GetPropertyAsBool("MACOSX_BUNDLE");
 757
 758     cmXCodeObject* buildFiles = 0;
 759
 760     // create source build phase
 761     cmXCodeObject* sourceBuildPhase = 0;
 762     if (!sourceFiles.empty())
 763       {
 764       sourceBuildPhase =
 765         this->CreateObject(cmXCodeObject::PBXSourcesBuildPhase);
 766       sourceBuildPhase->SetComment("Sources");
 767       sourceBuildPhase->AddAttribute("buildActionMask",
 768                                      this->CreateString("2147483647"));
 769       buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
 770       for(std::vector<cmXCodeObject*>::iterator i = sourceFiles.begin();
 771           i != sourceFiles.end(); ++i)
 772         {
 773         buildFiles->AddObject(*i);
 774         }
 775       sourceBuildPhase->AddAttribute("files", buildFiles);
 776       sourceBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
 777                                      this->CreateString("0"));
 778       }
 779
 780     // create header build phase - only for framework targets
 781     cmXCodeObject* headerBuildPhase = 0;
 782     if (!headerFiles.empty() && isFrameworkTarget)
 783       {
 784       headerBuildPhase =
 785         this->CreateObject(cmXCodeObject::PBXHeadersBuildPhase);
 786       headerBuildPhase->SetComment("Headers");
 787       headerBuildPhase->AddAttribute("buildActionMask",
 788                                      this->CreateString("2147483647"));
 789       buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
 790       for(std::vector<cmXCodeObject*>::iterator i = headerFiles.begin();
 791           i != headerFiles.end(); ++i)
 792         {
 793         buildFiles->AddObject(*i);
 794         }
 795       headerBuildPhase->AddAttribute("files", buildFiles);
 796       headerBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
 797                                      this->CreateString("0"));
 798       }
 799
 800     // create resource build phase - only for framework or bundle targets
 801     cmXCodeObject* resourceBuildPhase = 0;
 802     if (!resourceFiles.empty() && (isFrameworkTarget || isBundleTarget))
 803       {
 804       resourceBuildPhase =
 805         this->CreateObject(cmXCodeObject::PBXResourcesBuildPhase);
 806       resourceBuildPhase->SetComment("Resources");
 807       resourceBuildPhase->AddAttribute("buildActionMask",
 808                                        this->CreateString("2147483647"));
 809       buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
 810       for(std::vector<cmXCodeObject*>::iterator i = resourceFiles.begin();
 811           i != resourceFiles.end(); ++i)
 812         {
 813         buildFiles->AddObject(*i);
 814         }
 815       resourceBuildPhase->AddAttribute("files", buildFiles);
 816       resourceBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
 817                                      this->CreateString("0"));
 818       }
 819
 820     // create vector of "non-resource content file" build phases - only for
 821     // framework or bundle targets
 822     std::vector<cmXCodeObject*> contentBuildPhases;
 823     if (isFrameworkTarget || isBundleTarget)
 824       {
 825       typedef std::map<cmStdString, std::vector<cmSourceFile*> >
 826         mapOfVectorOfSourceFiles;
 827       mapOfVectorOfSourceFiles bundleFiles;
 828       for(std::vector<cmSourceFile*>::const_iterator i = classes.begin();
 829           i != classes.end(); ++i)
 830         {
 831         cmTarget::SourceFileFlags tsFlags =
 832           cmtarget.GetTargetSourceFileFlags(*i);
 833         if(tsFlags.Type == cmTarget::SourceFileTypeMacContent)
 834           {
 835           bundleFiles[tsFlags.MacFolder].push_back(*i);
 836           }
 837         }
 838       mapOfVectorOfSourceFiles::iterator mit;
 839       for ( mit = bundleFiles.begin(); mit != bundleFiles.end(); ++ mit )
 840         {
 841         cmXCodeObject* copyFilesBuildPhase =
 842           this->CreateObject(cmXCodeObject::PBXCopyFilesBuildPhase);
 843         copyFilesBuildPhase->SetComment("Copy files");
 844         copyFilesBuildPhase->AddAttribute("buildActionMask",
 845           this->CreateString("2147483647"));
 846         copyFilesBuildPhase->AddAttribute("dstSubfolderSpec",
 847           this->CreateString("6"));
 848         cmOStringStream ostr;
 849         if (cmtarget.IsFrameworkOnApple())
 850           {
 851           // dstPath in frameworks is relative to Versions/<version>
 852           ostr << mit->first;
 853           }
 854         else if ( mit->first != "MacOS" )
 855           {
 856           // dstPath in bundles is relative to Contents/MacOS
 857           ostr << "../" << mit->first.c_str();
 858           }
 859         copyFilesBuildPhase->AddAttribute("dstPath",
 860           this->CreateString(ostr.str().c_str()));
 861         copyFilesBuildPhase->AddAttribute(
 862           "runOnlyForDeploymentPostprocessing", this->CreateString("0"));
 863         buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
 864         copyFilesBuildPhase->AddAttribute("files", buildFiles);
 865         std::vector<cmSourceFile*>::iterator sfIt;
 866         for ( sfIt = mit->second.begin(); sfIt != mit->second.end(); ++ sfIt )
 867           {
 868           cmXCodeObject* xsf =
 869             this->CreateXCodeSourceFile(this->CurrentLocalGenerator,
 870                                         *sfIt, cmtarget);
 871           buildFiles->AddObject(xsf);
 872           }
 873         contentBuildPhases.push_back(copyFilesBuildPhase);
 874         }
 875       }
 876
 877     // create framework build phase
 878     cmXCodeObject* frameworkBuildPhase = 0;
 879     if (!externalObjFiles.empty())
 880       {
 881       frameworkBuildPhase =
 882         this->CreateObject(cmXCodeObject::PBXFrameworksBuildPhase);
 883       frameworkBuildPhase->SetComment("Frameworks");
 884       frameworkBuildPhase->AddAttribute("buildActionMask",
 885                                         this->CreateString("2147483647"));
 886       buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
 887       frameworkBuildPhase->AddAttribute("files", buildFiles);
 888       for(std::vector<cmXCodeObject*>::iterator i =  externalObjFiles.begin();
 889           i != externalObjFiles.end(); ++i)
 890         {
 891         buildFiles->AddObject(*i);
 892         }
 893       frameworkBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
 894                                         this->CreateString("0"));
 895       }
 896
 897     // create list of build phases and create the XCode target
 898     cmXCodeObject* buildPhases =
 899       this->CreateObject(cmXCodeObject::OBJECT_LIST);
 900
 901     this->CreateCustomCommands(buildPhases, sourceBuildPhase,
 902                                headerBuildPhase, resourceBuildPhase,
 903                                contentBuildPhases,
 904                                frameworkBuildPhase, cmtarget);
 905
 906     targets.push_back(this->CreateXCodeTarget(cmtarget, buildPhases));
 907     }
 908 }
 909
 910 //----------------------------------------------------------------------------
 911 cmXCodeObject*
 912 cmGlobalXCodeGenerator::CreateBuildPhase(const char* name,
 913                                          const char* name2,
 914                                          cmTarget& cmtarget,
 915                                          const std::vector<cmCustomCommand>&
 916                                          commands)
 917 {
 918   if(commands.size() == 0 && strcmp(name, "CMake ReRun") != 0)
 919     {
 920     return 0;
 921     }
 922   cmXCodeObject* buildPhase =
 923     this->CreateObject(cmXCodeObject::PBXShellScriptBuildPhase);
 924   buildPhase->AddAttribute("buildActionMask",
 925                            this->CreateString("2147483647"));
 926   cmXCodeObject* buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
 927   buildPhase->AddAttribute("files", buildFiles);
 928   buildPhase->AddAttribute("name",
 929                            this->CreateString(name));
 930   buildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
 931                            this->CreateString("0"));
 932   buildPhase->AddAttribute("shellPath",
 933                            this->CreateString("/bin/sh"));
 934   this->AddCommandsToBuildPhase(buildPhase, cmtarget, commands,
 935                                 name2);
 936   return buildPhase;
 937 }
 938
 939 //----------------------------------------------------------------------------
 940 void cmGlobalXCodeGenerator::CreateCustomCommands(cmXCodeObject* buildPhases,
 941                                                   cmXCodeObject*
 942                                                   sourceBuildPhase,
 943                                                   cmXCodeObject*
 944                                                   headerBuildPhase,
 945                                                   cmXCodeObject*
 946                                                   resourceBuildPhase,
 947                                                   std::vector<cmXCodeObject*>
 948                                                   contentBuildPhases,
 949                                                   cmXCodeObject*
 950                                                   frameworkBuildPhase,
 951                                                   cmTarget& cmtarget)
 952 {
 953   std::vector<cmCustomCommand> const & prebuild
 954     = cmtarget.GetPreBuildCommands();
 955   std::vector<cmCustomCommand> const & prelink
 956     = cmtarget.GetPreLinkCommands();
 957   std::vector<cmCustomCommand> const & postbuild
 958     = cmtarget.GetPostBuildCommands();
 959   std::vector<cmSourceFile*>const &classes = cmtarget.GetSourceFiles();
 960   // add all the sources
 961   std::vector<cmCustomCommand> commands;
 962   for(std::vector<cmSourceFile*>::const_iterator i = classes.begin();
 963       i != classes.end(); ++i)
 964     {
 965     if((*i)->GetCustomCommand())
 966       {
 967       commands.push_back(*(*i)->GetCustomCommand());
 968       }
 969     }
 970   std::vector<cmCustomCommand> reruncom;
 971   cmXCodeObject* cmakeReRunPhase =
 972     this->CreateBuildPhase("CMake ReRun", "cmakeReRunPhase",
 973                            cmtarget, reruncom);
 974   buildPhases->AddObject(cmakeReRunPhase);
 975   // create prebuild phase
 976   cmXCodeObject* cmakeRulesBuildPhase =
 977     this->CreateBuildPhase("CMake Rules",
 978                            "cmakeRulesBuildPhase",
 979                            cmtarget, commands);
 980   // create prebuild phase
 981   cmXCodeObject* preBuildPhase =
 982     this->CreateBuildPhase("CMake PreBuild Rules", "preBuildCommands",
 983                            cmtarget, prebuild);
 984   // create prelink phase
 985   cmXCodeObject* preLinkPhase =
 986     this->CreateBuildPhase("CMake PreLink Rules", "preLinkCommands",
 987                            cmtarget, prelink);
 988   // create postbuild phase
 989   cmXCodeObject* postBuildPhase =
 990     this->CreateBuildPhase("CMake PostBuild Rules", "postBuildPhase",
 991                            cmtarget, postbuild);
 992
 993   // The order here is the order they will be built in.
 994   // The order "headers, resources, sources" mimics a native project generated
 995   // from an xcode template...
 996   //
 997   if(preBuildPhase)
 998     {
 999     buildPhases->AddObject(preBuildPhase);
1000     }
1001   if(cmakeRulesBuildPhase)
1002     {
1003     buildPhases->AddObject(cmakeRulesBuildPhase);
1004     }
1005   if(headerBuildPhase)
1006     {
1007     buildPhases->AddObject(headerBuildPhase);
1008     }
1009   if(resourceBuildPhase)
1010     {
1011     buildPhases->AddObject(resourceBuildPhase);
1012     }
1013   std::vector<cmXCodeObject*>::iterator cit;
1014   for (cit = contentBuildPhases.begin(); cit != contentBuildPhases.end();
1015        ++cit)
1016     {
1017     buildPhases->AddObject(*cit);
1018     }
1019   if(sourceBuildPhase)
1020     {
1021     buildPhases->AddObject(sourceBuildPhase);
1022     }
1023   if(preLinkPhase)
1024     {
1025     buildPhases->AddObject(preLinkPhase);
1026     }
1027   if(frameworkBuildPhase)
1028     {
1029     buildPhases->AddObject(frameworkBuildPhase);
1030     }
1031   if(postBuildPhase)
1032     {
1033     buildPhases->AddObject(postBuildPhase);
1034     }
1035 }
1036
1037 //----------------------------------------------------------------------------
1038 std::string cmGlobalXCodeGenerator::ExtractFlag(const char* flag,
1039                                                 std::string& flags)
1040 {
1041   std::string retFlag;
1042   std::string::size_type pos = flags.find(flag);
1043   if(pos != flags.npos && (pos ==0 || flags[pos-1]==' '))
1044     {
1045     while(pos < flags.size() && flags[pos] != ' ')
1046       {
1047       retFlag += flags[pos];
1048       flags[pos] = ' ';
1049       pos++;
1050       }
1051     }
1052   return retFlag;
1053 }
1054
1055 //----------------------------------------------------------------------------
1056 void
1057 cmGlobalXCodeGenerator::AddCommandsToBuildPhase(cmXCodeObject* buildphase,
1058                                                 cmTarget& target,
1059                                                 std::vector<cmCustomCommand>
1060                                                 const & commands,
1061                                                 const char* name)
1062 {
1063   if(strcmp(name, "cmakeReRunPhase") == 0)
1064     {
1065     std::string cdir = this->CurrentMakefile->GetHomeOutputDirectory();
1066     cdir = this->ConvertToRelativeForMake(cdir.c_str());
1067     std::string makecmd = "make -C ";
1068     makecmd += cdir;
1069     makecmd += " -f ";
1070     makecmd +=
1071       this->ConvertToRelativeForMake(this->CurrentReRunCMakeMakefile.c_str());
1072     cmSystemTools::ReplaceString(makecmd, "\\ ", "\\\\ ");
1073     buildphase->AddAttribute("shellScript",
1074                              this->CreateString(makecmd.c_str()));
1075     return;
1076     }
1077
1078   // collect multiple outputs of custom commands into a set
1079   // which will be used for every configuration
1080   std::map<cmStdString, cmStdString> multipleOutputPairs;
1081   for(std::vector<cmCustomCommand>::const_iterator i = commands.begin();
1082       i != commands.end(); ++i)
1083     {
1084     cmCustomCommand const& cc = *i;
1085     if(!cc.GetCommandLines().empty())
1086       {
1087       const std::vector<std::string>& outputs = cc.GetOutputs();
1088       if(!outputs.empty())
1089         {
1090         // If there are more than one outputs treat the
1091         // first as the primary output and make the rest depend on it.
1092         std::vector<std::string>::const_iterator o = outputs.begin();
1093         std::string primaryOutput = this->ConvertToRelativeForMake(o->c_str());
1094         for(++o; o != outputs.end(); ++o)
1095           {
1096           std::string currentOutput=this->ConvertToRelativeForMake(o->c_str());
1097           multipleOutputPairs[currentOutput] = primaryOutput;
1098           }
1099         }
1100       }
1101     }
1102
1103   std::string dir = this->CurrentMakefile->GetCurrentOutputDirectory();
1104   dir += "/CMakeScripts";
1105   cmSystemTools::MakeDirectory(dir.c_str());
1106   std::string makefile = dir;
1107   makefile += "/";
1108   makefile += target.GetName();
1109   makefile += "_";
1110   makefile += name;
1111   makefile += ".make";
1112
1113   for (std::vector<std::string>::const_iterator currentConfig=
1114             this->CurrentConfigurationTypes.begin();
1115        currentConfig!=this->CurrentConfigurationTypes.end();
1116        currentConfig++ )
1117     {
1118     this->CreateCustomRulesMakefile(makefile.c_str(),
1119                                     target,
1120                                     commands,
1121                                     currentConfig->c_str(),
1122                                     multipleOutputPairs);
1123     }
1124
1125   std::string cdir = this->CurrentMakefile->GetCurrentOutputDirectory();
1126   cdir = this->ConvertToRelativeForXCode(cdir.c_str());
1127   std::string makecmd = "make -C ";
1128   makecmd += cdir;
1129   makecmd += " -f ";
1130   makecmd += this->ConvertToRelativeForMake(
1131                                           (makefile+"$CONFIGURATION").c_str());
1132   if(!multipleOutputPairs.empty())
1133     {
1134     makecmd += " cmake_check_multiple_outputs";
1135     }
1136   makecmd += " all";
1137   cmSystemTools::ReplaceString(makecmd, "\\ ", "\\\\ ");
1138   buildphase->AddAttribute("shellScript",
1139                            this->CreateString(makecmd.c_str()));
1140 }
1141
1142 //----------------------------------------------------------------------------
1143 void  cmGlobalXCodeGenerator
1144 ::CreateCustomRulesMakefile(const char* makefileBasename,
1145                             cmTarget& target,
1146                             std::vector<cmCustomCommand>
1147                             const & commands,
1148                             const char* configName,
1149                             const std::map<cmStdString,
1150                             cmStdString>& multipleOutputPairs
1151                            )
1152 {
1153   std::string makefileName=makefileBasename;
1154   makefileName+=configName;
1155   cmGeneratedFileStream makefileStream(makefileName.c_str());
1156   if(!makefileStream)
1157     {
1158     return;
1159     }
1160   makefileStream.SetCopyIfDifferent(true);
1161   makefileStream << "# Generated by CMake, DO NOT EDIT\n";
1162   makefileStream << "# Custom rules for " << target.GetName() << "\n";
1163
1164   // have all depend on all outputs
1165   makefileStream << "all: ";
1166   std::map<const cmCustomCommand*, cmStdString> tname;
1167   int count = 0;
1168   for(std::vector<cmCustomCommand>::const_iterator i = commands.begin();
1169       i != commands.end(); ++i)
1170     {
1171     cmCustomCommand const& cc = *i;
1172     if(!cc.GetCommandLines().empty())
1173       {
1174       const std::vector<std::string>& outputs = cc.GetOutputs();
1175       if(!outputs.empty())
1176         {
1177         for(std::vector<std::string>::const_iterator o = outputs.begin();
1178             o != outputs.end(); ++o)
1179           {
1180           makefileStream
1181               << "\\\n\t" << this->ConvertToRelativeForMake(o->c_str());
1182           }
1183         }
1184       else
1185         {
1186         cmOStringStream str;
1187         str << "_buildpart_" << count++ ;
1188         tname[&cc] = std::string(target.GetName()) + str.str();
1189         makefileStream << "\\\n\t" << tname[&cc];
1190         }
1191       }
1192     }
1193   makefileStream << "\n\n";
1194   for(std::vector<cmCustomCommand>::const_iterator i = commands.begin();
1195       i != commands.end(); ++i)
1196     {
1197     cmCustomCommand const& cc = *i;
1198     if(!cc.GetCommandLines().empty())
1199       {
1200       bool escapeOldStyle = cc.GetEscapeOldStyle();
1201       bool escapeAllowMakeVars = cc.GetEscapeAllowMakeVars();
1202       makefileStream << "\n";
1203       const std::vector<std::string>& outputs = cc.GetOutputs();
1204       if(!outputs.empty())
1205         {
1206         // There is at least one output, start the rule for it
1207         std::string primary_output =
1208             this->ConvertToRelativeForMake(outputs.begin()->c_str());
1209         makefileStream << primary_output << ": ";
1210         }
1211       else
1212         {
1213         // There are no outputs.  Use the generated force rule name.
1214         makefileStream << tname[&cc] << ": ";
1215         }
1216       for(std::vector<std::string>::const_iterator d =
1217           cc.GetDepends().begin();
1218           d != cc.GetDepends().end(); ++d)
1219         {
1220         std::string dep =
1221           this->CurrentLocalGenerator->GetRealDependency(d->c_str(),
1222                                                          configName);
1223         makefileStream << "\\\n" << this
1224           ->ConvertToRelativeForMake(dep.c_str());
1225         }
1226       makefileStream << "\n";
1227
1228       if(const char* comment = cc.GetComment())
1229         {
1230         std::string echo_cmd = "echo ";
1231         echo_cmd += (this->CurrentLocalGenerator->
1232                      EscapeForShell(comment, escapeAllowMakeVars));
1233         makefileStream << "\t" << echo_cmd.c_str() << "\n";
1234         }
1235
1236       // Add each command line to the set of commands.
1237       for(cmCustomCommandLines::const_iterator cl =
1238           cc.GetCommandLines().begin();
1239           cl != cc.GetCommandLines().end(); ++cl)
1240         {
1241         // Build the command line in a single string.
1242         const cmCustomCommandLine& commandLine = *cl;
1243         std::string cmd2 = this->CurrentLocalGenerator
1244                          ->GetRealLocation(commandLine[0].c_str(), configName);
1245
1246         cmSystemTools::ReplaceString(cmd2, "/./", "/");
1247         cmd2 = this->ConvertToRelativeForMake(cmd2.c_str());
1248         std::string cmd;
1249         if(cc.GetWorkingDirectory())
1250           {
1251           cmd += "cd ";
1252           cmd += this->ConvertToRelativeForMake(cc.GetWorkingDirectory());
1253           cmd += " && ";
1254           }
1255         cmd += cmd2;
1256         for(unsigned int j=1; j < commandLine.size(); ++j)
1257           {
1258           cmd += " ";
1259           if(escapeOldStyle)
1260             {
1261             cmd += (this->CurrentLocalGenerator
1262                 ->EscapeForShellOldStyle(commandLine[j].c_str()));
1263             }
1264           else
1265             {
1266             cmd += (this->CurrentLocalGenerator->
1267                 EscapeForShell(commandLine[j].c_str(),
1268                                escapeAllowMakeVars));
1269             }
1270           }
1271         makefileStream << "\t" << cmd.c_str() << "\n";
1272         }
1273       }
1274     }
1275
1276   // Add rules to deal with multiple outputs of custom commands.
1277   if(!multipleOutputPairs.empty())
1278     {
1279     makefileStream <<
1280         "\n# Dependencies of multiple outputs to their primary outputs \n";
1281
1282     for(std::map<cmStdString, cmStdString>::const_iterator o =
1283         multipleOutputPairs.begin(); o != multipleOutputPairs.end(); ++o)
1284       {
1285       makefileStream << o->first << ": " << o->second << "\n";
1286       }
1287
1288     makefileStream <<
1289         "\n"
1290         "cmake_check_multiple_outputs:\n";
1291     for(std::map<cmStdString, cmStdString>::const_iterator o =
1292         multipleOutputPairs.begin(); o != multipleOutputPairs.end(); ++o)
1293       {
1294       makefileStream << "\t@if [ ! -f "
1295           << o->first << " ]; then rm -f "
1296           << o->second << "; fi\n";
1297       }
1298     }
1299 }
1300
1301 //----------------------------------------------------------------------------
1302 void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
1303                                                  cmXCodeObject* buildSettings,
1304                                                  std::string& fileType,
1305                                                  std::string& productType,
1306                                                  std::string& productName,
1307                                                  const char* configName)
1308 {
1309   std::string flags;
1310   std::string defFlags;
1311   bool shared = ((target.GetType() == cmTarget::SHARED_LIBRARY) ||
1312                  (target.GetType() == cmTarget::MODULE_LIBRARY));
1313
1314   const char* lang = target.GetLinkerLanguage(this);
1315   std::string cflags;
1316   if(lang)
1317     {
1318     // for c++ projects get the c flags as well
1319     if(strcmp(lang, "CXX") == 0)
1320       {
1321       this->CurrentLocalGenerator->AddLanguageFlags(cflags, "C", configName);
1322       this->CurrentLocalGenerator->AddSharedFlags(cflags, lang, shared);
1323       }
1324
1325     // Add language-specific flags.
1326     this->CurrentLocalGenerator->AddLanguageFlags(flags, lang, configName);
1327
1328     // Add shared-library flags if needed.
1329     this->CurrentLocalGenerator->AddSharedFlags(flags, lang, shared);
1330     }
1331
1332   // Add define flags
1333   this->CurrentLocalGenerator->
1334     AppendFlags(defFlags,
1335                 this->CurrentMakefile->GetDefineFlags());
1336
1337   // Add preprocessor definitions for this target and configuration.
1338   std::string ppDefs;
1339   if(this->XcodeVersion > 15)
1340     {
1341     this->AppendDefines(ppDefs, "CMAKE_INTDIR=\"$(CONFIGURATION)\"");
1342     }
1343   if(const char* exportMacro = target.GetExportMacro())
1344     {
1345     // Add the export symbol definition for shared library objects.
1346     this->AppendDefines(ppDefs, exportMacro);
1347     }
1348   this->AppendDefines
1349     (ppDefs, this->CurrentMakefile->GetProperty("COMPILE_DEFINITIONS"));
1350   this->AppendDefines(ppDefs, target.GetProperty("COMPILE_DEFINITIONS"));
1351   if(configName)
1352     {
1353     std::string defVarName = "COMPILE_DEFINITIONS_";
1354     defVarName += cmSystemTools::UpperCase(configName);
1355     this->AppendDefines
1356       (ppDefs, this->CurrentMakefile->GetProperty(defVarName.c_str()));
1357     this->AppendDefines(ppDefs, target.GetProperty(defVarName.c_str()));
1358     }
1359   buildSettings->AddAttribute
1360     ("GCC_PREPROCESSOR_DEFINITIONS", this->CreateString(ppDefs.c_str()));
1361
1362   std::string extraLinkOptions;
1363   if(target.GetType() == cmTarget::EXECUTABLE)
1364     {
1365     extraLinkOptions =
1366       this->CurrentMakefile->GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS");
1367     }
1368   if(target.GetType() == cmTarget::SHARED_LIBRARY)
1369     {
1370     extraLinkOptions = this->CurrentMakefile->
1371       GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS");
1372     }
1373   if(target.GetType() == cmTarget::MODULE_LIBRARY)
1374     {
1375     extraLinkOptions = this->CurrentMakefile->
1376       GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS");
1377     }
1378
1379   const char* targetLinkFlags = target.GetProperty("LINK_FLAGS");
1380   if(targetLinkFlags)
1381     {
1382     extraLinkOptions += " ";
1383     extraLinkOptions += targetLinkFlags;
1384     }
1385
1386   // The product name is the full name of the target for this configuration.
1387   productName = target.GetFullName(configName);
1388
1389   // Get the product name components.
1390   std::string pnprefix;
1391   std::string pnbase;
1392   std::string pnsuffix;
1393   target.GetFullNameComponents(pnprefix, pnbase, pnsuffix, configName);
1394
1395   // Store the product name for all target types.
1396   buildSettings->AddAttribute("PRODUCT_NAME",
1397                               this->CreateString(pnbase.c_str()));
1398
1399   // Set attributes to specify the proper name for the target.
1400   if(target.GetType() == cmTarget::STATIC_LIBRARY ||
1401      target.GetType() == cmTarget::SHARED_LIBRARY ||
1402      target.GetType() == cmTarget::MODULE_LIBRARY ||
1403      target.GetType() == cmTarget::EXECUTABLE)
1404     {
1405     std::string pndir = target.GetDirectory();
1406     buildSettings->AddAttribute("SYMROOT",
1407                                 this->CreateString(pndir.c_str()));
1408     buildSettings->AddAttribute("EXECUTABLE_PREFIX",
1409                                 this->CreateString(pnprefix.c_str()));
1410     buildSettings->AddAttribute("EXECUTABLE_SUFFIX",
1411                                 this->CreateString(pnsuffix.c_str()));
1412     }
1413
1414   // Handle settings for each target type.
1415   switch(target.GetType())
1416     {
1417     case cmTarget::STATIC_LIBRARY:
1418     {
1419     fileType = "archive.ar";
1420     productType = "com.apple.product-type.library.static";
1421
1422     buildSettings->AddAttribute("LIBRARY_STYLE",
1423                                 this->CreateString("STATIC"));
1424     break;
1425     }
1426
1427     case cmTarget::MODULE_LIBRARY:
1428     {
1429     buildSettings->AddAttribute("LIBRARY_STYLE",
1430                                 this->CreateString("BUNDLE"));
1431     if(this->XcodeVersion >= 22)
1432       {
1433       fileType = "compiled.mach-o.executable";
1434       productType = "com.apple.product-type.tool";
1435
1436       buildSettings->AddAttribute("MACH_O_TYPE",
1437                                   this->CreateString("mh_bundle"));
1438       buildSettings->AddAttribute("GCC_DYNAMIC_NO_PIC",
1439                                   this->CreateString("NO"));
1440       // Add the flags to create an executable.
1441       std::string createFlags =
1442         this->LookupFlags("CMAKE_", lang, "_LINK_FLAGS", "");
1443       if(!createFlags.empty())
1444         {
1445         extraLinkOptions += " ";
1446         extraLinkOptions += createFlags;
1447         }
1448       }
1449     else
1450       {
1451       fileType = "compiled.mach-o.dylib";
1452       productType = "com.apple.product-type.library.dynamic";
1453
1454       // Add the flags to create a module.
1455       std::string createFlags =
1456         this->LookupFlags("CMAKE_SHARED_MODULE_CREATE_", lang, "_FLAGS",
1457                           "-bundle");
1458       if(!createFlags.empty())
1459         {
1460         extraLinkOptions += " ";
1461         extraLinkOptions += createFlags;
1462         }
1463       }
1464     break;
1465     }
1466     case cmTarget::SHARED_LIBRARY:
1467     {
1468     if(target.GetPropertyAsBool("FRAMEWORK"))
1469       {
1470       fileType = "wrapper.framework";
1471       productType = "com.apple.product-type.framework";
1472
1473       std::string version = target.GetFrameworkVersion();
1474       buildSettings->AddAttribute("FRAMEWORK_VERSION",
1475                                   this->CreateString(version.c_str()));
1476
1477       std::string plist = this->ComputeInfoPListLocation(target);
1478       // Xcode will create the final version of Info.plist at build time,
1479       // so let it replace the framework name.  This avoids creating
1480       // a per-configuration Info.plist file.
1481       this->CurrentLocalGenerator
1482         ->GenerateFrameworkInfoPList(&target, "$(EXECUTABLE_NAME)",
1483                                      plist.c_str());
1484       std::string path =
1485         this->ConvertToRelativeForXCode(plist.c_str());
1486       buildSettings->AddAttribute("INFOPLIST_FILE",
1487                                   this->CreateString(path.c_str()));
1488       }
1489     else
1490       {
1491       fileType = "compiled.mach-o.dylib";
1492       productType = "com.apple.product-type.library.dynamic";
1493
1494       // Add the flags to create a shared library.
1495       std::string createFlags =
1496         this->LookupFlags("CMAKE_SHARED_LIBRARY_CREATE_", lang, "_FLAGS",
1497                           "-dynamiclib");
1498       if(!createFlags.empty())
1499         {
1500         extraLinkOptions += " ";
1501         extraLinkOptions += createFlags;
1502         }
1503       }
1504
1505     buildSettings->AddAttribute("LIBRARY_STYLE",
1506                                 this->CreateString("DYNAMIC"));
1507     break;
1508     }
1509     case cmTarget::EXECUTABLE:
1510     {
1511     fileType = "compiled.mach-o.executable";
1512
1513     // Add the flags to create an executable.
1514     std::string createFlags =
1515       this->LookupFlags("CMAKE_", lang, "_LINK_FLAGS", "");
1516     if(!createFlags.empty())
1517       {
1518       extraLinkOptions += " ";
1519       extraLinkOptions += createFlags;
1520       }
1521
1522     // Handle bundles and normal executables separately.
1523     if(target.GetPropertyAsBool("MACOSX_BUNDLE"))
1524       {
1525       productType = "com.apple.product-type.application";
1526       std::string plist = this->ComputeInfoPListLocation(target);
1527       // Xcode will create the final version of Info.plist at build time,
1528       // so let it replace the executable name.  This avoids creating
1529       // a per-configuration Info.plist file.
1530       this->CurrentLocalGenerator
1531         ->GenerateAppleInfoPList(&target, "$(EXECUTABLE_NAME)",
1532                                  plist.c_str());
1533       std::string path =
1534         this->ConvertToRelativeForXCode(plist.c_str());
1535       buildSettings->AddAttribute("INFOPLIST_FILE",
1536                                   this->CreateString(path.c_str()));
1537
1538       }
1539     else
1540       {
1541       productType = "com.apple.product-type.tool";
1542       }
1543     }
1544     break;
1545     default:
1546       break;
1547     }
1548   if(this->XcodeVersion >= 22)
1549     {
1550     buildSettings->AddAttribute("PREBINDING",
1551                                 this->CreateString("NO"));
1552     }
1553   std::string dirs;
1554   std::vector<std::string> includes;
1555   this->CurrentLocalGenerator->GetIncludeDirectories(includes);
1556   std::string fdirs;
1557   std::set<cmStdString> emitted;
1558   emitted.insert("/System/Library/Frameworks");
1559   for(std::vector<std::string>::iterator i = includes.begin();
1560       i != includes.end(); ++i)
1561     {
1562     if(this->NameResolvesToFramework(i->c_str()))
1563       {
1564       std::string frameworkDir = *i;
1565       frameworkDir += "/../";
1566       frameworkDir = cmSystemTools::CollapseFullPath(frameworkDir.c_str());
1567       if(emitted.insert(frameworkDir).second)
1568         {
1569         fdirs += this->XCodeEscapePath(frameworkDir.c_str());
1570         fdirs += " ";
1571         }
1572       }
1573     else
1574       {
1575       std::string incpath =
1576         this->XCodeEscapePath(i->c_str());
1577       dirs += incpath + " ";
1578       }
1579     }
1580   std::vector<std::string>& frameworks = target.GetFrameworks();
1581   if(frameworks.size())
1582     {
1583     for(std::vector<std::string>::iterator fmIt = frameworks.begin();
1584         fmIt != frameworks.end(); ++fmIt)
1585       {
1586       if(emitted.insert(*fmIt).second)
1587         {
1588         fdirs += this->XCodeEscapePath(fmIt->c_str());
1589         fdirs += " ";
1590         }
1591       }
1592     }
1593   if(fdirs.size())
1594     {
1595     buildSettings->AddAttribute("FRAMEWORK_SEARCH_PATHS",
1596                                 this->CreateString(fdirs.c_str()));
1597     }
1598   if(dirs.size())
1599     {
1600     buildSettings->AddAttribute("HEADER_SEARCH_PATHS",
1601                                 this->CreateString(dirs.c_str()));
1602     }
1603   std::string oflagc = this->ExtractFlag("-O", cflags);
1604   char optLevel[2];
1605   optLevel[0] = '0';
1606   optLevel[1] = 0;
1607   if(oflagc.size() == 3)
1608     {
1609     optLevel[0] = oflagc[2];
1610     }
1611   if(oflagc.size() == 2)
1612     {
1613     optLevel[0] = '1';
1614     }
1615   std::string oflag = this->ExtractFlag("-O", flags);
1616   if(oflag.size() == 3)
1617     {
1618     optLevel[0] = oflag[2];
1619     }
1620   if(oflag.size() == 2)
1621     {
1622     optLevel[0] = '1';
1623     }
1624   std::string gflagc = this->ExtractFlag("-g", cflags);
1625   // put back gdwarf-2 if used since there is no way
1626   // to represent it in the gui, but we still want debug yes
1627   if(gflagc == "-gdwarf-2")
1628     {
1629     cflags += " ";
1630     cflags += gflagc;
1631     }
1632   std::string gflag = this->ExtractFlag("-g", flags);
1633   if(gflag == "-gdwarf-2")
1634     {
1635     flags += " ";
1636     flags += gflag;
1637     }
1638   const char* debugStr = "YES";
1639   if(gflagc.size() ==0  && gflag.size() == 0)
1640     {
1641     debugStr = "NO";
1642     }
1643
1644   buildSettings->AddAttribute("GCC_GENERATE_DEBUGGING_SYMBOLS",
1645                               this->CreateString(debugStr));
1646   buildSettings->AddAttribute("GCC_OPTIMIZATION_LEVEL",
1647                               this->CreateString(optLevel));
1648   buildSettings->AddAttribute("GCC_SYMBOLS_PRIVATE_EXTERN",
1649                               this->CreateString("NO"));
1650   buildSettings->AddAttribute("GCC_INLINES_ARE_PRIVATE_EXTERN",
1651                               this->CreateString("NO"));
1652   if(lang && strcmp(lang, "CXX") == 0)
1653     {
1654     flags += " ";
1655     flags += defFlags;
1656     buildSettings->AddAttribute("OTHER_CPLUSPLUSFLAGS",
1657                                 this->CreateString(flags.c_str()));
1658     cflags += " ";
1659     cflags += defFlags;
1660     buildSettings->AddAttribute("OTHER_CFLAGS",
1661                                 this->CreateString(cflags.c_str()));
1662
1663     }
1664   else
1665     {
1666     flags += " ";
1667     flags += defFlags;
1668     buildSettings->AddAttribute("OTHER_CFLAGS",
1669                                 this->CreateString(flags.c_str()));
1670     }
1671
1672   // Create the INSTALL_PATH attribute.
1673   std::string install_name_dir;
1674   if(target.GetType() == cmTarget::SHARED_LIBRARY)
1675     {
1676     // Get the install_name directory for the build tree.
1677     install_name_dir = target.GetInstallNameDirForBuildTree(configName, true);
1678     if(install_name_dir.empty())
1679       {
1680       // Xcode will not pass the -install_name option at all if INSTALL_PATH
1681       // is not given or is empty.  We must explicitly put the flag in the
1682       // link flags to create an install_name with just the library soname.
1683       extraLinkOptions += " -install_name ";
1684       extraLinkOptions += productName;
1685       }
1686     else
1687       {
1688       // Convert to a path for the native build tool.
1689       cmSystemTools::ConvertToUnixSlashes(install_name_dir);
1690       // do not escape spaces on this since it is only a single path
1691       }
1692     }
1693   buildSettings->AddAttribute("INSTALL_PATH",
1694                               this->CreateString(install_name_dir.c_str()));
1695
1696   buildSettings->AddAttribute("OTHER_LDFLAGS",
1697                               this->CreateString(extraLinkOptions.c_str()));
1698   buildSettings->AddAttribute("OTHER_REZFLAGS",
1699                               this->CreateString(""));
1700   buildSettings->AddAttribute("SECTORDER_FLAGS",
1701                               this->CreateString(""));
1702   buildSettings->AddAttribute("USE_HEADERMAP",
1703                               this->CreateString("NO"));
1704   buildSettings->AddAttribute("WARNING_CFLAGS",
1705                               this->CreateString(
1706                                 "-Wmost -Wno-four-char-constants"
1707                                 " -Wno-unknown-pragmas"));
1708
1709   // Runtime version information.
1710   if(target.GetType() == cmTarget::SHARED_LIBRARY)
1711     {
1712     int major;
1713     int minor;
1714     int patch;
1715
1716     // VERSION -> current_version
1717     target.GetTargetVersion(false, major, minor, patch);
1718     if(major == 0 && minor == 0 && patch == 0)
1719       {
1720       // Xcode always wants at least 1.0.0
1721       major = 1;
1722       }
1723     cmOStringStream v;
1724     v << major << "." << minor << "." << patch;
1725     buildSettings->AddAttribute("DYLIB_CURRENT_VERSION",
1726                                 this->CreateString(v.str().c_str()));
1727
1728     // SOVERSION -> compatibility_version
1729     target.GetTargetVersion(true, major, minor, patch);
1730     if(major == 0 && minor == 0 && patch == 0)
1731       {
1732       // Xcode always wants at least 1.0.0
1733       major = 1;
1734       }
1735     cmOStringStream vso;
1736     vso << major << "." << minor << "." << patch;
1737     buildSettings->AddAttribute("DYLIB_COMPATIBILITY_VERSION",
1738                                 this->CreateString(vso.str().c_str()));
1739     }
1740   // put this last so it can override existing settings
1741   // Convert "XCODE_ATTRIBUTE_*" properties directly.
1742   {
1743   cmPropertyMap const& props = target.GetProperties();
1744   for(cmPropertyMap::const_iterator i = props.begin();
1745       i != props.end(); ++i)
1746     {
1747     if(i->first.find("XCODE_ATTRIBUTE_") == 0)
1748       {
1749       buildSettings->AddAttribute(i->first.substr(16).c_str(),
1750                                   this->CreateString(i->second.GetValue()));
1751       }
1752     }
1753   }
1754 }
1755
1756 //----------------------------------------------------------------------------
1757 cmXCodeObject*
1758 cmGlobalXCodeGenerator::CreateUtilityTarget(cmTarget& cmtarget)
1759 {
1760   cmXCodeObject* shellBuildPhase =
1761     this->CreateObject(cmXCodeObject::PBXShellScriptBuildPhase);
1762   shellBuildPhase->AddAttribute("buildActionMask",
1763                                 this->CreateString("2147483647"));
1764   cmXCodeObject* buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
1765   shellBuildPhase->AddAttribute("files", buildFiles);
1766   cmXCodeObject* inputPaths = this->CreateObject(cmXCodeObject::OBJECT_LIST);
1767   shellBuildPhase->AddAttribute("inputPaths", inputPaths);
1768   cmXCodeObject* outputPaths = this->CreateObject(cmXCodeObject::OBJECT_LIST);
1769   shellBuildPhase->AddAttribute("outputPaths", outputPaths);
1770   shellBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
1771                                 this->CreateString("0"));
1772   shellBuildPhase->AddAttribute("shellPath",
1773                                 this->CreateString("/bin/sh"));
1774   shellBuildPhase->AddAttribute("shellScript",
1775                                 this->CreateString(
1776                                   "# shell script goes here\nexit 0"));
1777   cmXCodeObject* target =
1778     this->CreateObject(cmXCodeObject::PBXAggregateTarget);
1779   target->SetComment(cmtarget.GetName());
1780   cmXCodeObject* buildPhases =
1781     this->CreateObject(cmXCodeObject::OBJECT_LIST);
1782   std::vector<cmXCodeObject*> emptyContentVector;
1783   this->CreateCustomCommands(buildPhases, 0, 0, 0, emptyContentVector, 0,
1784                              cmtarget);
1785   target->AddAttribute("buildPhases", buildPhases);
1786   cmXCodeObject* buildSettings =
1787     this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
1788   std::string fileTypeString;
1789   std::string productTypeString;
1790   std::string productName;
1791   const char* globalConfig = 0;
1792   if(this->XcodeVersion > 20)
1793     {
1794     this->AddConfigurations(target, cmtarget);
1795     }
1796   else
1797     {
1798     globalConfig = this->CurrentMakefile->GetDefinition("CMAKE_BUILD_TYPE");
1799     }
1800   this->CreateBuildSettings(cmtarget,
1801                             buildSettings, fileTypeString,
1802                             productTypeString, productName, globalConfig);
1803   target->AddAttribute("buildSettings", buildSettings);
1804   cmXCodeObject* dependencies =
1805     this->CreateObject(cmXCodeObject::OBJECT_LIST);
1806   target->AddAttribute("dependencies", dependencies);
1807   target->AddAttribute("name", this->CreateString(productName.c_str()));
1808   target->AddAttribute("productName",this->CreateString(productName.c_str()));
1809   target->SetTarget(&cmtarget);
1810
1811   // Add source files without build rules for editing convenience.
1812   if(cmtarget.GetType() == cmTarget::UTILITY)
1813     {
1814     std::vector<cmSourceFile*> const& sources = cmtarget.GetSourceFiles();
1815     for(std::vector<cmSourceFile*>::const_iterator i = sources.begin();
1816         i != sources.end(); ++i)
1817       {
1818       if(!(*i)->GetPropertyAsBool("GENERATED"))
1819         {
1820         this->CreateXCodeFileReference(*i, cmtarget);
1821         }
1822       }
1823     }
1824
1825   return target;
1826 }
1827
1828 //----------------------------------------------------------------------------
1829 void cmGlobalXCodeGenerator::AddConfigurations(cmXCodeObject* target,
1830                                                cmTarget& cmtarget)
1831 {
1832   std::string configTypes =
1833     this->CurrentMakefile->GetRequiredDefinition("CMAKE_CONFIGURATION_TYPES");
1834   std::vector<std::string> configVectorIn;
1835   std::vector<std::string> configVector;
1836   configVectorIn.push_back(configTypes);
1837   cmSystemTools::ExpandList(configVectorIn, configVector);
1838   cmXCodeObject* configlist =
1839     this->CreateObject(cmXCodeObject::XCConfigurationList);
1840   cmXCodeObject* buildConfigurations =
1841     this->CreateObject(cmXCodeObject::OBJECT_LIST);
1842   configlist->AddAttribute("buildConfigurations", buildConfigurations);
1843   std::string comment = "Build configuration list for ";
1844   comment += cmXCodeObject::PBXTypeNames[target->GetIsA()];
1845   comment += " \"";
1846   comment += cmtarget.GetName();
1847   comment += "\"";
1848   configlist->SetComment(comment.c_str());
1849   target->AddAttribute("buildConfigurationList",
1850                        this->CreateObjectReference(configlist));
1851   for(unsigned int i = 0; i < configVector.size(); ++i)
1852     {
1853     cmXCodeObject* config =
1854       this->CreateObject(cmXCodeObject::XCBuildConfiguration);
1855     buildConfigurations->AddObject(config);
1856     cmXCodeObject* buildSettings =
1857       this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
1858     std::string fileTypeString;
1859     std::string productTypeString;
1860     std::string productName;
1861     this->CreateBuildSettings(cmtarget,
1862                               buildSettings, fileTypeString,
1863                               productTypeString, productName,
1864                               configVector[i].c_str());
1865     config->AddAttribute("name", this->CreateString(configVector[i].c_str()));
1866     config->SetComment(configVector[i].c_str());
1867     config->AddAttribute("buildSettings", buildSettings);
1868     }
1869   if(configVector.size())
1870     {
1871     configlist->AddAttribute("defaultConfigurationName",
1872                              this->CreateString(configVector[0].c_str()));
1873     configlist->AddAttribute("defaultConfigurationIsVisible",
1874                              this->CreateString("0"));
1875     }
1876 }
1877
1878 //----------------------------------------------------------------------------
1879 cmXCodeObject*
1880 cmGlobalXCodeGenerator::CreateXCodeTarget(cmTarget& cmtarget,
1881                                           cmXCodeObject* buildPhases)
1882 {
1883   cmXCodeObject* target =
1884     this->CreateObject(cmXCodeObject::PBXNativeTarget);
1885   target->AddAttribute("buildPhases", buildPhases);
1886   cmXCodeObject* buildRules = this->CreateObject(cmXCodeObject::OBJECT_LIST);
1887   target->AddAttribute("buildRules", buildRules);
1888   cmXCodeObject* buildSettings =
1889     this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
1890   std::string fileTypeString;
1891   std::string productTypeString;
1892   std::string productName;
1893   const char* globalConfig = 0;
1894   if(this->XcodeVersion > 20)
1895     {
1896     this->AddConfigurations(target, cmtarget);
1897     }
1898   else
1899     {
1900     globalConfig = this->CurrentMakefile->GetDefinition("CMAKE_BUILD_TYPE");
1901     }
1902   this->CreateBuildSettings(cmtarget,
1903                             buildSettings, fileTypeString,
1904                             productTypeString, productName, globalConfig);
1905   target->AddAttribute("buildSettings", buildSettings);
1906   cmXCodeObject* dependencies =
1907     this->CreateObject(cmXCodeObject::OBJECT_LIST);
1908   target->AddAttribute("dependencies", dependencies);
1909   target->AddAttribute("name", this->CreateString(productName.c_str()));
1910   target->AddAttribute("productName",this->CreateString(productName.c_str()));
1911
1912   cmXCodeObject* fileRef =
1913     this->CreateObject(cmXCodeObject::PBXFileReference);
1914   fileRef->AddAttribute("explicitFileType",
1915                         this->CreateString(fileTypeString.c_str()));
1916   fileRef->AddAttribute("path", this->CreateString(productName.c_str()));
1917   fileRef->AddAttribute("refType", this->CreateString("0"));
1918   fileRef->AddAttribute("sourceTree",
1919                         this->CreateString("BUILT_PRODUCTS_DIR"));
1920   fileRef->SetComment(cmtarget.GetName());
1921   target->AddAttribute("productReference",
1922                        this->CreateObjectReference(fileRef));
1923   target->AddAttribute("productType",
1924                        this->CreateString(productTypeString.c_str()));
1925   target->SetTarget(&cmtarget);
1926   return target;
1927 }
1928
1929 //----------------------------------------------------------------------------
1930 cmXCodeObject* cmGlobalXCodeGenerator::FindXCodeTarget(cmTarget* t)
1931 {
1932   if(!t)
1933     {
1934     return 0;
1935     }
1936   for(std::vector<cmXCodeObject*>::iterator i = this->XCodeObjects.begin();
1937       i != this->XCodeObjects.end(); ++i)
1938     {
1939     cmXCodeObject* o = *i;
1940     if(o->GetTarget() == t)
1941       {
1942       return o;
1943       }
1944     }
1945   return 0;
1946 }
1947
1948 //----------------------------------------------------------------------------
1949 void cmGlobalXCodeGenerator::AddDependTarget(cmXCodeObject* target,
1950                                              cmXCodeObject* dependTarget)
1951 {
1952   // make sure a target does not depend on itself
1953   if(target == dependTarget)
1954     {
1955     return;
1956     }
1957   // now avoid circular references if dependTarget already
1958   // depends on target then skip it.  Circular references crashes
1959   // xcode
1960   cmXCodeObject* dependTargetDepends =
1961     dependTarget->GetObject("dependencies");
1962   if(dependTargetDepends)
1963     {
1964     if(dependTargetDepends->HasObject(target->GetPBXTargetDependency()))
1965       {
1966       return;
1967       }
1968     }
1969
1970   cmXCodeObject* targetdep = dependTarget->GetPBXTargetDependency();
1971   if(!targetdep)
1972     {
1973     cmXCodeObject* container =
1974       this->CreateObject(cmXCodeObject::PBXContainerItemProxy);
1975     container->SetComment("PBXContainerItemProxy");
1976     container->AddAttribute("containerPortal",
1977                             this->CreateObjectReference(this->RootObject));
1978     container->AddAttribute("proxyType", this->CreateString("1"));
1979     container->AddAttribute("remoteGlobalIDString",
1980                             this->CreateObjectReference(dependTarget));
1981     container->AddAttribute("remoteInfo",
1982                             this->CreateString(
1983                               dependTarget->GetTarget()->GetName()));
1984     targetdep =
1985       this->CreateObject(cmXCodeObject::PBXTargetDependency);
1986     targetdep->SetComment("PBXTargetDependency");
1987     targetdep->AddAttribute("target",
1988                             this->CreateObjectReference(dependTarget));
1989     targetdep->AddAttribute("targetProxy",
1990                             this->CreateObjectReference(container));
1991     dependTarget->SetPBXTargetDependency(targetdep);
1992     }
1993
1994   cmXCodeObject* depends = target->GetObject("dependencies");
1995   if(!depends)
1996     {
1997     cmSystemTools::
1998       Error("target does not have dependencies attribute error..");
1999
2000     }
2001   else
2002     {
2003     depends->AddUniqueObject(targetdep);
2004     }
2005 }
2006
2007 //----------------------------------------------------------------------------
2008 void cmGlobalXCodeGenerator::AppendOrAddBuildSetting(cmXCodeObject* settings,
2009                                                      const char* attribute,
2010                                                      const char* value)
2011 {
2012   if(settings)
2013     {
2014     cmXCodeObject* attr = settings->GetObject(attribute);
2015     if(!attr)
2016       {
2017       settings->AddAttribute(attribute, this->CreateString(value));
2018       }
2019     else
2020       {
2021       std::string oldValue = attr->GetString();
2022       oldValue += " ";
2023       oldValue += value;
2024       attr->SetString(oldValue.c_str());
2025       }
2026     }
2027 }
2028
2029 //----------------------------------------------------------------------------
2030 void cmGlobalXCodeGenerator
2031 ::AppendBuildSettingAttribute(cmXCodeObject* target,
2032                               const char* attribute,
2033                               const char* value,
2034                               const char* configName)
2035 {
2036   if(this->XcodeVersion < 21)
2037     {
2038     // There is only one configuration.  Add the setting to the buildSettings
2039     // of the target.
2040     this->AppendOrAddBuildSetting(target->GetObject("buildSettings"),
2041                                   attribute, value);
2042     }
2043   else
2044     {
2045     // There are multiple configurations.  Add the setting to the
2046     // buildSettings of the configuration name given.
2047     cmXCodeObject* configurationList =
2048       target->GetObject("buildConfigurationList")->GetObject();
2049     cmXCodeObject* buildConfigs =
2050       configurationList->GetObject("buildConfigurations");
2051     std::vector<cmXCodeObject*> list = buildConfigs->GetObjectList();
2052     // each configuration and the target itself has a buildSettings in it
2053     //list.push_back(target);
2054     for(std::vector<cmXCodeObject*>::iterator i = list.begin();
2055         i != list.end(); ++i)
2056       {
2057       if(configName)
2058         {
2059         if(strcmp((*i)->GetObject("name")->GetString(), configName) == 0)
2060           {
2061           cmXCodeObject* settings = (*i)->GetObject("buildSettings");
2062           this->AppendOrAddBuildSetting(settings, attribute, value);
2063           }
2064         }
2065       else
2066         {
2067         cmXCodeObject* settings = (*i)->GetObject("buildSettings");
2068         this->AppendOrAddBuildSetting(settings, attribute, value);
2069         }
2070       }
2071     }
2072 }
2073
2074 //----------------------------------------------------------------------------
2075 void cmGlobalXCodeGenerator
2076 ::AddDependAndLinkInformation(cmXCodeObject* target)
2077 {
2078   cmTarget* cmtarget = target->GetTarget();
2079   if(!cmtarget)
2080     {
2081     cmSystemTools::Error("Error no target on xobject\n");
2082     return;
2083     }
2084
2085   // Add dependencies on other CMake targets.
2086   TargetDependSet const& deps = this->GetTargetDirectDepends(*cmtarget);
2087   for(TargetDependSet::const_iterator i = deps.begin(); i != deps.end(); ++i)
2088     {
2089     if(cmXCodeObject* dptarget = this->FindXCodeTarget(*i))
2090       {
2091       this->AddDependTarget(target, dptarget);
2092       }
2093     }
2094
2095   // Skip link information for static libraries.
2096   if(cmtarget->GetType() == cmTarget::STATIC_LIBRARY)
2097     {
2098     return;
2099     }
2100
2101   // Loop over configuration types and set per-configuration info.
2102   for(std::vector<std::string>::iterator i =
2103         this->CurrentConfigurationTypes.begin();
2104       i != this->CurrentConfigurationTypes.end(); ++i)
2105     {
2106     // Get the current configuration name.
2107     const char* configName = i->c_str();
2108     if(!*configName)
2109       {
2110       configName = 0;
2111       }
2112
2113     // Compute the link library and directory information.
2114     cmComputeLinkInformation* pcli = cmtarget->GetLinkInformation(configName);
2115     if(!pcli)
2116       {
2117       continue;
2118       }
2119     cmComputeLinkInformation& cli = *pcli;
2120
2121     // Add dependencies directly on library files.
2122     {
2123     std::vector<std::string> const& libDeps = cli.GetDepends();
2124     for(std::vector<std::string>::const_iterator j = libDeps.begin();
2125         j != libDeps.end(); ++j)
2126       {
2127       target->AddDependLibrary(configName, j->c_str());
2128       }
2129     }
2130
2131     // add the library search paths
2132     {
2133     std::vector<std::string> const& libDirs = cli.GetDirectories();
2134     std::string linkDirs;
2135     for(std::vector<std::string>::const_iterator libDir = libDirs.begin();
2136         libDir != libDirs.end(); ++libDir)
2137       {
2138       if(libDir->size() && *libDir != "/usr/lib")
2139         {
2140         if(this->XcodeVersion > 15)
2141           {
2142           // now add the same one but append $(CONFIGURATION) to it:
2143           linkDirs += " ";
2144           linkDirs += this->XCodeEscapePath(
2145             (*libDir + "/$(CONFIGURATION)").c_str());
2146           }
2147         linkDirs += " ";
2148         linkDirs += this->XCodeEscapePath(libDir->c_str());
2149         }
2150       }
2151     this->AppendBuildSettingAttribute(target, "LIBRARY_SEARCH_PATHS",
2152                                       linkDirs.c_str(), configName);
2153     }
2154
2155     // add the framework search paths
2156     {
2157     const char* sep = "";
2158     std::string fdirs;
2159     std::vector<std::string> const& fwDirs = cli.GetFrameworkPaths();
2160     for(std::vector<std::string>::const_iterator fdi = fwDirs.begin();
2161         fdi != fwDirs.end(); ++fdi)
2162       {
2163       fdirs += sep;
2164       sep = " ";
2165       fdirs += this->XCodeEscapePath(fdi->c_str());
2166       }
2167     if(!fdirs.empty())
2168       {
2169       this->AppendBuildSettingAttribute(target, "FRAMEWORK_SEARCH_PATHS",
2170                                         fdirs.c_str(), configName);
2171       }
2172     }
2173
2174     // now add the link libraries
2175     {
2176     std::string linkLibs;
2177     const char* sep = "";
2178     typedef cmComputeLinkInformation::ItemVector ItemVector;
2179     ItemVector const& libNames = cli.GetItems();
2180     for(ItemVector::const_iterator li = libNames.begin();
2181         li != libNames.end(); ++li)
2182       {
2183       linkLibs += sep;
2184       sep = " ";
2185       if(li->IsPath)
2186         {
2187         linkLibs += this->XCodeEscapePath(li->Value.c_str());
2188         }
2189       else
2190         {
2191         linkLibs += li->Value;
2192         }
2193       }
2194     this->AppendBuildSettingAttribute(target, "OTHER_LDFLAGS",
2195                                       linkLibs.c_str(), configName);
2196     }
2197     }
2198 }
2199
2200 //----------------------------------------------------------------------------
2201 void cmGlobalXCodeGenerator::CreateGroups(cmLocalGenerator* root,
2202                                           std::vector<cmLocalGenerator*>&
2203                                           generators)
2204 {
2205   for(std::vector<cmLocalGenerator*>::iterator i = generators.begin();
2206       i != generators.end(); ++i)
2207     {
2208     if(this->IsExcluded(root, *i))
2209       {
2210       continue;
2211       }
2212     cmMakefile* mf = (*i)->GetMakefile();
2213     std::vector<cmSourceGroup> sourceGroups = mf->GetSourceGroups();
2214     cmTargets &tgts = mf->GetTargets();
2215     for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); l++)
2216       {
2217       cmTarget& cmtarget = l->second;
2218
2219       // Same skipping logic here as in CreateXCodeTargets so that we do not
2220       // end up with (empty anyhow) ALL_BUILD and XCODE_DEPEND_HELPER source
2221       // groups:
2222       //
2223       if(cmtarget.GetType() == cmTarget::GLOBAL_TARGET)
2224         {
2225         continue;
2226         }
2227
2228       // add the soon to be generated Info.plist file as a source for a
2229       // MACOSX_BUNDLE file
2230       if(cmtarget.GetPropertyAsBool("MACOSX_BUNDLE"))
2231         {
2232         std::string plist = this->ComputeInfoPListLocation(cmtarget);
2233         cmSourceFile* sf = mf->GetOrCreateSource(plist.c_str(), true);
2234         cmtarget.AddSourceFile(sf);
2235         }
2236
2237       std::vector<cmSourceFile*>  classes = cmtarget.GetSourceFiles();
2238
2239       for(std::vector<cmSourceFile*>::const_iterator s = classes.begin();
2240           s != classes.end(); s++)
2241         {
2242         cmSourceFile* sf = *s;
2243         // Add the file to the list of sources.
2244         std::string const& source = sf->GetFullPath();
2245         cmSourceGroup& sourceGroup =
2246           mf->FindSourceGroup(source.c_str(), sourceGroups);
2247         cmXCodeObject* pbxgroup =
2248           this->CreateOrGetPBXGroup(cmtarget, &sourceGroup);
2249         cmStdString key = GetGroupMapKey(cmtarget, sf);
2250         this->GroupMap[key] = pbxgroup;
2251         }
2252       }
2253     }
2254 }
2255
2256 //----------------------------------------------------------------------------
2257 cmXCodeObject* cmGlobalXCodeGenerator
2258 ::CreateOrGetPBXGroup(cmTarget& cmtarget, cmSourceGroup* sg)
2259 {
2260   cmStdString s = cmtarget.GetName();
2261   s += "/";
2262   s += sg->GetName();
2263   std::map<cmStdString, cmXCodeObject* >::iterator i =
2264     this->GroupNameMap.find(s);
2265   if(i != this->GroupNameMap.end())
2266     {
2267     return i->second;
2268     }
2269   i = this->TargetGroup.find(cmtarget.GetName());
2270   cmXCodeObject* tgroup = 0;
2271   if(i != this->TargetGroup.end())
2272     {
2273     tgroup = i->second;
2274     }
2275   else
2276     {
2277     tgroup = this->CreateObject(cmXCodeObject::PBXGroup);
2278     this->TargetGroup[cmtarget.GetName()] = tgroup;
2279     cmXCodeObject* tgroupChildren =
2280       this->CreateObject(cmXCodeObject::OBJECT_LIST);
2281     tgroup->AddAttribute("name", this->CreateString(cmtarget.GetName()));
2282     tgroup->AddAttribute("children", tgroupChildren);
2283     if(this->XcodeVersion == 15)
2284       {
2285       tgroup->AddAttribute("refType", this->CreateString("4"));
2286       }
2287     tgroup->AddAttribute("sourceTree", this->CreateString("<group>"));
2288     this->SourcesGroupChildren->AddObject(tgroup);
2289     }
2290
2291   // If it's the default source group (empty name) then put the source file
2292   // directly in the tgroup...
2293   //
2294   if (cmStdString(sg->GetName()) == "")
2295     {
2296     this->GroupNameMap[s] = tgroup;
2297     return tgroup;
2298     }
2299
2300   cmXCodeObject* tgroupChildren = tgroup->GetObject("children");
2301   cmXCodeObject* group = this->CreateObject(cmXCodeObject::PBXGroup);
2302   cmXCodeObject* groupChildren =
2303     this->CreateObject(cmXCodeObject::OBJECT_LIST);
2304   group->AddAttribute("name", this->CreateString(sg->GetName()));
2305   group->AddAttribute("children", groupChildren);
2306   if(this->XcodeVersion == 15)
2307     {
2308     group->AddAttribute("refType", this->CreateString("4"));
2309     }
2310   group->AddAttribute("sourceTree", this->CreateString("<group>"));
2311   tgroupChildren->AddObject(group);
2312   this->GroupNameMap[s] = group;
2313   return group;
2314 }
2315
2316 //----------------------------------------------------------------------------
2317 void cmGlobalXCodeGenerator
2318 ::CreateXCodeObjects(cmLocalGenerator* root,
2319                      std::vector<cmLocalGenerator*>&
2320                      generators)
2321 {
2322   this->ClearXCodeObjects();
2323   this->RootObject = 0;
2324   this->SourcesGroupChildren = 0;
2325   this->ResourcesGroupChildren = 0;
2326   this->MainGroupChildren = 0;
2327   cmXCodeObject* group = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
2328   group->AddAttribute("COPY_PHASE_STRIP", this->CreateString("NO"));
2329   cmXCodeObject* developBuildStyle =
2330     this->CreateObject(cmXCodeObject::PBXBuildStyle);
2331   cmXCodeObject* listObjs = this->CreateObject(cmXCodeObject::OBJECT_LIST);
2332   if(this->XcodeVersion == 15)
2333     {
2334     developBuildStyle->AddAttribute("name",
2335                                     this->CreateString("Development"));
2336     developBuildStyle->AddAttribute("buildSettings", group);
2337     listObjs->AddObject(developBuildStyle);
2338     group = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
2339     group->AddAttribute("COPY_PHASE_STRIP", this->CreateString("YES"));
2340     cmXCodeObject* deployBuildStyle =
2341     this->CreateObject(cmXCodeObject::PBXBuildStyle);
2342     deployBuildStyle->AddAttribute("name", this->CreateString("Deployment"));
2343     deployBuildStyle->AddAttribute("buildSettings", group);
2344     listObjs->AddObject(deployBuildStyle);
2345     }
2346   else
2347     {
2348     for(unsigned int i = 0; i < this->CurrentConfigurationTypes.size(); ++i)
2349       {
2350       cmXCodeObject* buildStyle =
2351         this->CreateObject(cmXCodeObject::PBXBuildStyle);
2352       const char* name = this->CurrentConfigurationTypes[i].c_str();
2353       buildStyle->AddAttribute("name", this->CreateString(name));
2354       buildStyle->SetComment(name);
2355       cmXCodeObject* sgroup =
2356         this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
2357       sgroup->AddAttribute("COPY_PHASE_STRIP", this->CreateString("NO"));
2358       buildStyle->AddAttribute("buildSettings", sgroup);
2359       listObjs->AddObject(buildStyle);
2360       }
2361     }
2362
2363   cmXCodeObject* mainGroup = this->CreateObject(cmXCodeObject::PBXGroup);
2364   this->MainGroupChildren =
2365     this->CreateObject(cmXCodeObject::OBJECT_LIST);
2366   mainGroup->AddAttribute("children", this->MainGroupChildren);
2367   if(this->XcodeVersion == 15)
2368     {
2369     mainGroup->AddAttribute("refType", this->CreateString("4"));
2370     }
2371   mainGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
2372
2373   cmXCodeObject* sourcesGroup = this->CreateObject(cmXCodeObject::PBXGroup);
2374   this->SourcesGroupChildren =
2375     this->CreateObject(cmXCodeObject::OBJECT_LIST);
2376   sourcesGroup->AddAttribute("name", this->CreateString("Sources"));
2377   sourcesGroup->AddAttribute("children", this->SourcesGroupChildren);
2378   if(this->XcodeVersion == 15)
2379     {
2380     sourcesGroup->AddAttribute("refType", this->CreateString("4"));
2381     }
2382   sourcesGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
2383   this->MainGroupChildren->AddObject(sourcesGroup);
2384
2385   cmXCodeObject* resourcesGroup = this->CreateObject(cmXCodeObject::PBXGroup);
2386   this->ResourcesGroupChildren =
2387     this->CreateObject(cmXCodeObject::OBJECT_LIST);
2388   resourcesGroup->AddAttribute("name", this->CreateString("Resources"));
2389   resourcesGroup->AddAttribute("children", this->ResourcesGroupChildren);
2390   if(this->XcodeVersion == 15)
2391     {
2392     resourcesGroup->AddAttribute("refType", this->CreateString("4"));
2393     }
2394   resourcesGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
2395   this->MainGroupChildren->AddObject(resourcesGroup);
2396
2397   // now create the cmake groups
2398   this->CreateGroups(root, generators);
2399
2400   cmXCodeObject* productGroup = this->CreateObject(cmXCodeObject::PBXGroup);
2401   productGroup->AddAttribute("name", this->CreateString("Products"));
2402   if(this->XcodeVersion == 15)
2403     {
2404     productGroup->AddAttribute("refType", this->CreateString("4"));
2405     }
2406   productGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
2407   cmXCodeObject* productGroupChildren =
2408     this->CreateObject(cmXCodeObject::OBJECT_LIST);
2409   productGroup->AddAttribute("children", productGroupChildren);
2410   this->MainGroupChildren->AddObject(productGroup);
2411
2412
2413   this->RootObject = this->CreateObject(cmXCodeObject::PBXProject);
2414   this->RootObject->SetComment("Project object");
2415   group = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
2416   this->RootObject->AddAttribute("mainGroup",
2417                              this->CreateObjectReference(mainGroup));
2418   this->RootObject->AddAttribute("buildSettings", group);
2419   this->RootObject->AddAttribute("buildStyles", listObjs);
2420   this->RootObject->AddAttribute("hasScannedForEncodings",
2421                              this->CreateString("0"));
2422   // Point Xcode at the top of the source tree.
2423   {
2424   std::string proot = root->GetMakefile()->GetCurrentDirectory();
2425   proot = this->ConvertToRelativeForXCode(proot.c_str());
2426   this->RootObject->AddAttribute("projectRoot",
2427                                  this->CreateString(proot.c_str()));
2428   }
2429   cmXCodeObject* configlist =
2430     this->CreateObject(cmXCodeObject::XCConfigurationList);
2431   cmXCodeObject* buildConfigurations =
2432     this->CreateObject(cmXCodeObject::OBJECT_LIST);
2433   std::vector<cmXCodeObject*> configs;
2434   if(this->XcodeVersion == 15)
2435     {
2436     cmXCodeObject* configDebug =
2437       this->CreateObject(cmXCodeObject::XCBuildConfiguration);
2438     configDebug->AddAttribute("name", this->CreateString("Debug"));
2439     configs.push_back(configDebug);
2440     cmXCodeObject* configRelease =
2441       this->CreateObject(cmXCodeObject::XCBuildConfiguration);
2442     configRelease->AddAttribute("name", this->CreateString("Release"));
2443     configs.push_back(configRelease);
2444     }
2445   else
2446     {
2447     for(unsigned int i = 0; i < this->CurrentConfigurationTypes.size(); ++i)
2448       {
2449       const char* name = this->CurrentConfigurationTypes[i].c_str();
2450       cmXCodeObject* config =
2451         this->CreateObject(cmXCodeObject::XCBuildConfiguration);
2452       config->AddAttribute("name", this->CreateString(name));
2453       configs.push_back(config);
2454       }
2455     }
2456   for(std::vector<cmXCodeObject*>::iterator c = configs.begin();
2457       c != configs.end(); ++c)
2458     {
2459     buildConfigurations->AddObject(*c);
2460     }
2461   configlist->AddAttribute("buildConfigurations", buildConfigurations);
2462
2463   std::string comment = "Build configuration list for PBXProject ";
2464   comment += " \"";
2465   comment += this->CurrentProject;
2466   comment += "\"";
2467   configlist->SetComment(comment.c_str());
2468   configlist->AddAttribute("defaultConfigurationIsVisible",
2469                            this->CreateString("0"));
2470   configlist->AddAttribute("defaultConfigurationName",
2471                            this->CreateString("Debug"));
2472   cmXCodeObject* buildSettings =
2473       this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
2474   const char* osxArch =
2475       this->CurrentMakefile->GetDefinition("CMAKE_OSX_ARCHITECTURES");
2476   const char* sysroot =
2477       this->CurrentMakefile->GetDefinition("CMAKE_OSX_SYSROOT");
2478   const char* sysrootDefault =
2479     this->CurrentMakefile->GetDefinition("CMAKE_OSX_SYSROOT_DEFAULT");
2480   if(osxArch && sysroot)
2481     {
2482     bool flagsUsed = false;
2483     // recompute this as it may have been changed since enable language
2484     this->Architectures.clear();
2485     cmSystemTools::ExpandListArgument(std::string(osxArch),
2486                                       this->Architectures);
2487     bool addArchFlag = true;
2488     if(this->Architectures.size() == 1)
2489       {
2490       const char* archOrig =
2491         this->
2492         CurrentMakefile->GetSafeDefinition("CMAKE_OSX_ARCHITECTURES_DEFAULT");
2493       if(this->Architectures[0] == archOrig)
2494         {
2495         addArchFlag = false;
2496         }
2497       }
2498     if(addArchFlag)
2499       {
2500       flagsUsed = true;
2501       buildSettings->AddAttribute("SDKROOT",
2502                                   this->CreateString(sysroot));
2503       std::string archString;
2504       for( std::vector<std::string>::iterator i =
2505              this->Architectures.begin();
2506            i != this->Architectures.end(); ++i)
2507         {
2508         archString += *i;
2509         archString += " ";
2510         }
2511       buildSettings->AddAttribute("ARCHS",
2512                                   this->CreateString(archString.c_str()));
2513       }
2514     if(!flagsUsed && sysrootDefault &&
2515        strcmp(sysroot, sysrootDefault) != 0)
2516       {
2517       buildSettings->AddAttribute("SDKROOT",
2518                                   this->CreateString(sysroot));
2519       }
2520     }
2521   for( std::vector<cmXCodeObject*>::iterator i = configs.begin();
2522        i != configs.end(); ++i)
2523     {
2524     (*i)->AddAttribute("buildSettings", buildSettings);
2525     }
2526   this->RootObject->AddAttribute("buildConfigurationList",
2527                              this->CreateObjectReference(configlist));
2528
2529   std::vector<cmXCodeObject*> targets;
2530   for(std::vector<cmLocalGenerator*>::iterator i = generators.begin();
2531       i != generators.end(); ++i)
2532     {
2533     if(!this->IsExcluded(root, *i))
2534       {
2535       this->CreateXCodeTargets(*i, targets);
2536       }
2537     }
2538   // loop over all targets and add link and depend info
2539   for(std::vector<cmXCodeObject*>::iterator i = targets.begin();
2540       i != targets.end(); ++i)
2541     {
2542     cmXCodeObject* t = *i;
2543     this->AddDependAndLinkInformation(t);
2544     }
2545   // now create xcode depend hack makefile
2546   this->CreateXCodeDependHackTarget(targets);
2547   // now add all targets to the root object
2548   cmXCodeObject* allTargets = this->CreateObject(cmXCodeObject::OBJECT_LIST);
2549   for(std::vector<cmXCodeObject*>::iterator i = targets.begin();
2550       i != targets.end(); ++i)
2551     {
2552     cmXCodeObject* t = *i;
2553     allTargets->AddObject(t);
2554     cmXCodeObject* productRef = t->GetObject("productReference");
2555     if(productRef)
2556       {
2557       productGroupChildren->AddObject(productRef->GetObject());
2558       }
2559     }
2560   this->RootObject->AddAttribute("targets", allTargets);
2561 }
2562
2563 //----------------------------------------------------------------------------
2564 void
2565 cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
2566   std::vector<cmXCodeObject*>& targets)
2567 {
2568   cmGeneratedFileStream
2569     makefileStream(this->CurrentXCodeHackMakefile.c_str());
2570   if(!makefileStream)
2571     {
2572     cmSystemTools::Error("Could not create",
2573                          this->CurrentXCodeHackMakefile.c_str());
2574     return;
2575     }
2576   makefileStream.SetCopyIfDifferent(true);
2577   // one more pass for external depend information not handled
2578   // correctly by xcode
2579   makefileStream << "# DO NOT EDIT\n";
2580   makefileStream << "# This makefile makes sure all linkable targets are\n";
2581   makefileStream << "# up-to-date with anything they link to, avoiding a "
2582     "bug in XCode 1.5\n";
2583   for(std::vector<std::string>::const_iterator
2584         ct = this->CurrentConfigurationTypes.begin();
2585       ct != this->CurrentConfigurationTypes.end(); ++ct)
2586     {
2587     if(this->XcodeVersion < 21 || ct->empty())
2588       {
2589       makefileStream << "all: ";
2590       }
2591     else
2592       {
2593       makefileStream << "all." << *ct << ": ";
2594       }
2595     const char* configName = 0;
2596     if(!ct->empty())
2597       {
2598       configName = ct->c_str();
2599       }
2600     for(std::vector<cmXCodeObject*>::iterator i = targets.begin();
2601         i != targets.end(); ++i)
2602       {
2603       cmXCodeObject* target = *i;
2604       cmTarget* t =target->GetTarget();
2605       if(t->GetType() == cmTarget::EXECUTABLE ||
2606          t->GetType() == cmTarget::SHARED_LIBRARY ||
2607          t->GetType() == cmTarget::MODULE_LIBRARY)
2608         {
2609         std::string tfull = t->GetFullPath(configName);
2610         if(t->IsAppBundleOnApple())
2611           {
2612           tfull += ".app/Contents/MacOS/";
2613           tfull += t->GetFullName(configName);
2614           }
2615         makefileStream << "\\\n\t" <<
2616           this->ConvertToRelativeForMake(tfull.c_str());
2617         }
2618       }
2619     makefileStream << "\n\n";
2620     }
2621   makefileStream
2622     << "# For each target create a dummy rule "
2623     "so the target does not have to exist\n";
2624   std::set<cmStdString> emitted;
2625   for(std::vector<cmXCodeObject*>::iterator i = targets.begin();
2626       i != targets.end(); ++i)
2627     {
2628     cmXCodeObject* target = *i;
2629     std::map<cmStdString, cmXCodeObject::StringVec> const& deplibs =
2630       target->GetDependLibraries();
2631     for(std::map<cmStdString, cmXCodeObject::StringVec>::const_iterator ci
2632           = deplibs.begin(); ci != deplibs.end(); ++ci)
2633       {
2634       for(cmXCodeObject::StringVec::const_iterator d = ci->second.begin();
2635           d != ci->second.end(); ++d)
2636         {
2637         if(emitted.insert(*d).second)
2638           {
2639           makefileStream <<
2640             this->ConvertToRelativeForMake(d->c_str()) << ":\n";
2641           }
2642         }
2643       }
2644     }
2645   makefileStream << "\n\n";
2646
2647   // Write rules to help Xcode relink things at the right time.
2648   makefileStream <<
2649     "# Rules to remove targets that are older than anything to which they\n"
2650     "# link.  This forces Xcode to relink the targets from scratch.  It\n"
2651     "# does not seem to check these dependencies itself.\n";
2652   for(std::vector<std::string>::const_iterator
2653         ct = this->CurrentConfigurationTypes.begin();
2654       ct != this->CurrentConfigurationTypes.end(); ++ct)
2655     {
2656     const char* configName = 0;
2657     if(!ct->empty())
2658       {
2659       configName = ct->c_str();
2660       }
2661     for(std::vector<cmXCodeObject*>::iterator i = targets.begin();
2662         i != targets.end(); ++i)
2663       {
2664       cmXCodeObject* target = *i;
2665       cmTarget* t =target->GetTarget();
2666       if(t->GetType() == cmTarget::EXECUTABLE ||
2667          t->GetType() == cmTarget::SHARED_LIBRARY ||
2668          t->GetType() == cmTarget::MODULE_LIBRARY)
2669         {
2670         // Create a rule for this target.
2671         std::string tfull = t->GetFullPath(configName);
2672         if(t->IsAppBundleOnApple())
2673           {
2674           tfull += ".app/Contents/MacOS/";
2675           tfull += t->GetFullName(configName);
2676           }
2677         makefileStream << this->ConvertToRelativeForMake(tfull.c_str())
2678                        << ":";
2679
2680         // List dependencies if any exist.
2681         std::map<cmStdString, cmXCodeObject::StringVec>::const_iterator
2682           x = target->GetDependLibraries().find(*ct);
2683         if(x != target->GetDependLibraries().end())
2684           {
2685           std::vector<cmStdString> const& deplibs = x->second;
2686           for(std::vector<cmStdString>::const_iterator d = deplibs.begin();
2687               d != deplibs.end(); ++d)
2688             {
2689             makefileStream << "\\\n\t" <<
2690               this->ConvertToRelativeForMake(d->c_str());
2691             }
2692           }
2693         // Write the action to remove the target if it is out of date.
2694         makefileStream << "\n";
2695         makefileStream << "\t/bin/rm -f "
2696                        << this->ConvertToRelativeForMake(tfull.c_str())
2697                        << "\n";
2698         // if building for more than one architecture
2699         // then remove those exectuables as well
2700         if(this->Architectures.size() > 1)
2701           {
2702           std::string universal = t->GetDirectory();
2703           universal += "/";
2704           universal += this->CurrentMakefile->GetProjectName();
2705           universal += ".build/";
2706           universal += configName;
2707           universal += "/";
2708           universal += t->GetName();
2709           universal += ".build/Objects-normal/";
2710           for( std::vector<std::string>::iterator arch =
2711                  this->Architectures.begin();
2712                arch != this->Architectures.end(); ++arch)
2713             {
2714             std::string universalFile = universal;
2715             universalFile += *arch;
2716             universalFile += "/";
2717             universalFile += t->GetName();
2718             makefileStream << "\t/bin/rm -f "
2719                            <<
2720               this->ConvertToRelativeForMake(universalFile.c_str())
2721                            << "\n";
2722             }
2723           }
2724         makefileStream << "\n\n";
2725         }
2726       }
2727     }
2728 }
2729
2730 //----------------------------------------------------------------------------
2731 void
2732 cmGlobalXCodeGenerator::OutputXCodeProject(cmLocalGenerator* root,
2733                                            std::vector<cmLocalGenerator*>&
2734                                            generators)
2735 {
2736   if(generators.size() == 0)
2737     {
2738     return;
2739     }
2740   // Skip local generators that are excluded from this project.
2741   for(std::vector<cmLocalGenerator*>::iterator g = generators.begin();
2742       g != generators.end(); ++g)
2743     {
2744     if(this->IsExcluded(root, *g))
2745       {
2746       continue;
2747       }
2748     }
2749
2750   this->CreateXCodeObjects(root,
2751                            generators);
2752   std::string xcodeDir = root->GetMakefile()->GetStartOutputDirectory();
2753   xcodeDir += "/";
2754   xcodeDir += root->GetMakefile()->GetProjectName();
2755   xcodeDir += ".xcode";
2756   if(this->XcodeVersion > 20)
2757     {
2758     xcodeDir += "proj";
2759     }
2760   cmSystemTools::MakeDirectory(xcodeDir.c_str());
2761   std::string xcodeProjFile = xcodeDir + "/project.pbxproj";
2762   cmGeneratedFileStream fout(xcodeProjFile.c_str());
2763   fout.SetCopyIfDifferent(true);
2764   if(!fout)
2765     {
2766     return;
2767     }
2768   this->WriteXCodePBXProj(fout, root, generators);
2769   this->ClearXCodeObjects();
2770 }
2771
2772 //----------------------------------------------------------------------------
2773 void
2774 cmGlobalXCodeGenerator::WriteXCodePBXProj(std::ostream& fout,
2775                                           cmLocalGenerator* ,
2776                                           std::vector<cmLocalGenerator*>& )
2777 {
2778   fout << "// !$*UTF8*$!\n";
2779   fout << "{\n";
2780   cmXCodeObject::Indent(1, fout);
2781   fout << "archiveVersion = 1;\n";
2782   cmXCodeObject::Indent(1, fout);
2783   fout << "classes = {\n";
2784   cmXCodeObject::Indent(1, fout);
2785   fout << "};\n";
2786   cmXCodeObject::Indent(1, fout);
2787   fout << "objectVersion = 39;\n";
2788   cmXCodeObject::PrintList(this->XCodeObjects, fout);
2789   cmXCodeObject::Indent(1, fout);
2790   fout << "rootObject = " << this->RootObject->GetId() << ";\n";
2791   fout << "}\n";
2792 }
2793
2794 //----------------------------------------------------------------------------
2795 void cmGlobalXCodeGenerator::GetDocumentation(cmDocumentationEntry& entry)
2796   const
2797 {
2798   entry.Name = this->GetName();
2799   entry.Brief = "Generate XCode project files.";
2800   entry.Full = "";
2801 }
2802
2803 //----------------------------------------------------------------------------
2804 std::string cmGlobalXCodeGenerator::ConvertToRelativeForMake(const char* p)
2805 {
2806   if ( !this->CurrentMakefile->IsOn("CMAKE_USE_RELATIVE_PATHS") )
2807     {
2808     return cmSystemTools::ConvertToOutputPath(p);
2809     }
2810   else
2811     {
2812     std::string ret =
2813       this->CurrentLocalGenerator->
2814         ConvertToRelativePath(this->CurrentOutputDirectoryComponents, p);
2815     return cmSystemTools::ConvertToOutputPath(ret.c_str());
2816     }
2817 }
2818
2819 //----------------------------------------------------------------------------
2820 std::string cmGlobalXCodeGenerator::ConvertToRelativeForXCode(const char* p)
2821 {
2822   if ( !this->CurrentMakefile->IsOn("CMAKE_USE_RELATIVE_PATHS") )
2823     {
2824     return cmSystemTools::ConvertToOutputPath(p);
2825     }
2826   else
2827     {
2828     std::string ret =
2829       this->CurrentLocalGenerator->
2830         ConvertToRelativePath(this->ProjectOutputDirectoryComponents, p);
2831     return cmSystemTools::ConvertToOutputPath(ret.c_str());
2832     }
2833 }
2834
2835 //----------------------------------------------------------------------------
2836 std::string cmGlobalXCodeGenerator::XCodeEscapePath(const char* p)
2837 {
2838   std::string ret = p;
2839   if(ret.find(' ') != ret.npos)
2840     {
2841     std::string t = ret;
2842     ret = "\"";
2843     ret += t;
2844     ret += "\"";
2845     }
2846   return ret;
2847 }
2848
2849 //----------------------------------------------------------------------------
2850 void cmGlobalXCodeGenerator::
2851 GetTargetObjectFileDirectories(cmTarget* target,
2852                                std::vector<std::string>&
2853                                dirs)
2854 {
2855   std::string dir = this->CurrentMakefile->GetCurrentOutputDirectory();
2856   dir += "/";
2857   dir += this->CurrentMakefile->GetProjectName();
2858   dir += ".build/";
2859   dir += this->GetCMakeCFGInitDirectory();
2860   dir += "/";
2861   if(target->GetType() != cmTarget::EXECUTABLE)
2862     {
2863     dir += "lib";
2864     }
2865   dir += target->GetName();
2866   if(target->GetType() == cmTarget::STATIC_LIBRARY)
2867     {
2868     dir += ".a";
2869     }
2870   if(target->GetType() == cmTarget::SHARED_LIBRARY)
2871     {
2872     dir += ".dylib";
2873     }
2874   if(target->GetType() == cmTarget::MODULE_LIBRARY)
2875     {
2876     dir += ".so";
2877     }
2878   dir += ".build/Objects-normal/";
2879   std::string dirsave = dir;
2880   if(this->Architectures.size())
2881     {
2882     for(std::vector<std::string>::iterator i = this->Architectures.begin();
2883         i != this->Architectures.end(); ++i)
2884       {
2885       dir += *i;
2886       dirs.push_back(dir);
2887       dir = dirsave;
2888       }
2889     }
2890   else
2891     {
2892     dirs.push_back(dir);
2893     }
2894 }
2895
2896 //----------------------------------------------------------------------------
2897 void
2898 cmGlobalXCodeGenerator
2899 ::AppendDirectoryForConfig(const char* prefix,
2900                            const char* config,
2901                            const char* suffix,
2902                            std::string& dir)
2903 {
2904   if(this->XcodeVersion > 20)
2905     {
2906     if(config)
2907       {
2908       dir += prefix;
2909       dir += config;
2910       dir += suffix;
2911       }
2912     }
2913 }
2914
2915 //----------------------------------------------------------------------------
2916 std::string cmGlobalXCodeGenerator::LookupFlags(const char* varNamePrefix,
2917                                                 const char* varNameLang,
2918                                                 const char* varNameSuffix,
2919                                                 const char* default_flags)
2920 {
2921   if(varNameLang)
2922     {
2923     std::string varName = varNamePrefix;
2924     varName += varNameLang;
2925     varName += varNameSuffix;
2926     if(const char* varValue =
2927        this->CurrentMakefile->GetDefinition(varName.c_str()))
2928       {
2929       if(*varValue)
2930         {
2931         return varValue;
2932         }
2933       }
2934     }
2935   return default_flags;
2936 }
2937
2938 //----------------------------------------------------------------------------
2939 void cmGlobalXCodeGenerator::AppendDefines(std::string& defs,
2940                                            const char* defines_list,
2941                                            bool dflag)
2942 {
2943   // Skip this if there are no definitions.
2944   if(!defines_list)
2945     {
2946     return;
2947     }
2948
2949   // Expand the list of definitions.
2950   std::vector<std::string> defines;
2951   cmSystemTools::ExpandListArgument(defines_list, defines);
2952
2953   // GCC_PREPROCESSOR_DEFINITIONS is a space-separated list of definitions.
2954   // We escape everything as follows:
2955   //   - Place each definition in single quotes ''
2956   //   - Escape a single quote as \\'
2957   //   - Escape a backslash as \\\\ since it itself is an escape
2958   // Note that in the code below we need one more level of escapes for
2959   // C string syntax in this source file.
2960   const char* sep = defs.empty()? "" : " ";
2961   for(std::vector<std::string>::const_iterator di = defines.begin();
2962       di != defines.end(); ++di)
2963     {
2964     // Separate from previous definition.
2965     defs += sep;
2966     sep = " ";
2967
2968     // Open single quote.
2969     defs += "'";
2970
2971     // Add -D flag if requested.
2972     if(dflag)
2973       {
2974       defs += "-D";
2975       }
2976
2977     // Escaped definition string.
2978     for(const char* c = di->c_str(); *c; ++c)
2979       {
2980       if(*c == '\'')
2981         {
2982         defs += "\\\\'";
2983         }
2984       else if(*c == '\\')
2985         {
2986         defs += "\\\\\\\\";
2987         }
2988       else
2989         {
2990         defs += *c;
2991         }
2992       }
2993
2994     // Close single quote.
2995     defs += "'";
2996     }
2997 }
2998
2999 //----------------------------------------------------------------------------
3000 std::string
3001 cmGlobalXCodeGenerator::ComputeInfoPListLocation(cmTarget& target)
3002 {
3003   std::string plist = target.GetMakefile()->GetCurrentOutputDirectory();
3004   plist += cmake::GetCMakeFilesDirectory();
3005   plist += "/";
3006   plist += target.GetName();
3007   plist += ".dir/Info.plist";
3008   return plist;
3009 }