summaryrefslogtreecommitdiff
path: root/Source/cmGlobalXCodeGenerator.cxx
diff options
context:
space:
mode:
authorAnas Nashif <anas.nashif@intel.com>2012-10-30 22:39:57 (GMT)
committerAnas Nashif <anas.nashif@intel.com>2012-10-30 22:39:57 (GMT)
commit035c7fabc3b82cbc9a346c11abe2e9462b4c0379 (patch)
tree7e40f5a790eae329a8c5d3e59f046451767956ff /Source/cmGlobalXCodeGenerator.cxx
downloadcmake-035c7fabc3b82cbc9a346c11abe2e9462b4c0379.zip
cmake-035c7fabc3b82cbc9a346c11abe2e9462b4c0379.tar.gz
cmake-035c7fabc3b82cbc9a346c11abe2e9462b4c0379.tar.bz2
Imported Upstream version 2.8.9upstream/2.8.9
Diffstat (limited to 'Source/cmGlobalXCodeGenerator.cxx')
-rw-r--r--Source/cmGlobalXCodeGenerator.cxx3757
1 files changed, 3757 insertions, 0 deletions
diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx
new file mode 100644
index 0000000..938977b
--- /dev/null
+++ b/Source/cmGlobalXCodeGenerator.cxx
@@ -0,0 +1,3757 @@
+/*============================================================================
+ CMake - Cross Platform Makefile Generator
+ Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
+
+ Distributed under the OSI-approved BSD License (the "License");
+ see accompanying file Copyright.txt for details.
+
+ This software is distributed WITHOUT ANY WARRANTY; without even the
+ implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ See the License for more information.
+============================================================================*/
+#include "cmGlobalXCodeGenerator.h"
+#include "cmLocalXCodeGenerator.h"
+#include "cmMakefile.h"
+#include "cmXCodeObject.h"
+#include "cmXCode21Object.h"
+#include "cmake.h"
+#include "cmGeneratedFileStream.h"
+#include "cmComputeLinkInformation.h"
+#include "cmSourceFile.h"
+#include "cmCustomCommandGenerator.h"
+#include "cmGeneratorTarget.h"
+
+#include <cmsys/auto_ptr.hxx>
+
+//----------------------------------------------------------------------------
+#if defined(CMAKE_BUILD_WITH_CMAKE)
+#include "cmXMLParser.h"
+
+// parse the xml file storing the installed version of Xcode on
+// the machine
+class cmXcodeVersionParser : public cmXMLParser
+{
+public:
+ cmXcodeVersionParser(): Version("1.5") {}
+ void StartElement(const char* , const char** )
+ {
+ this->Data = "";
+ }
+ void EndElement(const char* name)
+ {
+ if(strcmp(name, "key") == 0)
+ {
+ this->Key = this->Data;
+ }
+ else if(strcmp(name, "string") == 0)
+ {
+ if(this->Key == "CFBundleShortVersionString")
+ {
+ this->Version = this->Data;
+ }
+ }
+ }
+ void CharacterDataHandler(const char* data, int length)
+ {
+ this->Data.append(data, length);
+ }
+ std::string Version;
+ std::string Key;
+ std::string Data;
+};
+#endif
+
+// Builds either an object list or a space-separated string from the
+// given inputs.
+class cmGlobalXCodeGenerator::BuildObjectListOrString
+{
+ cmGlobalXCodeGenerator *Generator;
+ cmXCodeObject *Group;
+ bool Empty;
+ std::string String;
+
+public:
+ BuildObjectListOrString(cmGlobalXCodeGenerator *gen, bool buildObjectList)
+ : Generator(gen), Group(0), Empty(true)
+ {
+ if (buildObjectList)
+ {
+ this->Group = this->Generator->CreateObject(cmXCodeObject::OBJECT_LIST);
+ }
+ }
+
+ bool IsEmpty() const { return this->Empty; }
+
+ void Add(const char *newString)
+ {
+ this->Empty = false;
+
+ if (this->Group)
+ {
+ this->Group->AddObject(this->Generator->CreateString(newString));
+ }
+ else
+ {
+ this->String += newString;
+ this->String += ' ';
+ }
+ }
+
+ const std::string &GetString() const { return this->String; }
+
+ cmXCodeObject *CreateList()
+ {
+ if (this->Group)
+ {
+ return this->Group;
+ }
+ else
+ {
+ return this->Generator->CreateString(this->String.c_str());
+ }
+ }
+};
+
+//----------------------------------------------------------------------------
+cmGlobalXCodeGenerator::cmGlobalXCodeGenerator(std::string const& version)
+{
+ this->VersionString = version;
+
+ // Compute an integer form of the version number.
+ unsigned int v[2] = {0,0};
+ sscanf(this->VersionString.c_str(), "%u.%u", &v[0], &v[1]);
+ this->XcodeVersion = 10*v[0] + v[1];
+
+ this->FindMakeProgramFile = "CMakeFindXCode.cmake";
+ this->RootObject = 0;
+ this->MainGroupChildren = 0;
+ this->SourcesGroupChildren = 0;
+ this->ResourcesGroupChildren = 0;
+ this->CurrentMakefile = 0;
+ this->CurrentLocalGenerator = 0;
+}
+
+//----------------------------------------------------------------------------
+cmGlobalGenerator* cmGlobalXCodeGenerator::New()
+{
+#if defined(CMAKE_BUILD_WITH_CMAKE)
+ cmXcodeVersionParser parser;
+ if (cmSystemTools::FileExists(
+ "/Applications/Xcode.app/Contents/version.plist"))
+ {
+ parser.ParseFile
+ ("/Applications/Xcode.app/Contents/version.plist");
+ }
+ else
+ {
+ parser.ParseFile
+ ("/Developer/Applications/Xcode.app/Contents/version.plist");
+ }
+ cmsys::auto_ptr<cmGlobalXCodeGenerator>
+ gg(new cmGlobalXCodeGenerator(parser.Version));
+ if (gg->XcodeVersion == 20)
+ {
+ cmSystemTools::Message("Xcode 2.0 not really supported by cmake, "
+ "using Xcode 15 generator\n");
+ gg->XcodeVersion = 15;
+ }
+ return gg.release();
+#else
+ std::cerr << "CMake should be built with cmake to use Xcode, "
+ "default to Xcode 1.5\n";
+ return new cmGlobalXCodeGenerator;
+#endif
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalXCodeGenerator::EnableLanguage(std::vector<std::string>const&
+ lang,
+ cmMakefile * mf, bool optional)
+{
+ mf->AddDefinition("XCODE","1");
+ mf->AddDefinition("XCODE_VERSION", this->VersionString.c_str());
+ if(this->XcodeVersion == 15)
+ {
+ }
+ else
+ {
+ if(!mf->GetDefinition("CMAKE_CONFIGURATION_TYPES"))
+ {
+ mf->AddCacheDefinition(
+ "CMAKE_CONFIGURATION_TYPES",
+ "Debug;Release;MinSizeRel;RelWithDebInfo",
+ "Semicolon separated list of supported configuration types, "
+ "only supports Debug, Release, MinSizeRel, and RelWithDebInfo, "
+ "anything else will be ignored.",
+ cmCacheManager::STRING);
+ }
+ }
+ mf->AddDefinition("CMAKE_GENERATOR_CC", "gcc");
+ mf->AddDefinition("CMAKE_GENERATOR_CXX", "g++");
+ mf->AddDefinition("CMAKE_GENERATOR_NO_COMPILER_ENV", "1");
+ this->cmGlobalGenerator::EnableLanguage(lang, mf, optional);
+ const char* osxArch =
+ mf->GetDefinition("CMAKE_OSX_ARCHITECTURES");
+ const char* sysroot =
+ mf->GetDefinition("CMAKE_OSX_SYSROOT");
+ if(osxArch && sysroot)
+ {
+ this->Architectures.clear();
+ cmSystemTools::ExpandListArgument(std::string(osxArch),
+ this->Architectures);
+ }
+}
+
+//----------------------------------------------------------------------------
+std::string cmGlobalXCodeGenerator
+::GenerateBuildCommand(const char* makeProgram,
+ const char *projectName,
+ const char* additionalOptions,
+ const char *targetName,
+ const char* config,
+ bool ignoreErrors,
+ bool)
+{
+ // Config is not used yet
+ (void) ignoreErrors;
+
+ // now build the test
+ if(makeProgram == 0 || !strlen(makeProgram))
+ {
+ cmSystemTools::Error(
+ "Generator cannot find the appropriate make command.");
+ return "";
+ }
+ std::string makeCommand =
+ cmSystemTools::ConvertToOutputPath(makeProgram);
+ std::string lowerCaseCommand = makeCommand;
+ cmSystemTools::LowerCase(lowerCaseCommand);
+
+ makeCommand += " -project ";
+ makeCommand += projectName;
+ makeCommand += ".xcode";
+ if(this->XcodeVersion > 20)
+ {
+ makeCommand += "proj";
+ }
+
+ bool clean = false;
+ if ( targetName && strcmp(targetName, "clean") == 0 )
+ {
+ clean = true;
+ targetName = "ALL_BUILD";
+ }
+ if(clean)
+ {
+ makeCommand += " clean";
+ }
+ else
+ {
+ makeCommand += " build";
+ }
+ makeCommand += " -target ";
+ // if it is a null string for config don't use it
+ if(config && *config == 0)
+ {
+ config = 0;
+ }
+ if (targetName && strlen(targetName))
+ {
+ makeCommand += targetName;
+ }
+ else
+ {
+ makeCommand += "ALL_BUILD";
+ }
+ if(this->XcodeVersion == 15)
+ {
+ makeCommand += " -buildstyle Development ";
+ }
+ else
+ {
+ makeCommand += " -configuration ";
+ makeCommand += config?config:"Debug";
+ }
+ if ( additionalOptions )
+ {
+ makeCommand += " ";
+ makeCommand += additionalOptions;
+ }
+ return makeCommand;
+}
+
+//----------------------------------------------------------------------------
+///! Create a local generator appropriate to this Global Generator
+cmLocalGenerator *cmGlobalXCodeGenerator::CreateLocalGenerator()
+{
+ cmLocalGenerator *lg = new cmLocalXCodeGenerator;
+ lg->SetGlobalGenerator(this);
+ return lg;
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalXCodeGenerator::Generate()
+{
+ std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it;
+ // make sure extra targets are added before calling
+ // the parent generate which will call trace depends
+ for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
+ {
+ cmLocalGenerator* root = it->second[0];
+ this->SetGenerationRoot(root);
+ // add ALL_BUILD, INSTALL, etc
+ this->AddExtraTargets(root, it->second);
+ }
+ this->ForceLinkerLanguages();
+ this->cmGlobalGenerator::Generate();
+ if(cmSystemTools::GetErrorOccuredFlag())
+ {
+ return;
+ }
+ for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
+ {
+ cmLocalGenerator* root = it->second[0];
+ this->SetGenerationRoot(root);
+ // now create the project
+ this->OutputXCodeProject(root, it->second);
+ }
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalXCodeGenerator::SetGenerationRoot(cmLocalGenerator* root)
+{
+ this->CurrentProject = root->GetMakefile()->GetProjectName();
+ this->SetCurrentLocalGenerator(root);
+ cmSystemTools::SplitPath(this->CurrentMakefile->GetCurrentDirectory(),
+ this->ProjectSourceDirectoryComponents);
+ cmSystemTools::SplitPath(this->CurrentMakefile->GetCurrentOutputDirectory(),
+ this->ProjectOutputDirectoryComponents);
+
+ this->CurrentXCodeHackMakefile =
+ root->GetMakefile()->GetCurrentOutputDirectory();
+ this->CurrentXCodeHackMakefile += "/CMakeScripts";
+ cmSystemTools::MakeDirectory(this->CurrentXCodeHackMakefile.c_str());
+ this->CurrentXCodeHackMakefile += "/XCODE_DEPEND_HELPER.make";
+}
+
+//----------------------------------------------------------------------------
+std::string
+cmGlobalXCodeGenerator::PostBuildMakeTarget(std::string const& tName,
+ std::string const& configName)
+{
+ std::string target = tName;
+ cmSystemTools::ReplaceString(target, " ", "_");
+ std::string out = "PostBuild." + target;
+ if(this->XcodeVersion > 20)
+ {
+ out += "." + configName;
+ }
+ return out;
+}
+
+//----------------------------------------------------------------------------
+#define CMAKE_CHECK_BUILD_SYSTEM_TARGET "ZERO_CHECK"
+
+//----------------------------------------------------------------------------
+void
+cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root,
+ std::vector<cmLocalGenerator*>& gens)
+{
+ cmMakefile* mf = root->GetMakefile();
+
+ // Add ALL_BUILD
+ const char* no_working_directory = 0;
+ std::vector<std::string> no_depends;
+ mf->AddUtilityCommand("ALL_BUILD", true, no_depends,
+ no_working_directory,
+ "echo", "Build all projects");
+ cmTarget* allbuild = mf->FindTarget("ALL_BUILD");
+
+ // Refer to the main build configuration file for easy editing.
+ std::string listfile = mf->GetStartDirectory();
+ listfile += "/";
+ listfile += "CMakeLists.txt";
+ allbuild->AddSource(listfile.c_str());
+
+ // Add XCODE depend helper
+ std::string dir = mf->GetCurrentOutputDirectory();
+ cmCustomCommandLine makecommand;
+ makecommand.push_back("make");
+ makecommand.push_back("-C");
+ makecommand.push_back(dir.c_str());
+ makecommand.push_back("-f");
+ makecommand.push_back(this->CurrentXCodeHackMakefile.c_str());
+ makecommand.push_back(""); // placeholder, see below
+
+ // Add ZERO_CHECK
+ bool regenerate = !mf->IsOn("CMAKE_SUPPRESS_REGENERATION");
+ if (regenerate)
+ {
+ this->CreateReRunCMakeFile(root, gens);
+ std::string file = this->ConvertToRelativeForMake(
+ this->CurrentReRunCMakeMakefile.c_str());
+ cmSystemTools::ReplaceString(file, "\\ ", " ");
+ mf->AddUtilityCommand(CMAKE_CHECK_BUILD_SYSTEM_TARGET, true, no_depends,
+ no_working_directory,
+ "make", "-f", file.c_str());
+ }
+
+ // now make the allbuild depend on all the non-utility targets
+ // in the project
+ for(std::vector<cmLocalGenerator*>::iterator i = gens.begin();
+ i != gens.end(); ++i)
+ {
+ cmLocalGenerator* lg = *i;
+ if(this->IsExcluded(root, *i))
+ {
+ continue;
+ }
+
+ cmTargets& tgts = lg->GetMakefile()->GetTargets();
+ for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); l++)
+ {
+ cmTarget& target = l->second;
+
+ if (regenerate && (l->first != CMAKE_CHECK_BUILD_SYSTEM_TARGET))
+ {
+ target.AddUtility(CMAKE_CHECK_BUILD_SYSTEM_TARGET);
+ }
+
+ // make all exe, shared libs and modules
+ // run the depend check makefile as a post build rule
+ // this will make sure that when the next target is built
+ // things are up-to-date
+ if((target.GetType() == cmTarget::EXECUTABLE ||
+// Nope - no post-build for OBJECT_LIRBRARY
+// target.GetType() == cmTarget::OBJECT_LIBRARY ||
+ target.GetType() == cmTarget::STATIC_LIBRARY ||
+ target.GetType() == cmTarget::SHARED_LIBRARY ||
+ target.GetType() == cmTarget::MODULE_LIBRARY))
+ {
+ makecommand[makecommand.size()-1] =
+ this->PostBuildMakeTarget(target.GetName(), "$(CONFIGURATION)");
+ cmCustomCommandLines commandLines;
+ commandLines.push_back(makecommand);
+ lg->GetMakefile()->AddCustomCommandToTarget(target.GetName(),
+ no_depends,
+ commandLines,
+ cmTarget::POST_BUILD,
+ "Depend check for xcode",
+ dir.c_str());
+ }
+
+ if(!target.GetPropertyAsBool("EXCLUDE_FROM_ALL"))
+ {
+ allbuild->AddUtility(target.GetName());
+ }
+
+ // Refer to the build configuration file for easy editing.
+ listfile = lg->GetMakefile()->GetStartDirectory();
+ listfile += "/";
+ listfile += "CMakeLists.txt";
+ target.AddSource(listfile.c_str());
+ }
+ }
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalXCodeGenerator::CreateReRunCMakeFile(
+ cmLocalGenerator* root, std::vector<cmLocalGenerator*> const& gens)
+{
+ cmMakefile* mf = root->GetMakefile();
+ std::vector<std::string> lfiles;
+ for(std::vector<cmLocalGenerator*>::const_iterator gi = gens.begin();
+ gi != gens.end(); ++gi)
+ {
+ std::vector<std::string> const& lf = (*gi)->GetMakefile()->GetListFiles();
+ lfiles.insert(lfiles.end(), lf.begin(), lf.end());
+ }
+
+ // sort the array
+ std::sort(lfiles.begin(), lfiles.end(), std::less<std::string>());
+ std::vector<std::string>::iterator new_end =
+ std::unique(lfiles.begin(), lfiles.end());
+ lfiles.erase(new_end, lfiles.end());
+ this->CurrentReRunCMakeMakefile = mf->GetStartOutputDirectory();
+ this->CurrentReRunCMakeMakefile += "/CMakeScripts";
+ cmSystemTools::MakeDirectory(this->CurrentReRunCMakeMakefile.c_str());
+ this->CurrentReRunCMakeMakefile += "/ReRunCMake.make";
+ cmGeneratedFileStream makefileStream
+ (this->CurrentReRunCMakeMakefile.c_str());
+ makefileStream.SetCopyIfDifferent(true);
+ makefileStream << "# Generated by CMake, DO NOT EDIT\n";
+ makefileStream << cmake::GetCMakeFilesDirectoryPostSlash();
+ makefileStream << "cmake.check_cache: ";
+ for(std::vector<std::string>::const_iterator i = lfiles.begin();
+ i != lfiles.end(); ++i)
+ {
+ makefileStream << "\\\n" << this->ConvertToRelativeForMake(i->c_str());
+ }
+ std::string cmake = mf->GetRequiredDefinition("CMAKE_COMMAND");
+ makefileStream << "\n\t" << this->ConvertToRelativeForMake(cmake.c_str())
+ << " -H" << this->ConvertToRelativeForMake(
+ mf->GetHomeDirectory())
+ << " -B" << this->ConvertToRelativeForMake(
+ mf->GetHomeOutputDirectory()) << "\n";
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalXCodeGenerator::ClearXCodeObjects()
+{
+ this->TargetDoneSet.clear();
+ for(unsigned int i = 0; i < this->XCodeObjects.size(); ++i)
+ {
+ delete this->XCodeObjects[i];
+ }
+ this->XCodeObjects.clear();
+ this->XCodeObjectIDs.clear();
+ this->GroupMap.clear();
+ this->GroupNameMap.clear();
+ this->TargetGroup.clear();
+ this->FileRefs.clear();
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalXCodeGenerator::addObject(cmXCodeObject *obj)
+{
+ if(obj->GetType() == cmXCodeObject::OBJECT)
+ {
+ cmStdString id = obj->GetId();
+
+ // If this is a duplicate id, it's an error:
+ //
+ if(this->XCodeObjectIDs.count(id))
+ {
+ cmSystemTools::Error(
+ "Xcode generator: duplicate object ids not allowed");
+ }
+
+ this->XCodeObjectIDs.insert(id);
+ }
+
+ this->XCodeObjects.push_back(obj);
+}
+
+//----------------------------------------------------------------------------
+cmXCodeObject*
+cmGlobalXCodeGenerator::CreateObject(cmXCodeObject::PBXType ptype)
+{
+ cmXCodeObject* obj;
+ if(this->XcodeVersion == 15)
+ {
+ obj = new cmXCodeObject(ptype, cmXCodeObject::OBJECT);
+ }
+ else
+ {
+ obj = new cmXCode21Object(ptype, cmXCodeObject::OBJECT);
+ }
+ this->addObject(obj);
+ return obj;
+}
+
+//----------------------------------------------------------------------------
+cmXCodeObject*
+cmGlobalXCodeGenerator::CreateObject(cmXCodeObject::Type type)
+{
+ cmXCodeObject* obj = new cmXCodeObject(cmXCodeObject::None, type);
+ this->addObject(obj);
+ return obj;
+}
+
+//----------------------------------------------------------------------------
+cmXCodeObject*
+cmGlobalXCodeGenerator::CreateString(const char* s)
+{
+ cmXCodeObject* obj = this->CreateObject(cmXCodeObject::STRING);
+ obj->SetString(s);
+ return obj;
+}
+
+//----------------------------------------------------------------------------
+cmXCodeObject* cmGlobalXCodeGenerator
+::CreateObjectReference(cmXCodeObject* ref)
+{
+ cmXCodeObject* obj = this->CreateObject(cmXCodeObject::OBJECT_REF);
+ obj->SetObject(ref);
+ return obj;
+}
+
+//----------------------------------------------------------------------------
+cmStdString
+GetGroupMapKeyFromPath(cmTarget& cmtarget, const std::string& fullpath)
+{
+ cmStdString key(cmtarget.GetName());
+ key += "-";
+ key += fullpath;
+ return key;
+}
+
+//----------------------------------------------------------------------------
+cmStdString
+GetGroupMapKey(cmTarget& cmtarget, cmSourceFile* sf)
+{
+ return GetGroupMapKeyFromPath(cmtarget, sf->GetFullPath());
+}
+
+//----------------------------------------------------------------------------
+cmXCodeObject*
+cmGlobalXCodeGenerator::CreateXCodeSourceFileFromPath(
+ const std::string &fullpath,
+ cmTarget& cmtarget,
+ const std::string &lang)
+{
+ // Using a map and the full path guarantees that we will always get the same
+ // fileRef object for any given full path.
+ //
+ cmXCodeObject* fileRef =
+ this->CreateXCodeFileReferenceFromPath(fullpath, cmtarget, lang);
+
+ cmXCodeObject* buildFile = this->CreateObject(cmXCodeObject::PBXBuildFile);
+ buildFile->SetComment(fileRef->GetComment());
+ buildFile->AddAttribute("fileRef", this->CreateObjectReference(fileRef));
+
+ return buildFile;
+}
+
+//----------------------------------------------------------------------------
+cmXCodeObject*
+cmGlobalXCodeGenerator::CreateXCodeSourceFile(cmLocalGenerator* lg,
+ cmSourceFile* sf,
+ cmTarget& cmtarget)
+{
+ // Add flags from target and source file properties.
+ std::string flags;
+ if(cmtarget.GetProperty("COMPILE_FLAGS"))
+ {
+ lg->AppendFlags(flags, cmtarget.GetProperty("COMPILE_FLAGS"));
+ }
+ const char* srcfmt = sf->GetProperty("Fortran_FORMAT");
+ switch(this->CurrentLocalGenerator->GetFortranFormat(srcfmt))
+ {
+ case cmLocalGenerator::FortranFormatFixed: flags="-fixed "+flags; break;
+ case cmLocalGenerator::FortranFormatFree: flags="-free "+flags; break;
+ default: break;
+ }
+ lg->AppendFlags(flags, sf->GetProperty("COMPILE_FLAGS"));
+
+ // Add per-source definitions.
+ BuildObjectListOrString flagsBuild(this, false);
+ this->AppendDefines(flagsBuild,
+ sf->GetProperty("COMPILE_DEFINITIONS"), true);
+ if (!flagsBuild.IsEmpty())
+ {
+ if (flags.size())
+ {
+ flags += ' ';
+ }
+ flags += flagsBuild.GetString();
+ }
+
+ const char* lang =
+ this->CurrentLocalGenerator->GetSourceFileLanguage(*sf);
+ if (!lang)
+ {
+ lang = "";
+ }
+
+ cmXCodeObject* buildFile =
+ this->CreateXCodeSourceFileFromPath(sf->GetFullPath(), cmtarget, lang);
+ cmXCodeObject* fileRef = buildFile->GetObject("fileRef")->GetObject();
+
+ cmXCodeObject* settings =
+ this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
+ settings->AddAttribute("COMPILER_FLAGS", this->CreateString(flags.c_str()));
+
+ // Is this a resource file in this target? Add it to the resources group...
+ //
+ cmTarget::SourceFileFlags tsFlags = cmtarget.GetTargetSourceFileFlags(sf);
+ bool isResource = (tsFlags.Type == cmTarget::SourceFileTypeResource);
+
+ // Is this a "private" or "public" framework header file?
+ // Set the ATTRIBUTES attribute appropriately...
+ //
+ if(cmtarget.IsFrameworkOnApple())
+ {
+ if(tsFlags.Type == cmTarget::SourceFileTypePrivateHeader)
+ {
+ cmXCodeObject* attrs = this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ attrs->AddObject(this->CreateString("Private"));
+ settings->AddAttribute("ATTRIBUTES", attrs);
+ isResource = true;
+ }
+ else if(tsFlags.Type == cmTarget::SourceFileTypePublicHeader)
+ {
+ cmXCodeObject* attrs = this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ attrs->AddObject(this->CreateString("Public"));
+ settings->AddAttribute("ATTRIBUTES", attrs);
+ isResource = true;
+ }
+ }
+
+ if(cmtarget.IsCFBundleOnApple())
+ {
+ cmtarget.SetProperty("PREFIX", "");
+ cmtarget.SetProperty("SUFFIX", "");
+ }
+
+ // Add the fileRef to the top level Resources group/folder if it is not
+ // already there.
+ //
+ if(isResource && this->ResourcesGroupChildren &&
+ !this->ResourcesGroupChildren->HasObject(fileRef))
+ {
+ this->ResourcesGroupChildren->AddObject(fileRef);
+ }
+
+ buildFile->AddAttribute("settings", settings);
+ return buildFile;
+}
+
+//----------------------------------------------------------------------------
+std::string
+GetSourcecodeValueFromFileExtension(const std::string& _ext,
+ const std::string& lang)
+{
+ std::string ext = cmSystemTools::LowerCase(_ext);
+ std::string sourcecode = "sourcecode";
+
+ if(ext == "o")
+ {
+ sourcecode = "compiled.mach-o.objfile";
+ }
+ else if(ext == "xib")
+ {
+ sourcecode = "file.xib";
+ }
+ else if(ext == "storyboard")
+ {
+ sourcecode = "file.storyboard";
+ }
+ else if(ext == "mm")
+ {
+ sourcecode += ".cpp.objcpp";
+ }
+ else if(ext == "m")
+ {
+ sourcecode += ".c.objc";
+ }
+ else if(ext == "xib")
+ {
+ sourcecode += ".file.xib";
+ }
+ else if(ext == "plist")
+ {
+ sourcecode += ".text.plist";
+ }
+ else if(ext == "h")
+ {
+ sourcecode += ".c.h";
+ }
+ else if(ext == "hxx" || ext == "hpp" || ext == "txx"
+ || ext == "pch" || ext == "hh")
+ {
+ sourcecode += ".cpp.h";
+ }
+ else if(ext == "png" || ext == "gif" || ext == "jpg")
+ {
+ sourcecode = "image";
+ }
+ else if(ext == "txt")
+ {
+ sourcecode += ".text";
+ }
+ else if(lang == "CXX")
+ {
+ sourcecode += ".cpp.cpp";
+ }
+ else if(lang == "C")
+ {
+ sourcecode += ".c.c";
+ }
+ else if(lang == "Fortran")
+ {
+ sourcecode += ".fortran.f90";
+ }
+ //else
+ // {
+ // // Already specialized above or we leave sourcecode == "sourcecode"
+ // // which is probably the most correct choice. Extensionless headers,
+ // // for example... Or file types unknown to Xcode that do not map to a
+ // // valid lastKnownFileType value.
+ // }
+
+ return sourcecode;
+}
+
+//----------------------------------------------------------------------------
+cmXCodeObject*
+cmGlobalXCodeGenerator::CreateXCodeFileReferenceFromPath(
+ const std::string &fullpath,
+ cmTarget& cmtarget,
+ const std::string &lang)
+{
+ std::string fname = fullpath;
+ cmXCodeObject* fileRef = this->FileRefs[fname];
+ if(!fileRef)
+ {
+ fileRef = this->CreateObject(cmXCodeObject::PBXFileReference);
+ std::string comment = fname;
+ fileRef->SetComment(fname.c_str());
+ this->FileRefs[fname] = fileRef;
+ }
+ cmStdString key = GetGroupMapKeyFromPath(cmtarget, fullpath);
+ cmXCodeObject* group = this->GroupMap[key];
+ cmXCodeObject* children = group->GetObject("children");
+ if (!children->HasObject(fileRef))
+ {
+ children->AddObject(fileRef);
+ }
+ fileRef->AddAttribute("fileEncoding", this->CreateString("4"));
+
+ // Compute the extension.
+ std::string ext;
+ std::string realExt =
+ cmSystemTools::GetFilenameLastExtension(fullpath);
+ if(!realExt.empty())
+ {
+ // Extension without the leading '.'.
+ ext = realExt.substr(1);
+ }
+
+ std::string sourcecode = GetSourcecodeValueFromFileExtension(ext, lang);
+
+ fileRef->AddAttribute("lastKnownFileType",
+ this->CreateString(sourcecode.c_str()));
+
+ // Store the file path relative to the top of the source tree.
+ std::string path = this->RelativeToSource(fullpath.c_str());
+ std::string name = cmSystemTools::GetFilenameName(path.c_str());
+ const char* sourceTree = (cmSystemTools::FileIsFullPath(path.c_str())?
+ "<absolute>" : "SOURCE_ROOT");
+ fileRef->AddAttribute("name", this->CreateString(name.c_str()));
+ fileRef->AddAttribute("path", this->CreateString(path.c_str()));
+ fileRef->AddAttribute("sourceTree", this->CreateString(sourceTree));
+ if(this->XcodeVersion == 15)
+ {
+ fileRef->AddAttribute("refType", this->CreateString("4"));
+ }
+ return fileRef;
+}
+
+//----------------------------------------------------------------------------
+cmXCodeObject*
+cmGlobalXCodeGenerator::CreateXCodeFileReference(cmSourceFile* sf,
+ cmTarget& cmtarget)
+{
+ const char* lang =
+ this->CurrentLocalGenerator->GetSourceFileLanguage(*sf);
+ if (!lang)
+ {
+ lang = "";
+ }
+
+ return this->CreateXCodeFileReferenceFromPath(
+ sf->GetFullPath(), cmtarget, lang);
+}
+
+//----------------------------------------------------------------------------
+bool cmGlobalXCodeGenerator::SpecialTargetEmitted(std::string const& tname)
+{
+ if(tname == "ALL_BUILD" || tname == "XCODE_DEPEND_HELPER" ||
+ tname == "install" || tname == "package" || tname == "RUN_TESTS" ||
+ tname == CMAKE_CHECK_BUILD_SYSTEM_TARGET )
+ {
+ if(this->TargetDoneSet.find(tname) != this->TargetDoneSet.end())
+ {
+ return true;
+ }
+ this->TargetDoneSet.insert(tname);
+ return false;
+ }
+ return false;
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalXCodeGenerator::SetCurrentLocalGenerator(cmLocalGenerator* gen)
+{
+ this->CurrentLocalGenerator = gen;
+ this->CurrentMakefile = gen->GetMakefile();
+ std::string outdir =
+ cmSystemTools::CollapseFullPath(this->CurrentMakefile->
+ GetCurrentOutputDirectory());
+ cmSystemTools::SplitPath(outdir.c_str(),
+ this->CurrentOutputDirectoryComponents);
+
+ // Select the current set of configuration types.
+ this->CurrentConfigurationTypes.clear();
+ this->CurrentMakefile->GetConfigurations(this->CurrentConfigurationTypes);
+ if(this->CurrentConfigurationTypes.empty())
+ {
+ this->CurrentConfigurationTypes.push_back("");
+ }
+}
+
+//----------------------------------------------------------------------------
+void
+cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
+ std::vector<cmXCodeObject*>&
+ targets)
+{
+ this->SetCurrentLocalGenerator(gen);
+ cmTargets &tgts = this->CurrentMakefile->GetTargets();
+ for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); l++)
+ {
+ cmTarget& cmtarget = l->second;
+
+ // make sure ALL_BUILD, INSTALL, etc are only done once
+ if(this->SpecialTargetEmitted(l->first.c_str()))
+ {
+ continue;
+ }
+
+ if(cmtarget.GetType() == cmTarget::UTILITY ||
+ cmtarget.GetType() == cmTarget::GLOBAL_TARGET)
+ {
+ targets.push_back(this->CreateUtilityTarget(cmtarget));
+ continue;
+ }
+
+ // organize the sources
+ std::vector<cmSourceFile*> const &classes = cmtarget.GetSourceFiles();
+ std::vector<cmXCodeObject*> externalObjFiles;
+ std::vector<cmXCodeObject*> headerFiles;
+ std::vector<cmXCodeObject*> resourceFiles;
+ std::vector<cmXCodeObject*> sourceFiles;
+ for(std::vector<cmSourceFile*>::const_iterator i = classes.begin();
+ i != classes.end(); ++i)
+ {
+ cmXCodeObject* xsf =
+ this->CreateXCodeSourceFile(this->CurrentLocalGenerator,
+ *i, cmtarget);
+ cmXCodeObject* fr = xsf->GetObject("fileRef");
+ cmXCodeObject* filetype =
+ fr->GetObject()->GetObject("lastKnownFileType");
+
+ cmTarget::SourceFileFlags tsFlags =
+ cmtarget.GetTargetSourceFileFlags(*i);
+
+ if(strcmp(filetype->GetString(), "compiled.mach-o.objfile") == 0)
+ {
+ externalObjFiles.push_back(xsf);
+ }
+ else if(this->IsHeaderFile(*i) ||
+ (tsFlags.Type == cmTarget::SourceFileTypePrivateHeader) ||
+ (tsFlags.Type == cmTarget::SourceFileTypePublicHeader))
+ {
+ headerFiles.push_back(xsf);
+ }
+ else if(tsFlags.Type == cmTarget::SourceFileTypeResource)
+ {
+ resourceFiles.push_back(xsf);
+ }
+ else if(!(*i)->GetPropertyAsBool("HEADER_FILE_ONLY"))
+ {
+ // Include this file in the build if it has a known language
+ // and has not been listed as an ignored extension for this
+ // generator.
+ if(this->CurrentLocalGenerator->GetSourceFileLanguage(**i) &&
+ !this->IgnoreFile((*i)->GetExtension().c_str()))
+ {
+ sourceFiles.push_back(xsf);
+ }
+ }
+ }
+
+ // Add object library contents as external objects. (Equivalent to
+ // the externalObjFiles above, except each one is not a cmSourceFile
+ // within the target.)
+ std::vector<std::string> objs;
+ this->GetGeneratorTarget(&cmtarget)->UseObjectLibraries(objs);
+ for(std::vector<std::string>::const_iterator
+ oi = objs.begin(); oi != objs.end(); ++oi)
+ {
+ std::string obj = *oi;
+ cmXCodeObject* xsf =
+ this->CreateXCodeSourceFileFromPath(obj, cmtarget, "");
+ externalObjFiles.push_back(xsf);
+ }
+
+ // some build phases only apply to bundles and/or frameworks
+ bool isFrameworkTarget = cmtarget.IsFrameworkOnApple();
+ bool isBundleTarget = cmtarget.GetPropertyAsBool("MACOSX_BUNDLE");
+ bool isCFBundleTarget = cmtarget.IsCFBundleOnApple();
+
+ cmXCodeObject* buildFiles = 0;
+
+ // create source build phase
+ cmXCodeObject* sourceBuildPhase = 0;
+ if (!sourceFiles.empty())
+ {
+ sourceBuildPhase =
+ this->CreateObject(cmXCodeObject::PBXSourcesBuildPhase);
+ sourceBuildPhase->SetComment("Sources");
+ sourceBuildPhase->AddAttribute("buildActionMask",
+ this->CreateString("2147483647"));
+ buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ for(std::vector<cmXCodeObject*>::iterator i = sourceFiles.begin();
+ i != sourceFiles.end(); ++i)
+ {
+ buildFiles->AddObject(*i);
+ }
+ sourceBuildPhase->AddAttribute("files", buildFiles);
+ sourceBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
+ this->CreateString("0"));
+ }
+
+ // create header build phase - only for framework targets
+ cmXCodeObject* headerBuildPhase = 0;
+ if (!headerFiles.empty() && isFrameworkTarget)
+ {
+ headerBuildPhase =
+ this->CreateObject(cmXCodeObject::PBXHeadersBuildPhase);
+ headerBuildPhase->SetComment("Headers");
+ headerBuildPhase->AddAttribute("buildActionMask",
+ this->CreateString("2147483647"));
+ buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ for(std::vector<cmXCodeObject*>::iterator i = headerFiles.begin();
+ i != headerFiles.end(); ++i)
+ {
+ buildFiles->AddObject(*i);
+ }
+ headerBuildPhase->AddAttribute("files", buildFiles);
+ headerBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
+ this->CreateString("0"));
+ }
+
+ // create resource build phase - only for framework or bundle targets
+ cmXCodeObject* resourceBuildPhase = 0;
+ if (!resourceFiles.empty() &&
+ (isFrameworkTarget || isBundleTarget || isCFBundleTarget))
+ {
+ resourceBuildPhase =
+ this->CreateObject(cmXCodeObject::PBXResourcesBuildPhase);
+ resourceBuildPhase->SetComment("Resources");
+ resourceBuildPhase->AddAttribute("buildActionMask",
+ this->CreateString("2147483647"));
+ buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ for(std::vector<cmXCodeObject*>::iterator i = resourceFiles.begin();
+ i != resourceFiles.end(); ++i)
+ {
+ buildFiles->AddObject(*i);
+ }
+ resourceBuildPhase->AddAttribute("files", buildFiles);
+ resourceBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
+ this->CreateString("0"));
+ }
+
+ // create vector of "non-resource content file" build phases - only for
+ // framework or bundle targets
+ std::vector<cmXCodeObject*> contentBuildPhases;
+ if (isFrameworkTarget || isBundleTarget || isCFBundleTarget)
+ {
+ typedef std::map<cmStdString, std::vector<cmSourceFile*> >
+ mapOfVectorOfSourceFiles;
+ mapOfVectorOfSourceFiles bundleFiles;
+ for(std::vector<cmSourceFile*>::const_iterator i = classes.begin();
+ i != classes.end(); ++i)
+ {
+ cmTarget::SourceFileFlags tsFlags =
+ cmtarget.GetTargetSourceFileFlags(*i);
+ if(tsFlags.Type == cmTarget::SourceFileTypeMacContent)
+ {
+ bundleFiles[tsFlags.MacFolder].push_back(*i);
+ }
+ }
+ mapOfVectorOfSourceFiles::iterator mit;
+ for ( mit = bundleFiles.begin(); mit != bundleFiles.end(); ++ mit )
+ {
+ cmXCodeObject* copyFilesBuildPhase =
+ this->CreateObject(cmXCodeObject::PBXCopyFilesBuildPhase);
+ copyFilesBuildPhase->SetComment("Copy files");
+ copyFilesBuildPhase->AddAttribute("buildActionMask",
+ this->CreateString("2147483647"));
+ copyFilesBuildPhase->AddAttribute("dstSubfolderSpec",
+ this->CreateString("6"));
+ cmOStringStream ostr;
+ if (cmtarget.IsFrameworkOnApple())
+ {
+ // dstPath in frameworks is relative to Versions/<version>
+ ostr << mit->first;
+ }
+ else if ( mit->first != "MacOS" )
+ {
+ // dstPath in bundles is relative to Contents/MacOS
+ ostr << "../" << mit->first.c_str();
+ }
+ copyFilesBuildPhase->AddAttribute("dstPath",
+ this->CreateString(ostr.str().c_str()));
+ copyFilesBuildPhase->AddAttribute(
+ "runOnlyForDeploymentPostprocessing", this->CreateString("0"));
+ buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ copyFilesBuildPhase->AddAttribute("files", buildFiles);
+ std::vector<cmSourceFile*>::iterator sfIt;
+ for ( sfIt = mit->second.begin(); sfIt != mit->second.end(); ++ sfIt )
+ {
+ cmXCodeObject* xsf =
+ this->CreateXCodeSourceFile(this->CurrentLocalGenerator,
+ *sfIt, cmtarget);
+ buildFiles->AddObject(xsf);
+ }
+ contentBuildPhases.push_back(copyFilesBuildPhase);
+ }
+ }
+
+ // create framework build phase
+ cmXCodeObject* frameworkBuildPhase = 0;
+ if (!externalObjFiles.empty())
+ {
+ frameworkBuildPhase =
+ this->CreateObject(cmXCodeObject::PBXFrameworksBuildPhase);
+ frameworkBuildPhase->SetComment("Frameworks");
+ frameworkBuildPhase->AddAttribute("buildActionMask",
+ this->CreateString("2147483647"));
+ buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ frameworkBuildPhase->AddAttribute("files", buildFiles);
+ for(std::vector<cmXCodeObject*>::iterator i = externalObjFiles.begin();
+ i != externalObjFiles.end(); ++i)
+ {
+ buildFiles->AddObject(*i);
+ }
+ frameworkBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
+ this->CreateString("0"));
+ }
+
+ // create list of build phases and create the Xcode target
+ cmXCodeObject* buildPhases =
+ this->CreateObject(cmXCodeObject::OBJECT_LIST);
+
+ this->CreateCustomCommands(buildPhases, sourceBuildPhase,
+ headerBuildPhase, resourceBuildPhase,
+ contentBuildPhases,
+ frameworkBuildPhase, cmtarget);
+
+ targets.push_back(this->CreateXCodeTarget(cmtarget, buildPhases));
+ }
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalXCodeGenerator::ForceLinkerLanguages()
+{
+ // This makes sure all targets link using the proper language.
+ for(std::map<cmStdString, cmTarget*>::const_iterator
+ ti = this->TotalTargets.begin(); ti != this->TotalTargets.end(); ++ti)
+ {
+ this->ForceLinkerLanguage(*ti->second);
+ }
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalXCodeGenerator::ForceLinkerLanguage(cmTarget& cmtarget)
+{
+ // This matters only for targets that link.
+ if(cmtarget.GetType() != cmTarget::EXECUTABLE &&
+ cmtarget.GetType() != cmTarget::SHARED_LIBRARY &&
+ cmtarget.GetType() != cmTarget::MODULE_LIBRARY)
+ {
+ return;
+ }
+
+ const char* llang = cmtarget.GetLinkerLanguage("NOCONFIG");
+ if(!llang) { return; }
+
+ // If the language is compiled as a source trust Xcode to link with it.
+ cmTarget::LinkImplementation const* impl =
+ cmtarget.GetLinkImplementation("NOCONFIG");
+ for(std::vector<std::string>::const_iterator li = impl->Languages.begin();
+ li != impl->Languages.end(); ++li)
+ {
+ if(*li == llang) { return; }
+ }
+
+ // Add an empty source file to the target that compiles with the
+ // linker language. This should convince Xcode to choose the proper
+ // language.
+ cmMakefile* mf = cmtarget.GetMakefile();
+ std::string fname = mf->GetCurrentOutputDirectory();
+ fname += cmake::GetCMakeFilesDirectory();
+ fname += "/";
+ fname += cmtarget.GetName();
+ fname += "-CMakeForceLinker";
+ fname += ".";
+ fname += cmSystemTools::LowerCase(llang);
+ {
+ cmGeneratedFileStream fout(fname.c_str());
+ fout << "\n";
+ }
+ if(cmSourceFile* sf = mf->GetOrCreateSource(fname.c_str()))
+ {
+ sf->SetProperty("LANGUAGE", llang);
+ cmtarget.AddSourceFile(sf);
+ }
+}
+
+//----------------------------------------------------------------------------
+bool cmGlobalXCodeGenerator::IsHeaderFile(cmSourceFile* sf)
+{
+ const std::vector<std::string>& hdrExts =
+ this->CurrentMakefile->GetHeaderExtensions();
+ return (std::find(hdrExts.begin(), hdrExts.end(), sf->GetExtension()) !=
+ hdrExts.end());
+}
+
+//----------------------------------------------------------------------------
+cmXCodeObject*
+cmGlobalXCodeGenerator::CreateBuildPhase(const char* name,
+ const char* name2,
+ cmTarget& cmtarget,
+ const std::vector<cmCustomCommand>&
+ commands)
+{
+ if(commands.size() == 0 && strcmp(name, "CMake ReRun") != 0)
+ {
+ return 0;
+ }
+ cmXCodeObject* buildPhase =
+ this->CreateObject(cmXCodeObject::PBXShellScriptBuildPhase);
+ buildPhase->AddAttribute("buildActionMask",
+ this->CreateString("2147483647"));
+ cmXCodeObject* buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ buildPhase->AddAttribute("files", buildFiles);
+ buildPhase->AddAttribute("name",
+ this->CreateString(name));
+ buildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
+ this->CreateString("0"));
+ buildPhase->AddAttribute("shellPath",
+ this->CreateString("/bin/sh"));
+ this->AddCommandsToBuildPhase(buildPhase, cmtarget, commands,
+ name2);
+ return buildPhase;
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalXCodeGenerator::CreateCustomCommands(cmXCodeObject* buildPhases,
+ cmXCodeObject*
+ sourceBuildPhase,
+ cmXCodeObject*
+ headerBuildPhase,
+ cmXCodeObject*
+ resourceBuildPhase,
+ std::vector<cmXCodeObject*>
+ contentBuildPhases,
+ cmXCodeObject*
+ frameworkBuildPhase,
+ cmTarget& cmtarget)
+{
+ std::vector<cmCustomCommand> const & prebuild
+ = cmtarget.GetPreBuildCommands();
+ std::vector<cmCustomCommand> const & prelink
+ = cmtarget.GetPreLinkCommands();
+ std::vector<cmCustomCommand> const & postbuild
+ = cmtarget.GetPostBuildCommands();
+ std::vector<cmSourceFile*>const &classes = cmtarget.GetSourceFiles();
+ // add all the sources
+ std::vector<cmCustomCommand> commands;
+ for(std::vector<cmSourceFile*>::const_iterator i = classes.begin();
+ i != classes.end(); ++i)
+ {
+ if((*i)->GetCustomCommand())
+ {
+ commands.push_back(*(*i)->GetCustomCommand());
+ }
+ }
+ // create prebuild phase
+ cmXCodeObject* cmakeRulesBuildPhase =
+ this->CreateBuildPhase("CMake Rules",
+ "cmakeRulesBuildPhase",
+ cmtarget, commands);
+ // create prebuild phase
+ cmXCodeObject* preBuildPhase =
+ this->CreateBuildPhase("CMake PreBuild Rules", "preBuildCommands",
+ cmtarget, prebuild);
+ // create prelink phase
+ cmXCodeObject* preLinkPhase =
+ this->CreateBuildPhase("CMake PreLink Rules", "preLinkCommands",
+ cmtarget, prelink);
+ // create postbuild phase
+ cmXCodeObject* postBuildPhase =
+ this->CreateBuildPhase("CMake PostBuild Rules", "postBuildPhase",
+ cmtarget, postbuild);
+
+ // The order here is the order they will be built in.
+ // The order "headers, resources, sources" mimics a native project generated
+ // from an xcode template...
+ //
+ if(preBuildPhase)
+ {
+ buildPhases->AddObject(preBuildPhase);
+ }
+ if(cmakeRulesBuildPhase)
+ {
+ buildPhases->AddObject(cmakeRulesBuildPhase);
+ }
+ if(headerBuildPhase)
+ {
+ buildPhases->AddObject(headerBuildPhase);
+ }
+ if(resourceBuildPhase)
+ {
+ buildPhases->AddObject(resourceBuildPhase);
+ }
+ std::vector<cmXCodeObject*>::iterator cit;
+ for (cit = contentBuildPhases.begin(); cit != contentBuildPhases.end();
+ ++cit)
+ {
+ buildPhases->AddObject(*cit);
+ }
+ if(sourceBuildPhase)
+ {
+ buildPhases->AddObject(sourceBuildPhase);
+ }
+ if(preLinkPhase)
+ {
+ buildPhases->AddObject(preLinkPhase);
+ }
+ if(frameworkBuildPhase)
+ {
+ buildPhases->AddObject(frameworkBuildPhase);
+ }
+ if(postBuildPhase)
+ {
+ buildPhases->AddObject(postBuildPhase);
+ }
+}
+
+//----------------------------------------------------------------------------
+// This function removes each occurence of the flag and returns the last one
+// (i.e., the dominant flag in GCC)
+std::string cmGlobalXCodeGenerator::ExtractFlag(const char* flag,
+ std::string& flags)
+{
+ std::string retFlag;
+ std::string::size_type pos = flags.rfind(flag);
+ bool saved = false;
+ while(pos != flags.npos)
+ {
+ if(pos == 0 || flags[pos-1]==' ')
+ {
+ while(pos < flags.size() && flags[pos] != ' ')
+ {
+ if(!saved)
+ {
+ retFlag += flags[pos];
+ }
+ flags[pos] = ' ';
+ pos++;
+ }
+ }
+ saved = true;
+ pos = flags.rfind(flag);
+ }
+ return retFlag;
+}
+
+//----------------------------------------------------------------------------
+void
+cmGlobalXCodeGenerator::AddCommandsToBuildPhase(cmXCodeObject* buildphase,
+ cmTarget& target,
+ std::vector<cmCustomCommand>
+ const & commands,
+ const char* name)
+{
+
+ // collect multiple outputs of custom commands into a set
+ // which will be used for every configuration
+ std::map<cmStdString, cmStdString> multipleOutputPairs;
+ for(std::vector<cmCustomCommand>::const_iterator i = commands.begin();
+ i != commands.end(); ++i)
+ {
+ cmCustomCommand const& cc = *i;
+ if(!cc.GetCommandLines().empty())
+ {
+ const std::vector<std::string>& outputs = cc.GetOutputs();
+ if(!outputs.empty())
+ {
+ // If there are more than one outputs treat the
+ // first as the primary output and make the rest depend on it.
+ std::vector<std::string>::const_iterator o = outputs.begin();
+ std::string primaryOutput = this->ConvertToRelativeForMake(o->c_str());
+ for(++o; o != outputs.end(); ++o)
+ {
+ std::string currentOutput=this->ConvertToRelativeForMake(o->c_str());
+ multipleOutputPairs[currentOutput] = primaryOutput;
+ }
+ }
+ }
+ }
+
+ std::string dir = this->CurrentMakefile->GetCurrentOutputDirectory();
+ dir += "/CMakeScripts";
+ cmSystemTools::MakeDirectory(dir.c_str());
+ std::string makefile = dir;
+ makefile += "/";
+ makefile += target.GetName();
+ makefile += "_";
+ makefile += name;
+ makefile += ".make";
+
+ for (std::vector<std::string>::const_iterator currentConfig=
+ this->CurrentConfigurationTypes.begin();
+ currentConfig!=this->CurrentConfigurationTypes.end();
+ currentConfig++ )
+ {
+ this->CreateCustomRulesMakefile(makefile.c_str(),
+ target,
+ commands,
+ currentConfig->c_str(),
+ multipleOutputPairs);
+ }
+
+ std::string cdir = this->CurrentMakefile->GetCurrentOutputDirectory();
+ cdir = this->ConvertToRelativeForXCode(cdir.c_str());
+ std::string makecmd = "make -C ";
+ makecmd += cdir;
+ makecmd += " -f ";
+ makecmd += this->ConvertToRelativeForMake(
+ (makefile+"$CONFIGURATION").c_str());
+ if(!multipleOutputPairs.empty())
+ {
+ makecmd += " cmake_check_multiple_outputs";
+ }
+ makecmd += " all";
+ cmSystemTools::ReplaceString(makecmd, "\\ ", "\\\\ ");
+ buildphase->AddAttribute("shellScript",
+ this->CreateString(makecmd.c_str()));
+ buildphase->AddAttribute("showEnvVarsInLog",
+ this->CreateString("0"));
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalXCodeGenerator
+::CreateCustomRulesMakefile(const char* makefileBasename,
+ cmTarget& target,
+ std::vector<cmCustomCommand>
+ const & commands,
+ const char* configName,
+ const std::map<cmStdString,
+ cmStdString>& multipleOutputPairs
+ )
+{
+ std::string makefileName=makefileBasename;
+ if(this->XcodeVersion > 20)
+ {
+ makefileName+=configName;
+ }
+ cmGeneratedFileStream makefileStream(makefileName.c_str());
+ if(!makefileStream)
+ {
+ return;
+ }
+ makefileStream.SetCopyIfDifferent(true);
+ makefileStream << "# Generated by CMake, DO NOT EDIT\n";
+ makefileStream << "# Custom rules for " << target.GetName() << "\n";
+
+ // disable the implicit rules
+ makefileStream << ".SUFFIXES: " << "\n";
+
+ // have all depend on all outputs
+ makefileStream << "all: ";
+ std::map<const cmCustomCommand*, cmStdString> tname;
+ int count = 0;
+ for(std::vector<cmCustomCommand>::const_iterator i = commands.begin();
+ i != commands.end(); ++i)
+ {
+ cmCustomCommand const& cc = *i;
+ if(!cc.GetCommandLines().empty())
+ {
+ const std::vector<std::string>& outputs = cc.GetOutputs();
+ if(!outputs.empty())
+ {
+ for(std::vector<std::string>::const_iterator o = outputs.begin();
+ o != outputs.end(); ++o)
+ {
+ makefileStream
+ << "\\\n\t" << this->ConvertToRelativeForMake(o->c_str());
+ }
+ }
+ else
+ {
+ cmOStringStream str;
+ str << "_buildpart_" << count++ ;
+ tname[&cc] = std::string(target.GetName()) + str.str();
+ makefileStream << "\\\n\t" << tname[&cc];
+ }
+ }
+ }
+ makefileStream << "\n\n";
+ for(std::vector<cmCustomCommand>::const_iterator i = commands.begin();
+ i != commands.end(); ++i)
+ {
+ cmCustomCommand const& cc = *i;
+ if(!cc.GetCommandLines().empty())
+ {
+ cmCustomCommandGenerator ccg(cc, configName, this->CurrentMakefile);
+ makefileStream << "\n";
+ const std::vector<std::string>& outputs = cc.GetOutputs();
+ if(!outputs.empty())
+ {
+ // There is at least one output, start the rule for it
+ std::string primary_output =
+ this->ConvertToRelativeForMake(outputs.begin()->c_str());
+ makefileStream << primary_output << ": ";
+ }
+ else
+ {
+ // There are no outputs. Use the generated force rule name.
+ makefileStream << tname[&cc] << ": ";
+ }
+ for(std::vector<std::string>::const_iterator d =
+ cc.GetDepends().begin();
+ d != cc.GetDepends().end(); ++d)
+ {
+ std::string dep;
+ if(this->CurrentLocalGenerator
+ ->GetRealDependency(d->c_str(), configName, dep))
+ {
+ makefileStream << "\\\n" <<
+ this->ConvertToRelativeForMake(dep.c_str());
+ }
+ }
+ makefileStream << "\n";
+
+ if(const char* comment = cc.GetComment())
+ {
+ std::string echo_cmd = "echo ";
+ echo_cmd += (this->CurrentLocalGenerator->
+ EscapeForShell(comment, cc.GetEscapeAllowMakeVars()));
+ makefileStream << "\t" << echo_cmd.c_str() << "\n";
+ }
+
+ // Add each command line to the set of commands.
+ for(unsigned int c = 0; c < ccg.GetNumberOfCommands(); ++c)
+ {
+ // Build the command line in a single string.
+ std::string cmd2 = ccg.GetCommand(c);
+ cmSystemTools::ReplaceString(cmd2, "/./", "/");
+ cmd2 = this->ConvertToRelativeForMake(cmd2.c_str());
+ std::string cmd;
+ if(cc.GetWorkingDirectory())
+ {
+ cmd += "cd ";
+ cmd += this->ConvertToRelativeForMake(cc.GetWorkingDirectory());
+ cmd += " && ";
+ }
+ cmd += cmd2;
+ ccg.AppendArguments(c, cmd);
+ makefileStream << "\t" << cmd.c_str() << "\n";
+ }
+ }
+ }
+
+ // Add rules to deal with multiple outputs of custom commands.
+ if(!multipleOutputPairs.empty())
+ {
+ makefileStream <<
+ "\n# Dependencies of multiple outputs to their primary outputs \n";
+
+ for(std::map<cmStdString, cmStdString>::const_iterator o =
+ multipleOutputPairs.begin(); o != multipleOutputPairs.end(); ++o)
+ {
+ makefileStream << o->first << ": " << o->second << "\n";
+ }
+
+ makefileStream <<
+ "\n"
+ "cmake_check_multiple_outputs:\n";
+ for(std::map<cmStdString, cmStdString>::const_iterator o =
+ multipleOutputPairs.begin(); o != multipleOutputPairs.end(); ++o)
+ {
+ makefileStream << "\t@if [ ! -f "
+ << o->first << " ]; then rm -f "
+ << o->second << "; fi\n";
+ }
+ }
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
+ cmXCodeObject* buildSettings,
+ const char* configName)
+{
+ std::string flags;
+ std::string defFlags;
+ bool shared = ((target.GetType() == cmTarget::SHARED_LIBRARY) ||
+ (target.GetType() == cmTarget::MODULE_LIBRARY));
+ bool binary = ((target.GetType() == cmTarget::OBJECT_LIBRARY) ||
+ (target.GetType() == cmTarget::STATIC_LIBRARY) ||
+ (target.GetType() == cmTarget::EXECUTABLE) ||
+ shared);
+
+ const char* lang = target.GetLinkerLanguage(configName);
+ std::string cflags;
+ if(lang)
+ {
+ // for c++ projects get the c flags as well
+ if(strcmp(lang, "CXX") == 0)
+ {
+ this->CurrentLocalGenerator->AddLanguageFlags(cflags, "C", configName);
+ this->CurrentLocalGenerator->AddCMP0018Flags(cflags, &target, "C");
+ }
+
+ // Add language-specific flags.
+ this->CurrentLocalGenerator->AddLanguageFlags(flags, lang, configName);
+
+ // Add shared-library flags if needed.
+ this->CurrentLocalGenerator->AddCMP0018Flags(flags, &target, lang);
+ }
+ else if(binary)
+ {
+ cmSystemTools::Error
+ ("CMake can not determine linker language for target:",
+ target.GetName());
+ return;
+ }
+
+ // Add define flags
+ this->CurrentLocalGenerator->
+ AppendFlags(defFlags,
+ this->CurrentMakefile->GetDefineFlags());
+
+ // Add preprocessor definitions for this target and configuration.
+ BuildObjectListOrString ppDefs(this, this->XcodeVersion >= 30);
+ if(this->XcodeVersion > 15)
+ {
+ this->AppendDefines(ppDefs,
+ "CMAKE_INTDIR=\"$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)\"");
+ }
+ if(const char* exportMacro = target.GetExportMacro())
+ {
+ // Add the export symbol definition for shared library objects.
+ this->AppendDefines(ppDefs, exportMacro);
+ }
+ this->AppendDefines
+ (ppDefs, this->CurrentMakefile->GetProperty("COMPILE_DEFINITIONS"));
+ this->AppendDefines(ppDefs, target.GetProperty("COMPILE_DEFINITIONS"));
+ if(configName)
+ {
+ std::string defVarName = "COMPILE_DEFINITIONS_";
+ defVarName += cmSystemTools::UpperCase(configName);
+ this->AppendDefines
+ (ppDefs, this->CurrentMakefile->GetProperty(defVarName.c_str()));
+ this->AppendDefines(ppDefs, target.GetProperty(defVarName.c_str()));
+ }
+ buildSettings->AddAttribute
+ ("GCC_PREPROCESSOR_DEFINITIONS", ppDefs.CreateList());
+
+ std::string extraLinkOptions;
+ if(target.GetType() == cmTarget::EXECUTABLE)
+ {
+ extraLinkOptions =
+ this->CurrentMakefile->GetRequiredDefinition("CMAKE_EXE_LINKER_FLAGS");
+ std::string var = "CMAKE_EXE_LINKER_FLAGS_";
+ var += cmSystemTools::UpperCase(configName);
+ std::string val =
+ this->CurrentMakefile->GetSafeDefinition(var.c_str());
+ if(val.size())
+ {
+ extraLinkOptions += " ";
+ extraLinkOptions += val;
+ }
+ }
+ if(target.GetType() == cmTarget::SHARED_LIBRARY)
+ {
+ extraLinkOptions = this->CurrentMakefile->
+ GetRequiredDefinition("CMAKE_SHARED_LINKER_FLAGS");
+ }
+ if(target.GetType() == cmTarget::MODULE_LIBRARY)
+ {
+ extraLinkOptions = this->CurrentMakefile->
+ GetRequiredDefinition("CMAKE_MODULE_LINKER_FLAGS");
+ }
+
+ const char* linkFlagsProp = "LINK_FLAGS";
+ if(target.GetType() == cmTarget::OBJECT_LIBRARY ||
+ target.GetType() == cmTarget::STATIC_LIBRARY)
+ {
+ linkFlagsProp = "STATIC_LIBRARY_FLAGS";
+ }
+ const char* targetLinkFlags = target.GetProperty(linkFlagsProp);
+ if(targetLinkFlags)
+ {
+ extraLinkOptions += " ";
+ extraLinkOptions += targetLinkFlags;
+ }
+ if(configName && *configName)
+ {
+ std::string linkFlagsVar = linkFlagsProp;
+ linkFlagsVar += "_";
+ linkFlagsVar += cmSystemTools::UpperCase(configName);
+ if(const char* linkFlags = target.GetProperty(linkFlagsVar.c_str()))
+ {
+ extraLinkOptions += " ";
+ extraLinkOptions += linkFlags;
+ }
+ }
+
+ // Set target-specific architectures.
+ std::vector<std::string> archs;
+ target.GetAppleArchs(configName, archs);
+ if(!archs.empty())
+ {
+ // Enable ARCHS attribute.
+ buildSettings->AddAttribute("ONLY_ACTIVE_ARCH",
+ this->CreateString("NO"));
+
+ // Store ARCHS value.
+ if(archs.size() == 1)
+ {
+ buildSettings->AddAttribute("ARCHS",
+ this->CreateString(archs[0].c_str()));
+ }
+ else
+ {
+ cmXCodeObject* archObjects =
+ this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ for(std::vector<std::string>::iterator i = archs.begin();
+ i != archs.end(); i++)
+ {
+ archObjects->AddObject(this->CreateString((*i).c_str()));
+ }
+ buildSettings->AddAttribute("ARCHS", archObjects);
+ }
+ }
+
+ // Get the product name components.
+ std::string pnprefix;
+ std::string pnbase;
+ std::string pnsuffix;
+
+ target.GetFullNameComponents(pnprefix, pnbase, pnsuffix, configName);
+
+ // Set attributes to specify the proper name for the target.
+ std::string pndir = this->CurrentMakefile->GetCurrentOutputDirectory();
+ if(target.GetType() == cmTarget::STATIC_LIBRARY ||
+ target.GetType() == cmTarget::SHARED_LIBRARY ||
+ target.GetType() == cmTarget::MODULE_LIBRARY ||
+ target.GetType() == cmTarget::EXECUTABLE)
+ {
+ if(this->XcodeVersion >= 21)
+ {
+ if(!target.UsesDefaultOutputDir(configName, false))
+ {
+ std::string pncdir = target.GetDirectory(configName);
+ buildSettings->AddAttribute("CONFIGURATION_BUILD_DIR",
+ this->CreateString(pncdir.c_str()));
+ }
+ }
+ else
+ {
+ buildSettings->AddAttribute("OBJROOT",
+ this->CreateString(pndir.c_str()));
+ pndir = target.GetDirectory(configName);
+ }
+
+ buildSettings->AddAttribute("EXECUTABLE_PREFIX",
+ this->CreateString(pnprefix.c_str()));
+ buildSettings->AddAttribute("EXECUTABLE_SUFFIX",
+ this->CreateString(pnsuffix.c_str()));
+ }
+ else if(target.GetType() == cmTarget::OBJECT_LIBRARY)
+ {
+ pnprefix = "lib";
+ pnbase = target.GetName();
+ pnsuffix = ".a";
+
+ if(this->XcodeVersion >= 21)
+ {
+ std::string pncdir = this->GetObjectsNormalDirectory(
+ this->CurrentProject, configName, &target);
+ buildSettings->AddAttribute("CONFIGURATION_BUILD_DIR",
+ this->CreateString(pncdir.c_str()));
+ }
+ else
+ {
+ buildSettings->AddAttribute("OBJROOT",
+ this->CreateString(pndir.c_str()));
+ pndir = this->GetObjectsNormalDirectory(
+ this->CurrentProject, configName, &target);
+ }
+ }
+
+ // Store the product name for all target types.
+ buildSettings->AddAttribute("PRODUCT_NAME",
+ this->CreateString(pnbase.c_str()));
+ buildSettings->AddAttribute("SYMROOT",
+ this->CreateString(pndir.c_str()));
+
+ // Handle settings for each target type.
+ switch(target.GetType())
+ {
+ case cmTarget::OBJECT_LIBRARY:
+ case cmTarget::STATIC_LIBRARY:
+ {
+ buildSettings->AddAttribute("LIBRARY_STYLE",
+ this->CreateString("STATIC"));
+ break;
+ }
+
+ case cmTarget::MODULE_LIBRARY:
+ {
+ buildSettings->AddAttribute("LIBRARY_STYLE",
+ this->CreateString("BUNDLE"));
+ if (target.GetPropertyAsBool("BUNDLE"))
+ {
+ // It turns out that a BUNDLE is basically the same
+ // in many ways as an application bundle, as far as
+ // link flags go
+ std::string createFlags =
+ this->LookupFlags("CMAKE_SHARED_MODULE_CREATE_", lang, "_FLAGS",
+ "-bundle");
+ if(!createFlags.empty())
+ {
+ extraLinkOptions += " ";
+ extraLinkOptions += createFlags;
+ }
+ std::string plist = this->ComputeInfoPListLocation(target);
+ // Xcode will create the final version of Info.plist at build time,
+ // so let it replace the cfbundle name. This avoids creating
+ // a per-configuration Info.plist file. The cfbundle plist
+ // is very similar to the application bundle plist
+ this->CurrentLocalGenerator
+ ->GenerateAppleInfoPList(&target, "$(EXECUTABLE_NAME)",
+ plist.c_str());
+ std::string path =
+ this->ConvertToRelativeForXCode(plist.c_str());
+ buildSettings->AddAttribute("INFOPLIST_FILE",
+ this->CreateString(path.c_str()));
+ }
+ else if(this->XcodeVersion >= 22)
+ {
+ buildSettings->AddAttribute("MACH_O_TYPE",
+ this->CreateString("mh_bundle"));
+ buildSettings->AddAttribute("GCC_DYNAMIC_NO_PIC",
+ this->CreateString("NO"));
+ // Add the flags to create an executable.
+ std::string createFlags =
+ this->LookupFlags("CMAKE_", lang, "_LINK_FLAGS", "");
+ if(!createFlags.empty())
+ {
+ extraLinkOptions += " ";
+ extraLinkOptions += createFlags;
+ }
+ }
+ else
+ {
+ // Add the flags to create a module.
+ std::string createFlags =
+ this->LookupFlags("CMAKE_SHARED_MODULE_CREATE_", lang, "_FLAGS",
+ "-bundle");
+ if(!createFlags.empty())
+ {
+ extraLinkOptions += " ";
+ extraLinkOptions += createFlags;
+ }
+ }
+ break;
+ }
+ case cmTarget::SHARED_LIBRARY:
+ {
+ if(target.GetPropertyAsBool("FRAMEWORK"))
+ {
+ std::string version = target.GetFrameworkVersion();
+ buildSettings->AddAttribute("FRAMEWORK_VERSION",
+ this->CreateString(version.c_str()));
+
+ std::string plist = this->ComputeInfoPListLocation(target);
+ // Xcode will create the final version of Info.plist at build time,
+ // so let it replace the framework name. This avoids creating
+ // a per-configuration Info.plist file.
+ this->CurrentLocalGenerator
+ ->GenerateFrameworkInfoPList(&target, "$(EXECUTABLE_NAME)",
+ plist.c_str());
+ std::string path =
+ this->ConvertToRelativeForXCode(plist.c_str());
+ buildSettings->AddAttribute("INFOPLIST_FILE",
+ this->CreateString(path.c_str()));
+ }
+ else
+ {
+ // Add the flags to create a shared library.
+ std::string createFlags =
+ this->LookupFlags("CMAKE_SHARED_LIBRARY_CREATE_", lang, "_FLAGS",
+ "-dynamiclib");
+ if(!createFlags.empty())
+ {
+ extraLinkOptions += " ";
+ extraLinkOptions += createFlags;
+ }
+ }
+
+ buildSettings->AddAttribute("LIBRARY_STYLE",
+ this->CreateString("DYNAMIC"));
+ break;
+ }
+ case cmTarget::EXECUTABLE:
+ {
+ // Add the flags to create an executable.
+ std::string createFlags =
+ this->LookupFlags("CMAKE_", lang, "_LINK_FLAGS", "");
+ if(!createFlags.empty())
+ {
+ extraLinkOptions += " ";
+ extraLinkOptions += createFlags;
+ }
+
+ // Handle bundles and normal executables separately.
+ if(target.GetPropertyAsBool("MACOSX_BUNDLE"))
+ {
+ std::string plist = this->ComputeInfoPListLocation(target);
+ // Xcode will create the final version of Info.plist at build time,
+ // so let it replace the executable name. This avoids creating
+ // a per-configuration Info.plist file.
+ this->CurrentLocalGenerator
+ ->GenerateAppleInfoPList(&target, "$(EXECUTABLE_NAME)",
+ plist.c_str());
+ std::string path =
+ this->ConvertToRelativeForXCode(plist.c_str());
+ buildSettings->AddAttribute("INFOPLIST_FILE",
+ this->CreateString(path.c_str()));
+
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ if(this->XcodeVersion >= 22 && this->XcodeVersion < 40)
+ {
+ buildSettings->AddAttribute("PREBINDING",
+ this->CreateString("NO"));
+ }
+
+ BuildObjectListOrString dirs(this, this->XcodeVersion >= 30);
+ BuildObjectListOrString fdirs(this, this->XcodeVersion >= 30);
+ std::vector<std::string> includes;
+ this->CurrentLocalGenerator->GetIncludeDirectories(includes, &target);
+ std::set<cmStdString> emitted;
+ emitted.insert("/System/Library/Frameworks");
+ for(std::vector<std::string>::iterator i = includes.begin();
+ i != includes.end(); ++i)
+ {
+ if(this->NameResolvesToFramework(i->c_str()))
+ {
+ std::string frameworkDir = *i;
+ frameworkDir += "/../";
+ frameworkDir = cmSystemTools::CollapseFullPath(frameworkDir.c_str());
+ if(emitted.insert(frameworkDir).second)
+ {
+ fdirs.Add(this->XCodeEscapePath(frameworkDir.c_str()).c_str());
+ }
+ }
+ else
+ {
+ std::string incpath =
+ this->XCodeEscapePath(i->c_str());
+ dirs.Add(incpath.c_str());
+ }
+ }
+ std::vector<std::string>& frameworks = target.GetFrameworks();
+ if(frameworks.size())
+ {
+ for(std::vector<std::string>::iterator fmIt = frameworks.begin();
+ fmIt != frameworks.end(); ++fmIt)
+ {
+ if(emitted.insert(*fmIt).second)
+ {
+ fdirs.Add(this->XCodeEscapePath(fmIt->c_str()).c_str());
+ }
+ }
+ }
+ if(!fdirs.IsEmpty())
+ {
+ buildSettings->AddAttribute("FRAMEWORK_SEARCH_PATHS",
+ fdirs.CreateList());
+ }
+ if(!dirs.IsEmpty())
+ {
+ buildSettings->AddAttribute("HEADER_SEARCH_PATHS",
+ dirs.CreateList());
+ }
+ std::string oflagc = this->ExtractFlag("-O", cflags);
+ char optLevel[2];
+ optLevel[0] = '0';
+ optLevel[1] = 0;
+ if(oflagc.size() == 3)
+ {
+ optLevel[0] = oflagc[2];
+ }
+ if(oflagc.size() == 2)
+ {
+ optLevel[0] = '1';
+ }
+ std::string oflag = this->ExtractFlag("-O", flags);
+ if(oflag.size() == 3)
+ {
+ optLevel[0] = oflag[2];
+ }
+ if(oflag.size() == 2)
+ {
+ optLevel[0] = '1';
+ }
+ std::string gflagc = this->ExtractFlag("-g", cflags);
+ // put back gdwarf-2 if used since there is no way
+ // to represent it in the gui, but we still want debug yes
+ if(gflagc == "-gdwarf-2")
+ {
+ cflags += " ";
+ cflags += gflagc;
+ }
+ std::string gflag = this->ExtractFlag("-g", flags);
+ if(gflag == "-gdwarf-2")
+ {
+ flags += " ";
+ flags += gflag;
+ }
+ const char* debugStr = "YES";
+ // We can't set the Xcode flag differently depending on the language,
+ // so put them back in this case.
+ if( (lang && strcmp(lang, "CXX") == 0) && gflag != gflagc )
+ {
+ cflags += " ";
+ cflags += gflagc;
+ flags += " ";
+ flags += gflag;
+ debugStr = "NO";
+ }
+ if( gflag == "-g0" || gflag.size() == 0 )
+ {
+ debugStr = "NO";
+ }
+
+ buildSettings->AddAttribute("GCC_GENERATE_DEBUGGING_SYMBOLS",
+ this->CreateString(debugStr));
+ buildSettings->AddAttribute("GCC_OPTIMIZATION_LEVEL",
+ this->CreateString(optLevel));
+ buildSettings->AddAttribute("GCC_SYMBOLS_PRIVATE_EXTERN",
+ this->CreateString("NO"));
+ buildSettings->AddAttribute("GCC_INLINES_ARE_PRIVATE_EXTERN",
+ this->CreateString("NO"));
+ if(lang && strcmp(lang, "CXX") == 0)
+ {
+ flags += " ";
+ flags += defFlags;
+ buildSettings->AddAttribute("OTHER_CPLUSPLUSFLAGS",
+ this->CreateString(flags.c_str()));
+ cflags += " ";
+ cflags += defFlags;
+ buildSettings->AddAttribute("OTHER_CFLAGS",
+ this->CreateString(cflags.c_str()));
+
+ }
+ else
+ {
+ flags += " ";
+ flags += defFlags;
+ buildSettings->AddAttribute("OTHER_CFLAGS",
+ this->CreateString(flags.c_str()));
+ }
+
+ // Add Fortran source format attribute if property is set.
+ const char* format = 0;
+ const char* tgtfmt = target.GetProperty("Fortran_FORMAT");
+ switch(this->CurrentLocalGenerator->GetFortranFormat(tgtfmt))
+ {
+ case cmLocalGenerator::FortranFormatFixed: format = "fixed"; break;
+ case cmLocalGenerator::FortranFormatFree: format = "free"; break;
+ default: break;
+ }
+ if(format)
+ {
+ buildSettings->AddAttribute("IFORT_LANG_SRCFMT",
+ this->CreateString(format));
+ }
+
+ // Create the INSTALL_PATH attribute.
+ std::string install_name_dir;
+ if(target.GetType() == cmTarget::SHARED_LIBRARY)
+ {
+ // Get the install_name directory for the build tree.
+ install_name_dir = target.GetInstallNameDirForBuildTree(configName, true);
+ if(install_name_dir.empty())
+ {
+ // Xcode will not pass the -install_name option at all if INSTALL_PATH
+ // is not given or is empty. We must explicitly put the flag in the
+ // link flags to create an install_name with just the library soname.
+ extraLinkOptions += " -install_name ";
+ extraLinkOptions += target.GetFullName(configName);
+ }
+ else
+ {
+ // Convert to a path for the native build tool.
+ cmSystemTools::ConvertToUnixSlashes(install_name_dir);
+ // do not escape spaces on this since it is only a single path
+ }
+ }
+ buildSettings->AddAttribute("INSTALL_PATH",
+ this->CreateString(install_name_dir.c_str()));
+
+ buildSettings->AddAttribute("OTHER_LDFLAGS",
+ this->CreateString(extraLinkOptions.c_str()));
+ buildSettings->AddAttribute("OTHER_REZFLAGS",
+ this->CreateString(""));
+ buildSettings->AddAttribute("SECTORDER_FLAGS",
+ this->CreateString(""));
+ buildSettings->AddAttribute("USE_HEADERMAP",
+ this->CreateString("NO"));
+ if (this->XcodeVersion >= 30)
+ {
+ cmXCodeObject *group = this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ group->AddObject(this->CreateString("-Wmost"));
+ group->AddObject(this->CreateString("-Wno-four-char-constants"));
+ group->AddObject(this->CreateString("-Wno-unknown-pragmas"));
+ buildSettings->AddAttribute("WARNING_CFLAGS", group);
+ }
+ else
+ {
+ buildSettings->AddAttribute("WARNING_CFLAGS",
+ this->CreateString(
+ "-Wmost -Wno-four-char-constants"
+ " -Wno-unknown-pragmas"));
+ }
+
+ // Runtime version information.
+ if(target.GetType() == cmTarget::SHARED_LIBRARY)
+ {
+ int major;
+ int minor;
+ int patch;
+
+ // VERSION -> current_version
+ target.GetTargetVersion(false, major, minor, patch);
+ cmOStringStream v;
+
+ // Xcode always wants at least 1.0.0 or nothing
+ if(!(major == 0 && minor == 0 && patch == 0))
+ {
+ v << major << "." << minor << "." << patch;
+ }
+ buildSettings->AddAttribute("DYLIB_CURRENT_VERSION",
+ this->CreateString(v.str().c_str()));
+
+ // SOVERSION -> compatibility_version
+ target.GetTargetVersion(true, major, minor, patch);
+ cmOStringStream vso;
+
+ // Xcode always wants at least 1.0.0 or nothing
+ if(!(major == 0 && minor == 0 && patch == 0))
+ {
+ vso << major << "." << minor << "." << patch;
+ }
+ buildSettings->AddAttribute("DYLIB_COMPATIBILITY_VERSION",
+ this->CreateString(vso.str().c_str()));
+ }
+ // put this last so it can override existing settings
+ // Convert "XCODE_ATTRIBUTE_*" properties directly.
+ {
+ cmPropertyMap const& props = target.GetProperties();
+ for(cmPropertyMap::const_iterator i = props.begin();
+ i != props.end(); ++i)
+ {
+ if(i->first.find("XCODE_ATTRIBUTE_") == 0)
+ {
+ buildSettings->AddAttribute(i->first.substr(16).c_str(),
+ this->CreateString(i->second.GetValue()));
+ }
+ }
+ }
+}
+
+//----------------------------------------------------------------------------
+cmXCodeObject*
+cmGlobalXCodeGenerator::CreateUtilityTarget(cmTarget& cmtarget)
+{
+ cmXCodeObject* shellBuildPhase =
+ this->CreateObject(cmXCodeObject::PBXShellScriptBuildPhase);
+ shellBuildPhase->AddAttribute("buildActionMask",
+ this->CreateString("2147483647"));
+ cmXCodeObject* buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ shellBuildPhase->AddAttribute("files", buildFiles);
+ cmXCodeObject* inputPaths = this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ shellBuildPhase->AddAttribute("inputPaths", inputPaths);
+ cmXCodeObject* outputPaths = this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ shellBuildPhase->AddAttribute("outputPaths", outputPaths);
+ shellBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
+ this->CreateString("0"));
+ shellBuildPhase->AddAttribute("shellPath",
+ this->CreateString("/bin/sh"));
+ shellBuildPhase->AddAttribute("shellScript",
+ this->CreateString(
+ "# shell script goes here\nexit 0"));
+ shellBuildPhase->AddAttribute("showEnvVarsInLog",
+ this->CreateString("0"));
+
+ cmXCodeObject* target =
+ this->CreateObject(cmXCodeObject::PBXAggregateTarget);
+ target->SetComment(cmtarget.GetName());
+ cmXCodeObject* buildPhases =
+ this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ std::vector<cmXCodeObject*> emptyContentVector;
+ this->CreateCustomCommands(buildPhases, 0, 0, 0, emptyContentVector, 0,
+ cmtarget);
+ target->AddAttribute("buildPhases", buildPhases);
+ if(this->XcodeVersion > 20)
+ {
+ this->AddConfigurations(target, cmtarget);
+ }
+ else
+ {
+ const char* theConfig =
+ this->CurrentMakefile->GetDefinition("CMAKE_BUILD_TYPE");
+ cmXCodeObject* buildSettings =
+ this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
+ this->CreateBuildSettings(cmtarget, buildSettings, theConfig);
+ target->AddAttribute("buildSettings", buildSettings);
+ }
+ cmXCodeObject* dependencies =
+ this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ target->AddAttribute("dependencies", dependencies);
+ target->AddAttribute("name", this->CreateString(cmtarget.GetName()));
+ target->AddAttribute("productName",this->CreateString(cmtarget.GetName()));
+ target->SetTarget(&cmtarget);
+
+ // Add source files without build rules for editing convenience.
+ if(cmtarget.GetType() == cmTarget::UTILITY)
+ {
+ std::vector<cmSourceFile*> const& sources = cmtarget.GetSourceFiles();
+ for(std::vector<cmSourceFile*>::const_iterator i = sources.begin();
+ i != sources.end(); ++i)
+ {
+ if(!(*i)->GetPropertyAsBool("GENERATED"))
+ {
+ this->CreateXCodeFileReference(*i, cmtarget);
+ }
+ }
+ }
+
+ target->SetId(this->GetOrCreateId(
+ cmtarget.GetName(), target->GetId()).c_str());
+
+ return target;
+}
+
+//----------------------------------------------------------------------------
+std::string cmGlobalXCodeGenerator::AddConfigurations(cmXCodeObject* target,
+ cmTarget& cmtarget)
+{
+ std::string configTypes =
+ this->CurrentMakefile->GetRequiredDefinition("CMAKE_CONFIGURATION_TYPES");
+ std::vector<std::string> configVectorIn;
+ std::vector<std::string> configVector;
+ configVectorIn.push_back(configTypes);
+ cmSystemTools::ExpandList(configVectorIn, configVector);
+ cmXCodeObject* configlist =
+ this->CreateObject(cmXCodeObject::XCConfigurationList);
+ cmXCodeObject* buildConfigurations =
+ this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ configlist->AddAttribute("buildConfigurations", buildConfigurations);
+ std::string comment = "Build configuration list for ";
+ comment += cmXCodeObject::PBXTypeNames[target->GetIsA()];
+ comment += " \"";
+ comment += cmtarget.GetName();
+ comment += "\"";
+ configlist->SetComment(comment.c_str());
+ target->AddAttribute("buildConfigurationList",
+ this->CreateObjectReference(configlist));
+ for(unsigned int i = 0; i < configVector.size(); ++i)
+ {
+ cmXCodeObject* config =
+ this->CreateObject(cmXCodeObject::XCBuildConfiguration);
+ buildConfigurations->AddObject(config);
+ cmXCodeObject* buildSettings =
+ this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
+ this->CreateBuildSettings(cmtarget, buildSettings,
+ configVector[i].c_str());
+ config->AddAttribute("name", this->CreateString(configVector[i].c_str()));
+ config->SetComment(configVector[i].c_str());
+ config->AddAttribute("buildSettings", buildSettings);
+ }
+ if(configVector.size())
+ {
+ configlist->AddAttribute("defaultConfigurationName",
+ this->CreateString(configVector[0].c_str()));
+ configlist->AddAttribute("defaultConfigurationIsVisible",
+ this->CreateString("0"));
+ return configVector[0];
+ }
+ return "";
+}
+
+//----------------------------------------------------------------------------
+const char* cmGlobalXCodeGenerator::GetTargetFileType(cmTarget& cmtarget)
+{
+ switch(cmtarget.GetType())
+ {
+ case cmTarget::OBJECT_LIBRARY:
+ case cmTarget::STATIC_LIBRARY:
+ return "archive.ar";
+ case cmTarget::MODULE_LIBRARY:
+ if (cmtarget.IsCFBundleOnApple())
+ return "wrapper.plug-in";
+ else
+ return ((this->XcodeVersion >= 22)?
+ "compiled.mach-o.executable" : "compiled.mach-o.dylib");
+ case cmTarget::SHARED_LIBRARY:
+ return (cmtarget.GetPropertyAsBool("FRAMEWORK")?
+ "wrapper.framework" : "compiled.mach-o.dylib");
+ case cmTarget::EXECUTABLE:
+ return "compiled.mach-o.executable";
+ default: break;
+ }
+ return 0;
+}
+
+//----------------------------------------------------------------------------
+const char* cmGlobalXCodeGenerator::GetTargetProductType(cmTarget& cmtarget)
+{
+ switch(cmtarget.GetType())
+ {
+ case cmTarget::OBJECT_LIBRARY:
+ case cmTarget::STATIC_LIBRARY:
+ return "com.apple.product-type.library.static";
+ case cmTarget::MODULE_LIBRARY:
+ if (cmtarget.IsCFBundleOnApple())
+ return "com.apple.product-type.bundle";
+ else
+ return ((this->XcodeVersion >= 22)?
+ "com.apple.product-type.tool" :
+ "com.apple.product-type.library.dynamic");
+ case cmTarget::SHARED_LIBRARY:
+ return (cmtarget.GetPropertyAsBool("FRAMEWORK")?
+ "com.apple.product-type.framework" :
+ "com.apple.product-type.library.dynamic");
+ case cmTarget::EXECUTABLE:
+ return (cmtarget.GetPropertyAsBool("MACOSX_BUNDLE")?
+ "com.apple.product-type.application" :
+ "com.apple.product-type.tool");
+ default: break;
+ }
+ return 0;
+}
+
+//----------------------------------------------------------------------------
+cmXCodeObject*
+cmGlobalXCodeGenerator::CreateXCodeTarget(cmTarget& cmtarget,
+ cmXCodeObject* buildPhases)
+{
+ cmXCodeObject* target =
+ this->CreateObject(cmXCodeObject::PBXNativeTarget);
+ target->AddAttribute("buildPhases", buildPhases);
+ cmXCodeObject* buildRules = this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ target->AddAttribute("buildRules", buildRules);
+ std::string defConfig;
+ if(this->XcodeVersion > 20)
+ {
+ defConfig = this->AddConfigurations(target, cmtarget);
+ }
+ else
+ {
+ cmXCodeObject* buildSettings =
+ this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
+ defConfig = this->CurrentMakefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
+ this->CreateBuildSettings(cmtarget, buildSettings, defConfig.c_str());
+ target->AddAttribute("buildSettings", buildSettings);
+ }
+ cmXCodeObject* dependencies =
+ this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ target->AddAttribute("dependencies", dependencies);
+ target->AddAttribute("name", this->CreateString(cmtarget.GetName()));
+ target->AddAttribute("productName",this->CreateString(cmtarget.GetName()));
+
+ cmXCodeObject* fileRef =
+ this->CreateObject(cmXCodeObject::PBXFileReference);
+ if(const char* fileType = this->GetTargetFileType(cmtarget))
+ {
+ fileRef->AddAttribute("explicitFileType", this->CreateString(fileType));
+ }
+ std::string fullName;
+ if(cmtarget.GetType() == cmTarget::OBJECT_LIBRARY)
+ {
+ fullName = "lib";
+ fullName += cmtarget.GetName();
+ fullName += ".a";
+ }
+ else
+ {
+ fullName = cmtarget.GetFullName(defConfig.c_str());
+ }
+ fileRef->AddAttribute("path", this->CreateString(fullName.c_str()));
+ fileRef->AddAttribute("refType", this->CreateString("0"));
+ fileRef->AddAttribute("sourceTree",
+ this->CreateString("BUILT_PRODUCTS_DIR"));
+ fileRef->SetComment(cmtarget.GetName());
+ target->AddAttribute("productReference",
+ this->CreateObjectReference(fileRef));
+ if(const char* productType = this->GetTargetProductType(cmtarget))
+ {
+ target->AddAttribute("productType", this->CreateString(productType));
+ }
+ target->SetTarget(&cmtarget);
+ target->SetId(this->GetOrCreateId(
+ cmtarget.GetName(), target->GetId()).c_str());
+ return target;
+}
+
+//----------------------------------------------------------------------------
+cmXCodeObject* cmGlobalXCodeGenerator::FindXCodeTarget(cmTarget* t)
+{
+ if(!t)
+ {
+ return 0;
+ }
+ for(std::vector<cmXCodeObject*>::iterator i = this->XCodeObjects.begin();
+ i != this->XCodeObjects.end(); ++i)
+ {
+ cmXCodeObject* o = *i;
+ if(o->GetTarget() == t)
+ {
+ return o;
+ }
+ }
+ return 0;
+}
+
+//----------------------------------------------------------------------------
+std::string cmGlobalXCodeGenerator::GetOrCreateId(const char* name,
+ const char* id)
+{
+ std::string guidStoreName = name;
+ guidStoreName += "_GUID_CMAKE";
+ const char* storedGUID =
+ this->CMakeInstance->GetCacheDefinition(guidStoreName.c_str());
+
+ if(storedGUID)
+ {
+ return storedGUID;
+ }
+
+ this->CMakeInstance->AddCacheEntry(guidStoreName.c_str(),
+ id, "Stored Xcode object GUID", cmCacheManager::INTERNAL);
+
+ return id;
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalXCodeGenerator::AddDependTarget(cmXCodeObject* target,
+ cmXCodeObject* dependTarget)
+{
+ // make sure a target does not depend on itself
+ if(target == dependTarget)
+ {
+ return;
+ }
+ // now avoid circular references if dependTarget already
+ // depends on target then skip it. Circular references crashes
+ // xcode
+ cmXCodeObject* dependTargetDepends =
+ dependTarget->GetObject("dependencies");
+ if(dependTargetDepends)
+ {
+ if(dependTargetDepends->HasObject(target->GetPBXTargetDependency()))
+ {
+ return;
+ }
+ }
+
+ cmXCodeObject* targetdep = dependTarget->GetPBXTargetDependency();
+ if(!targetdep)
+ {
+ cmXCodeObject* container =
+ this->CreateObject(cmXCodeObject::PBXContainerItemProxy);
+ container->SetComment("PBXContainerItemProxy");
+ container->AddAttribute("containerPortal",
+ this->CreateObjectReference(this->RootObject));
+ container->AddAttribute("proxyType", this->CreateString("1"));
+ container->AddAttribute("remoteGlobalIDString",
+ this->CreateObjectReference(dependTarget));
+ container->AddAttribute("remoteInfo",
+ this->CreateString(
+ dependTarget->GetTarget()->GetName()));
+ targetdep =
+ this->CreateObject(cmXCodeObject::PBXTargetDependency);
+ targetdep->SetComment("PBXTargetDependency");
+ targetdep->AddAttribute("target",
+ this->CreateObjectReference(dependTarget));
+ targetdep->AddAttribute("targetProxy",
+ this->CreateObjectReference(container));
+ dependTarget->SetPBXTargetDependency(targetdep);
+ }
+
+ cmXCodeObject* depends = target->GetObject("dependencies");
+ if(!depends)
+ {
+ cmSystemTools::
+ Error("target does not have dependencies attribute error..");
+
+ }
+ else
+ {
+ depends->AddUniqueObject(targetdep);
+ }
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalXCodeGenerator::AppendOrAddBuildSetting(cmXCodeObject* settings,
+ const char* attribute,
+ const char* value)
+{
+ if(settings)
+ {
+ cmXCodeObject* attr = settings->GetObject(attribute);
+ if(!attr)
+ {
+ settings->AddAttribute(attribute, this->CreateString(value));
+ }
+ else
+ {
+ std::string oldValue = attr->GetString();
+ oldValue += " ";
+ oldValue += value;
+ attr->SetString(oldValue.c_str());
+ }
+ }
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalXCodeGenerator
+::AppendBuildSettingAttribute(cmXCodeObject* target,
+ const char* attribute,
+ const char* value,
+ const char* configName)
+{
+ if(this->XcodeVersion < 21)
+ {
+ // There is only one configuration. Add the setting to the buildSettings
+ // of the target.
+ this->AppendOrAddBuildSetting(target->GetObject("buildSettings"),
+ attribute, value);
+ }
+ else
+ {
+ // There are multiple configurations. Add the setting to the
+ // buildSettings of the configuration name given.
+ cmXCodeObject* configurationList =
+ target->GetObject("buildConfigurationList")->GetObject();
+ cmXCodeObject* buildConfigs =
+ configurationList->GetObject("buildConfigurations");
+ std::vector<cmXCodeObject*> list = buildConfigs->GetObjectList();
+ // each configuration and the target itself has a buildSettings in it
+ //list.push_back(target);
+ for(std::vector<cmXCodeObject*>::iterator i = list.begin();
+ i != list.end(); ++i)
+ {
+ if(configName)
+ {
+ if(strcmp((*i)->GetObject("name")->GetString(), configName) == 0)
+ {
+ cmXCodeObject* settings = (*i)->GetObject("buildSettings");
+ this->AppendOrAddBuildSetting(settings, attribute, value);
+ }
+ }
+ else
+ {
+ cmXCodeObject* settings = (*i)->GetObject("buildSettings");
+ this->AppendOrAddBuildSetting(settings, attribute, value);
+ }
+ }
+ }
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalXCodeGenerator
+::AddDependAndLinkInformation(cmXCodeObject* target)
+{
+ cmTarget* cmtarget = target->GetTarget();
+ if(!cmtarget)
+ {
+ cmSystemTools::Error("Error no target on xobject\n");
+ return;
+ }
+
+ // Add dependencies on other CMake targets.
+ TargetDependSet const& deps = this->GetTargetDirectDepends(*cmtarget);
+ for(TargetDependSet::const_iterator i = deps.begin(); i != deps.end(); ++i)
+ {
+ if(cmXCodeObject* dptarget = this->FindXCodeTarget(*i))
+ {
+ this->AddDependTarget(target, dptarget);
+ }
+ }
+
+ // Skip link information for static libraries.
+ if(cmtarget->GetType() == cmTarget::OBJECT_LIBRARY ||
+ cmtarget->GetType() == cmTarget::STATIC_LIBRARY)
+ {
+ return;
+ }
+
+ // Loop over configuration types and set per-configuration info.
+ for(std::vector<std::string>::iterator i =
+ this->CurrentConfigurationTypes.begin();
+ i != this->CurrentConfigurationTypes.end(); ++i)
+ {
+ // Get the current configuration name.
+ const char* configName = i->c_str();
+ if(!*configName)
+ {
+ configName = 0;
+ }
+
+ // Compute the link library and directory information.
+ cmComputeLinkInformation* pcli = cmtarget->GetLinkInformation(configName);
+ if(!pcli)
+ {
+ continue;
+ }
+ cmComputeLinkInformation& cli = *pcli;
+
+ // Add dependencies directly on library files.
+ {
+ std::vector<std::string> const& libDeps = cli.GetDepends();
+ for(std::vector<std::string>::const_iterator j = libDeps.begin();
+ j != libDeps.end(); ++j)
+ {
+ target->AddDependLibrary(configName, j->c_str());
+ }
+ }
+
+ // add the library search paths
+ {
+ std::vector<std::string> const& libDirs = cli.GetDirectories();
+ std::string linkDirs;
+ for(std::vector<std::string>::const_iterator libDir = libDirs.begin();
+ libDir != libDirs.end(); ++libDir)
+ {
+ if(libDir->size() && *libDir != "/usr/lib")
+ {
+ if(this->XcodeVersion > 15)
+ {
+ // Now add the same one but append
+ // $(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME) to it:
+ linkDirs += " ";
+ linkDirs += this->XCodeEscapePath(
+ (*libDir + "/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)").c_str());
+ }
+ linkDirs += " ";
+ linkDirs += this->XCodeEscapePath(libDir->c_str());
+ }
+ }
+ this->AppendBuildSettingAttribute(target, "LIBRARY_SEARCH_PATHS",
+ linkDirs.c_str(), configName);
+ }
+
+ // add the framework search paths
+ {
+ const char* sep = "";
+ std::string fdirs;
+ std::vector<std::string> const& fwDirs = cli.GetFrameworkPaths();
+ for(std::vector<std::string>::const_iterator fdi = fwDirs.begin();
+ fdi != fwDirs.end(); ++fdi)
+ {
+ fdirs += sep;
+ sep = " ";
+ fdirs += this->XCodeEscapePath(fdi->c_str());
+ }
+ if(!fdirs.empty())
+ {
+ this->AppendBuildSettingAttribute(target, "FRAMEWORK_SEARCH_PATHS",
+ fdirs.c_str(), configName);
+ }
+ }
+
+ // now add the link libraries
+ {
+ std::string linkLibs;
+ const char* sep = "";
+ typedef cmComputeLinkInformation::ItemVector ItemVector;
+ ItemVector const& libNames = cli.GetItems();
+ for(ItemVector::const_iterator li = libNames.begin();
+ li != libNames.end(); ++li)
+ {
+ linkLibs += sep;
+ sep = " ";
+ if(li->IsPath)
+ {
+ linkLibs += this->XCodeEscapePath(li->Value.c_str());
+ }
+ else
+ {
+ linkLibs += li->Value;
+ }
+ if(li->Target && !li->Target->IsImported())
+ {
+ target->AddDependTarget(configName, li->Target->GetName());
+ }
+ }
+ this->AppendBuildSettingAttribute(target, "OTHER_LDFLAGS",
+ linkLibs.c_str(), configName);
+ }
+ }
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalXCodeGenerator::CreateGroups(cmLocalGenerator* root,
+ std::vector<cmLocalGenerator*>&
+ generators)
+{
+ for(std::vector<cmLocalGenerator*>::iterator i = generators.begin();
+ i != generators.end(); ++i)
+ {
+ if(this->IsExcluded(root, *i))
+ {
+ continue;
+ }
+ cmMakefile* mf = (*i)->GetMakefile();
+ std::vector<cmSourceGroup> sourceGroups = mf->GetSourceGroups();
+ cmTargets &tgts = mf->GetTargets();
+ for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); l++)
+ {
+ cmTarget& cmtarget = l->second;
+
+ // Same skipping logic here as in CreateXCodeTargets so that we do not
+ // end up with (empty anyhow) ALL_BUILD and XCODE_DEPEND_HELPER source
+ // groups:
+ //
+ if(cmtarget.GetType() == cmTarget::GLOBAL_TARGET)
+ {
+ continue;
+ }
+
+ // add the soon to be generated Info.plist file as a source for a
+ // MACOSX_BUNDLE file
+ if(cmtarget.GetPropertyAsBool("MACOSX_BUNDLE"))
+ {
+ std::string plist = this->ComputeInfoPListLocation(cmtarget);
+ cmSourceFile* sf = mf->GetOrCreateSource(plist.c_str(), true);
+ cmtarget.AddSourceFile(sf);
+ }
+
+ std::vector<cmSourceFile*> classes = cmtarget.GetSourceFiles();
+
+ // Put cmSourceFile instances in proper groups:
+ for(std::vector<cmSourceFile*>::const_iterator s = classes.begin();
+ s != classes.end(); s++)
+ {
+ cmSourceFile* sf = *s;
+ // Add the file to the list of sources.
+ std::string const& source = sf->GetFullPath();
+ cmSourceGroup& sourceGroup =
+ mf->FindSourceGroup(source.c_str(), sourceGroups);
+ cmXCodeObject* pbxgroup =
+ this->CreateOrGetPBXGroup(cmtarget, &sourceGroup);
+ cmStdString key = GetGroupMapKey(cmtarget, sf);
+ this->GroupMap[key] = pbxgroup;
+ }
+
+ // Put OBJECT_LIBRARY objects in proper groups:
+ std::vector<std::string> objs;
+ this->GetGeneratorTarget(&cmtarget)->UseObjectLibraries(objs);
+ for(std::vector<std::string>::const_iterator
+ oi = objs.begin(); oi != objs.end(); ++oi)
+ {
+ std::string const& source = *oi;
+ cmSourceGroup& sourceGroup =
+ mf->FindSourceGroup(source.c_str(), sourceGroups);
+ cmXCodeObject* pbxgroup =
+ this->CreateOrGetPBXGroup(cmtarget, &sourceGroup);
+ cmStdString key = GetGroupMapKeyFromPath(cmtarget, source);
+ this->GroupMap[key] = pbxgroup;
+ }
+ }
+ }
+}
+
+cmXCodeObject *cmGlobalXCodeGenerator
+::CreatePBXGroup(cmXCodeObject *parent, cmStdString name)
+{
+ cmXCodeObject* parentChildren = NULL;
+ if(parent)
+ parentChildren = parent->GetObject("children");
+ cmXCodeObject* group = this->CreateObject(cmXCodeObject::PBXGroup);
+ cmXCodeObject* groupChildren =
+ this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ group->AddAttribute("name", this->CreateString(name.c_str()));
+ group->AddAttribute("children", groupChildren);
+ if(this->XcodeVersion == 15)
+ {
+ group->AddAttribute("refType", this->CreateString("4"));
+ }
+ group->AddAttribute("sourceTree", this->CreateString("<group>"));
+ if(parentChildren)
+ parentChildren->AddObject(group);
+ return group;
+}
+
+//----------------------------------------------------------------------------
+cmXCodeObject* cmGlobalXCodeGenerator
+::CreateOrGetPBXGroup(cmTarget& cmtarget, cmSourceGroup* sg)
+{
+ cmStdString s;
+ cmStdString target;
+ const char *targetFolder= cmtarget.GetProperty("FOLDER");
+ if(targetFolder) {
+ target = targetFolder;
+ target += "/";
+ }
+ target += cmtarget.GetName();
+ s = target + "/";
+ s += sg->GetFullName();
+ std::map<cmStdString, cmXCodeObject* >::iterator it =
+ this->GroupNameMap.find(s);
+ if(it != this->GroupNameMap.end())
+ {
+ return it->second;
+ }
+
+ it = this->TargetGroup.find(target);
+ cmXCodeObject* tgroup = 0;
+ if(it != this->TargetGroup.end())
+ {
+ tgroup = it->second;
+ }
+ else
+ {
+ std::vector<std::string> tgt_folders =
+ cmSystemTools::tokenize(target, "/");
+ cmStdString curr_tgt_folder;
+ for(std::vector<std::string>::size_type i = 0; i < tgt_folders.size();i++)
+ {
+ curr_tgt_folder += tgt_folders[i];
+ it = this->TargetGroup.find(curr_tgt_folder);
+ if(it == this->TargetGroup.end())
+ {
+ tgroup = this->CreatePBXGroup(tgroup,tgt_folders[i]);
+ this->TargetGroup[curr_tgt_folder] = tgroup;
+ }
+ else
+ {
+ tgroup = it->second;
+ continue;
+ }
+ if(i == 0)
+ {
+ this->SourcesGroupChildren->AddObject(tgroup);
+ }
+ curr_tgt_folder += "/";
+ }
+ }
+ this->TargetGroup[target] = tgroup;
+
+ // If it's the default source group (empty name) then put the source file
+ // directly in the tgroup...
+ //
+ if (cmStdString(sg->GetFullName()) == "")
+ {
+ this->GroupNameMap[s] = tgroup;
+ return tgroup;
+ }
+
+ //It's a recursive folder structure, let's find the real parent group
+ if(std::string(sg->GetFullName()) != std::string(sg->GetName()))
+ {
+ std::vector<std::string> folders =
+ cmSystemTools::tokenize(sg->GetFullName(), "\\");
+ cmStdString curr_folder = cmtarget.GetName();
+ curr_folder += "/";
+ for(std::vector<std::string>::size_type i = 0; i < folders.size();i++)
+ {
+ curr_folder += folders[i];
+ std::map<cmStdString, cmXCodeObject* >::iterator i_folder =
+ this->GroupNameMap.find(curr_folder);
+ //Create new folder
+ if(i_folder == this->GroupNameMap.end())
+ {
+ cmXCodeObject *group = this->CreatePBXGroup(tgroup,folders[i]);
+ this->GroupNameMap[curr_folder] = group;
+ tgroup = group;
+ }
+ else
+ {
+ tgroup = i_folder->second;
+ }
+ curr_folder = curr_folder + "\\";
+ }
+ return tgroup;
+ }
+ cmXCodeObject *group = this->CreatePBXGroup(tgroup,sg->GetName());
+ this->GroupNameMap[s] = group;
+ return group;
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalXCodeGenerator
+::CreateXCodeObjects(cmLocalGenerator* root,
+ std::vector<cmLocalGenerator*>&
+ generators)
+{
+ this->ClearXCodeObjects();
+ this->RootObject = 0;
+ this->SourcesGroupChildren = 0;
+ this->ResourcesGroupChildren = 0;
+ this->MainGroupChildren = 0;
+ cmXCodeObject* group = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
+ group->AddAttribute("COPY_PHASE_STRIP", this->CreateString("NO"));
+ cmXCodeObject* developBuildStyle =
+ this->CreateObject(cmXCodeObject::PBXBuildStyle);
+ cmXCodeObject* listObjs = this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ if(this->XcodeVersion == 15)
+ {
+ developBuildStyle->AddAttribute("name",
+ this->CreateString("Development"));
+ developBuildStyle->AddAttribute("buildSettings", group);
+ listObjs->AddObject(developBuildStyle);
+ group = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
+ group->AddAttribute("COPY_PHASE_STRIP", this->CreateString("YES"));
+ cmXCodeObject* deployBuildStyle =
+ this->CreateObject(cmXCodeObject::PBXBuildStyle);
+ deployBuildStyle->AddAttribute("name", this->CreateString("Deployment"));
+ deployBuildStyle->AddAttribute("buildSettings", group);
+ listObjs->AddObject(deployBuildStyle);
+ }
+ else
+ {
+ for(unsigned int i = 0; i < this->CurrentConfigurationTypes.size(); ++i)
+ {
+ cmXCodeObject* buildStyle =
+ this->CreateObject(cmXCodeObject::PBXBuildStyle);
+ const char* name = this->CurrentConfigurationTypes[i].c_str();
+ buildStyle->AddAttribute("name", this->CreateString(name));
+ buildStyle->SetComment(name);
+ cmXCodeObject* sgroup =
+ this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
+ sgroup->AddAttribute("COPY_PHASE_STRIP", this->CreateString("NO"));
+ buildStyle->AddAttribute("buildSettings", sgroup);
+ listObjs->AddObject(buildStyle);
+ }
+ }
+
+ cmXCodeObject* mainGroup = this->CreateObject(cmXCodeObject::PBXGroup);
+ this->MainGroupChildren =
+ this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ mainGroup->AddAttribute("children", this->MainGroupChildren);
+ if(this->XcodeVersion == 15)
+ {
+ mainGroup->AddAttribute("refType", this->CreateString("4"));
+ }
+ mainGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
+
+ cmXCodeObject* sourcesGroup = this->CreateObject(cmXCodeObject::PBXGroup);
+ this->SourcesGroupChildren =
+ this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ sourcesGroup->AddAttribute("name", this->CreateString("Sources"));
+ sourcesGroup->AddAttribute("children", this->SourcesGroupChildren);
+ if(this->XcodeVersion == 15)
+ {
+ sourcesGroup->AddAttribute("refType", this->CreateString("4"));
+ }
+ sourcesGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
+ this->MainGroupChildren->AddObject(sourcesGroup);
+
+ cmXCodeObject* resourcesGroup = this->CreateObject(cmXCodeObject::PBXGroup);
+ this->ResourcesGroupChildren =
+ this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ resourcesGroup->AddAttribute("name", this->CreateString("Resources"));
+ resourcesGroup->AddAttribute("children", this->ResourcesGroupChildren);
+ if(this->XcodeVersion == 15)
+ {
+ resourcesGroup->AddAttribute("refType", this->CreateString("4"));
+ }
+ resourcesGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
+ this->MainGroupChildren->AddObject(resourcesGroup);
+
+ // now create the cmake groups
+ this->CreateGroups(root, generators);
+
+ cmXCodeObject* productGroup = this->CreateObject(cmXCodeObject::PBXGroup);
+ productGroup->AddAttribute("name", this->CreateString("Products"));
+ if(this->XcodeVersion == 15)
+ {
+ productGroup->AddAttribute("refType", this->CreateString("4"));
+ }
+ productGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
+ cmXCodeObject* productGroupChildren =
+ this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ productGroup->AddAttribute("children", productGroupChildren);
+ this->MainGroupChildren->AddObject(productGroup);
+
+
+ this->RootObject = this->CreateObject(cmXCodeObject::PBXProject);
+ this->RootObject->SetComment("Project object");
+
+ std::string project_id = "PROJECT_";
+ project_id += root->GetMakefile()->GetProjectName();
+ this->RootObject->SetId(this->GetOrCreateId(
+ project_id.c_str(), this->RootObject->GetId()).c_str());
+
+ group = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
+ this->RootObject->AddAttribute("mainGroup",
+ this->CreateObjectReference(mainGroup));
+ this->RootObject->AddAttribute("buildSettings", group);
+ this->RootObject->AddAttribute("buildStyles", listObjs);
+ this->RootObject->AddAttribute("hasScannedForEncodings",
+ this->CreateString("0"));
+ if (this->XcodeVersion >= 30)
+ {
+ group = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
+ group->AddAttribute("BuildIndependentTargetsInParallel",
+ this->CreateString("YES"));
+ this->RootObject->AddAttribute("attributes", group);
+ if (this->XcodeVersion >= 32)
+ this->RootObject->AddAttribute("compatibilityVersion",
+ this->CreateString("Xcode 3.2"));
+ else if (this->XcodeVersion >= 31)
+ this->RootObject->AddAttribute("compatibilityVersion",
+ this->CreateString("Xcode 3.1"));
+ else
+ this->RootObject->AddAttribute("compatibilityVersion",
+ this->CreateString("Xcode 3.0"));
+ }
+ // Point Xcode at the top of the source tree.
+ {
+ std::string pdir =
+ this->RelativeToBinary(root->GetMakefile()->GetCurrentDirectory());
+ this->RootObject->AddAttribute("projectDirPath",
+ this->CreateString(pdir.c_str()));
+ this->RootObject->AddAttribute("projectRoot", this->CreateString(""));
+ }
+ cmXCodeObject* configlist =
+ this->CreateObject(cmXCodeObject::XCConfigurationList);
+ cmXCodeObject* buildConfigurations =
+ this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ std::vector<cmXCodeObject*> configs;
+ const char *defaultConfigName = "Debug";
+ if(this->XcodeVersion == 15)
+ {
+ cmXCodeObject* configDebug =
+ this->CreateObject(cmXCodeObject::XCBuildConfiguration);
+ configDebug->AddAttribute("name", this->CreateString("Debug"));
+ configs.push_back(configDebug);
+ cmXCodeObject* configRelease =
+ this->CreateObject(cmXCodeObject::XCBuildConfiguration);
+ configRelease->AddAttribute("name", this->CreateString("Release"));
+ configs.push_back(configRelease);
+ }
+ else
+ {
+ for(unsigned int i = 0; i < this->CurrentConfigurationTypes.size(); ++i)
+ {
+ const char* name = this->CurrentConfigurationTypes[i].c_str();
+ if (0 == i)
+ {
+ defaultConfigName = name;
+ }
+ cmXCodeObject* config =
+ this->CreateObject(cmXCodeObject::XCBuildConfiguration);
+ config->AddAttribute("name", this->CreateString(name));
+ configs.push_back(config);
+ }
+ }
+ for(std::vector<cmXCodeObject*>::iterator c = configs.begin();
+ c != configs.end(); ++c)
+ {
+ buildConfigurations->AddObject(*c);
+ }
+ configlist->AddAttribute("buildConfigurations", buildConfigurations);
+
+ std::string comment = "Build configuration list for PBXProject ";
+ comment += " \"";
+ comment += this->CurrentProject;
+ comment += "\"";
+ configlist->SetComment(comment.c_str());
+ configlist->AddAttribute("defaultConfigurationIsVisible",
+ this->CreateString("0"));
+ configlist->AddAttribute("defaultConfigurationName",
+ this->CreateString(defaultConfigName));
+ cmXCodeObject* buildSettings =
+ this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
+ const char* osxArch =
+ this->CurrentMakefile->GetDefinition("CMAKE_OSX_ARCHITECTURES");
+ if(!osxArch || strlen(osxArch) == 0)
+ {
+ if(this->XcodeVersion >= 32)
+ {
+ osxArch = "$(ARCHS_STANDARD_32_64_BIT)";
+ }
+ else if(this->XcodeVersion == 31)
+ {
+ osxArch = "$(ARCHS_STANDARD_32_BIT)";
+ }
+ else if(this->XcodeVersion <= 30)
+ {
+#ifdef __ppc__
+ osxArch = "ppc";
+#endif
+#ifdef __i386
+ osxArch = "i386";
+#endif
+ }
+ buildSettings->AddAttribute("ONLY_ACTIVE_ARCH",
+ this->CreateString("YES"));
+ }
+
+ const char* sysroot =
+ this->CurrentMakefile->GetDefinition("CMAKE_OSX_SYSROOT");
+ const char* sysrootDefault =
+ this->CurrentMakefile->GetDefinition("CMAKE_OSX_SYSROOT_DEFAULT");
+ const char* deploymentTarget =
+ this->CurrentMakefile->GetDefinition("CMAKE_OSX_DEPLOYMENT_TARGET");
+ if(osxArch && sysroot)
+ {
+ bool flagsUsed = false;
+ // recompute this as it may have been changed since enable language
+ this->Architectures.clear();
+ cmSystemTools::ExpandListArgument(std::string(osxArch),
+ this->Architectures);
+ flagsUsed = true;
+ buildSettings->AddAttribute("SDKROOT",
+ this->CreateString(sysroot));
+ std::string archString;
+ const char* sep = "";
+ for( std::vector<std::string>::iterator i =
+ this->Architectures.begin();
+ i != this->Architectures.end(); ++i)
+ {
+ archString += sep;
+ archString += *i;
+ sep = " ";
+ }
+ buildSettings->AddAttribute("ARCHS",
+ this->CreateString(archString.c_str()));
+ if(!flagsUsed && sysrootDefault &&
+ strcmp(sysroot, sysrootDefault) != 0)
+ {
+ buildSettings->AddAttribute("SDKROOT",
+ this->CreateString(sysroot));
+ }
+ }
+ if(deploymentTarget && *deploymentTarget)
+ {
+ buildSettings->AddAttribute("MACOSX_DEPLOYMENT_TARGET",
+ this->CreateString(deploymentTarget));
+ }
+
+ // Put this last so it can override existing settings
+ // Convert "CMAKE_XCODE_ATTRIBUTE_*" variables directly.
+ {
+ std::vector<std::string> vars = this->CurrentMakefile->GetDefinitions();
+ for(std::vector<std::string>::const_iterator i = vars.begin();
+ i != vars.end(); ++i)
+ {
+ if(i->find("CMAKE_XCODE_ATTRIBUTE_") == 0)
+ {
+ buildSettings->AddAttribute(i->substr(22).c_str(),
+ this->CreateString(
+ this->CurrentMakefile->GetDefinition(i->c_str())));
+ }
+ }
+ }
+
+ std::string symroot = root->GetMakefile()->GetCurrentOutputDirectory();
+ symroot += "/build";
+ buildSettings->AddAttribute("SYMROOT", this->CreateString(symroot.c_str()));
+
+ for( std::vector<cmXCodeObject*>::iterator i = configs.begin();
+ i != configs.end(); ++i)
+ {
+ (*i)->AddAttribute("buildSettings", buildSettings);
+ }
+
+ this->RootObject->AddAttribute("buildConfigurationList",
+ this->CreateObjectReference(configlist));
+
+ std::vector<cmXCodeObject*> targets;
+ for(std::vector<cmLocalGenerator*>::iterator i = generators.begin();
+ i != generators.end(); ++i)
+ {
+ if(!this->IsExcluded(root, *i))
+ {
+ this->CreateXCodeTargets(*i, targets);
+ }
+ }
+ // loop over all targets and add link and depend info
+ for(std::vector<cmXCodeObject*>::iterator i = targets.begin();
+ i != targets.end(); ++i)
+ {
+ cmXCodeObject* t = *i;
+ this->AddDependAndLinkInformation(t);
+ }
+ // now create xcode depend hack makefile
+ this->CreateXCodeDependHackTarget(targets);
+ // now add all targets to the root object
+ cmXCodeObject* allTargets = this->CreateObject(cmXCodeObject::OBJECT_LIST);
+ for(std::vector<cmXCodeObject*>::iterator i = targets.begin();
+ i != targets.end(); ++i)
+ {
+ cmXCodeObject* t = *i;
+ allTargets->AddObject(t);
+ cmXCodeObject* productRef = t->GetObject("productReference");
+ if(productRef)
+ {
+ productGroupChildren->AddObject(productRef->GetObject());
+ }
+ }
+ this->RootObject->AddAttribute("targets", allTargets);
+}
+
+//----------------------------------------------------------------------------
+std::string
+cmGlobalXCodeGenerator::GetObjectsNormalDirectory(
+ const std::string &projName,
+ const std::string &configName,
+ const cmTarget *t) const
+{
+ std::string dir =
+ t->GetMakefile()->GetCurrentOutputDirectory();
+ dir += "/";
+ dir += projName;
+ dir += ".build/";
+ dir += configName;
+ dir += "/";
+ dir += t->GetName();
+ dir += ".build/Objects-normal/";
+
+ return dir;
+}
+
+//----------------------------------------------------------------------------
+void
+cmGlobalXCodeGenerator::CreateXCodeDependHackTarget(
+ std::vector<cmXCodeObject*>& targets)
+{
+ cmGeneratedFileStream
+ makefileStream(this->CurrentXCodeHackMakefile.c_str());
+ if(!makefileStream)
+ {
+ cmSystemTools::Error("Could not create",
+ this->CurrentXCodeHackMakefile.c_str());
+ return;
+ }
+ makefileStream.SetCopyIfDifferent(true);
+ // one more pass for external depend information not handled
+ // correctly by xcode
+ makefileStream << "# DO NOT EDIT\n";
+ makefileStream << "# This makefile makes sure all linkable targets are\n";
+ makefileStream << "# up-to-date with anything they link to\n"
+ "default:\n"
+ "\techo \"Do not invoke directly\"\n"
+ "\n";
+ makefileStream
+ << "# For each target create a dummy rule "
+ "so the target does not have to exist\n";
+ std::set<cmStdString> emitted;
+ for(std::vector<cmXCodeObject*>::iterator i = targets.begin();
+ i != targets.end(); ++i)
+ {
+ cmXCodeObject* target = *i;
+ std::map<cmStdString, cmXCodeObject::StringVec> const& deplibs =
+ target->GetDependLibraries();
+ for(std::map<cmStdString, cmXCodeObject::StringVec>::const_iterator ci
+ = deplibs.begin(); ci != deplibs.end(); ++ci)
+ {
+ for(cmXCodeObject::StringVec::const_iterator d = ci->second.begin();
+ d != ci->second.end(); ++d)
+ {
+ if(emitted.insert(*d).second)
+ {
+ makefileStream <<
+ this->ConvertToRelativeForMake(d->c_str()) << ":\n";
+ }
+ }
+ }
+ }
+ makefileStream << "\n\n";
+
+ // Write rules to help Xcode relink things at the right time.
+ makefileStream <<
+ "# Rules to remove targets that are older than anything to which they\n"
+ "# link. This forces Xcode to relink the targets from scratch. It\n"
+ "# does not seem to check these dependencies itself.\n";
+ for(std::vector<std::string>::const_iterator
+ ct = this->CurrentConfigurationTypes.begin();
+ ct != this->CurrentConfigurationTypes.end(); ++ct)
+ {
+ const char* configName = 0;
+ if(!ct->empty())
+ {
+ configName = ct->c_str();
+ }
+ for(std::vector<cmXCodeObject*>::iterator i = targets.begin();
+ i != targets.end(); ++i)
+ {
+ cmXCodeObject* target = *i;
+ cmTarget* t =target->GetTarget();
+
+ if(t->GetType() == cmTarget::EXECUTABLE ||
+// Nope - no post-build for OBJECT_LIRBRARY
+// t->GetType() == cmTarget::OBJECT_LIBRARY ||
+ t->GetType() == cmTarget::STATIC_LIBRARY ||
+ t->GetType() == cmTarget::SHARED_LIBRARY ||
+ t->GetType() == cmTarget::MODULE_LIBRARY)
+ {
+ // Declare an entry point for the target post-build phase.
+ makefileStream << this->PostBuildMakeTarget(t->GetName(), *ct)
+ << ":\n";
+ }
+
+ if(t->GetType() == cmTarget::EXECUTABLE ||
+ t->GetType() == cmTarget::SHARED_LIBRARY ||
+ t->GetType() == cmTarget::MODULE_LIBRARY)
+ {
+ std::string tfull = t->GetFullPath(configName);
+ std::string trel = this->ConvertToRelativeForMake(tfull.c_str());
+
+ // Add this target to the post-build phases of its dependencies.
+ std::map<cmStdString, cmXCodeObject::StringVec>::const_iterator
+ y = target->GetDependTargets().find(*ct);
+ if(y != target->GetDependTargets().end())
+ {
+ std::vector<cmStdString> const& deptgts = y->second;
+ for(std::vector<cmStdString>::const_iterator d = deptgts.begin();
+ d != deptgts.end(); ++d)
+ {
+ makefileStream << this->PostBuildMakeTarget(*d, *ct) << ": "
+ << trel << "\n";
+ }
+ }
+
+ // Create a rule for this target.
+ makefileStream << trel << ":";
+
+ // List dependencies if any exist.
+ std::map<cmStdString, cmXCodeObject::StringVec>::const_iterator
+ x = target->GetDependLibraries().find(*ct);
+ if(x != target->GetDependLibraries().end())
+ {
+ std::vector<cmStdString> const& deplibs = x->second;
+ for(std::vector<cmStdString>::const_iterator d = deplibs.begin();
+ d != deplibs.end(); ++d)
+ {
+ makefileStream << "\\\n\t" <<
+ this->ConvertToRelativeForMake(d->c_str());
+ }
+ }
+ // Write the action to remove the target if it is out of date.
+ makefileStream << "\n";
+ makefileStream << "\t/bin/rm -f "
+ << this->ConvertToRelativeForMake(tfull.c_str())
+ << "\n";
+ // if building for more than one architecture
+ // then remove those exectuables as well
+ if(this->Architectures.size() > 1)
+ {
+ std::string universal = this->GetObjectsNormalDirectory(
+ this->CurrentProject, configName, t);
+ for( std::vector<std::string>::iterator arch =
+ this->Architectures.begin();
+ arch != this->Architectures.end(); ++arch)
+ {
+ std::string universalFile = universal;
+ universalFile += *arch;
+ universalFile += "/";
+ universalFile += t->GetFullName(configName);
+ makefileStream << "\t/bin/rm -f "
+ <<
+ this->ConvertToRelativeForMake(universalFile.c_str())
+ << "\n";
+ }
+ }
+ makefileStream << "\n\n";
+ }
+ }
+ }
+}
+
+//----------------------------------------------------------------------------
+void
+cmGlobalXCodeGenerator::OutputXCodeProject(cmLocalGenerator* root,
+ std::vector<cmLocalGenerator*>&
+ generators)
+{
+ if(generators.size() == 0)
+ {
+ return;
+ }
+ // Skip local generators that are excluded from this project.
+ for(std::vector<cmLocalGenerator*>::iterator g = generators.begin();
+ g != generators.end(); ++g)
+ {
+ if(this->IsExcluded(root, *g))
+ {
+ continue;
+ }
+ }
+
+ this->CreateXCodeObjects(root,
+ generators);
+ std::string xcodeDir = root->GetMakefile()->GetStartOutputDirectory();
+ xcodeDir += "/";
+ xcodeDir += root->GetMakefile()->GetProjectName();
+ xcodeDir += ".xcode";
+ if(this->XcodeVersion > 20)
+ {
+ xcodeDir += "proj";
+ }
+ cmSystemTools::MakeDirectory(xcodeDir.c_str());
+ std::string xcodeProjFile = xcodeDir + "/project.pbxproj";
+ cmGeneratedFileStream fout(xcodeProjFile.c_str());
+ fout.SetCopyIfDifferent(true);
+ if(!fout)
+ {
+ return;
+ }
+ this->WriteXCodePBXProj(fout, root, generators);
+ this->ClearXCodeObjects();
+
+ // Since this call may have created new cache entries, save the cache:
+ //
+ root->GetMakefile()->GetCacheManager()->SaveCache(
+ root->GetMakefile()->GetHomeOutputDirectory());
+}
+
+//----------------------------------------------------------------------------
+void
+cmGlobalXCodeGenerator::WriteXCodePBXProj(std::ostream& fout,
+ cmLocalGenerator* ,
+ std::vector<cmLocalGenerator*>& )
+{
+ fout << "// !$*UTF8*$!\n";
+ fout << "{\n";
+ cmXCodeObject::Indent(1, fout);
+ fout << "archiveVersion = 1;\n";
+ cmXCodeObject::Indent(1, fout);
+ fout << "classes = {\n";
+ cmXCodeObject::Indent(1, fout);
+ fout << "};\n";
+ cmXCodeObject::Indent(1, fout);
+ if(this->XcodeVersion >= 21)
+ {
+ if (this->XcodeVersion >= 32)
+ fout << "objectVersion = 46;\n";
+ else if (this->XcodeVersion >= 31)
+ fout << "objectVersion = 45;\n";
+ else if (this->XcodeVersion >= 30)
+ fout << "objectVersion = 44;\n";
+ else
+ fout << "objectVersion = 42;\n";
+ cmXCode21Object::PrintList(this->XCodeObjects, fout);
+ }
+ else
+ {
+ fout << "objectVersion = 39;\n";
+ cmXCodeObject::PrintList(this->XCodeObjects, fout);
+ }
+ cmXCodeObject::Indent(1, fout);
+ fout << "rootObject = " << this->RootObject->GetId() << ";\n";
+ fout << "}\n";
+}
+
+//----------------------------------------------------------------------------
+const char* cmGlobalXCodeGenerator::GetCMakeCFGIntDir() const
+{
+ return this->XcodeVersion >= 21 ?
+ "$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)" : ".";
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalXCodeGenerator::GetDocumentation(cmDocumentationEntry& entry)
+ const
+{
+ entry.Name = this->GetName();
+ entry.Brief = "Generate Xcode project files.";
+ entry.Full = "";
+}
+
+//----------------------------------------------------------------------------
+std::string cmGlobalXCodeGenerator::ConvertToRelativeForMake(const char* p)
+{
+ if ( !this->CurrentMakefile->IsOn("CMAKE_USE_RELATIVE_PATHS") )
+ {
+ return cmSystemTools::ConvertToOutputPath(p);
+ }
+ else
+ {
+ std::string ret =
+ this->CurrentLocalGenerator->
+ ConvertToRelativePath(this->CurrentOutputDirectoryComponents, p);
+ return cmSystemTools::ConvertToOutputPath(ret.c_str());
+ }
+}
+
+//----------------------------------------------------------------------------
+std::string cmGlobalXCodeGenerator::ConvertToRelativeForXCode(const char* p)
+{
+ if ( !this->CurrentMakefile->IsOn("CMAKE_USE_RELATIVE_PATHS") )
+ {
+ return cmSystemTools::ConvertToOutputPath(p);
+ }
+ else
+ {
+ std::string ret =
+ this->CurrentLocalGenerator->
+ ConvertToRelativePath(this->ProjectOutputDirectoryComponents, p);
+ return cmSystemTools::ConvertToOutputPath(ret.c_str());
+ }
+}
+
+//----------------------------------------------------------------------------
+std::string cmGlobalXCodeGenerator::RelativeToSource(const char* p)
+{
+ // We force conversion because Xcode breakpoints do not work unless
+ // they are in a file named relative to the source tree.
+ return this->CurrentLocalGenerator->
+ ConvertToRelativePath(this->ProjectSourceDirectoryComponents, p, true);
+}
+
+//----------------------------------------------------------------------------
+std::string cmGlobalXCodeGenerator::RelativeToBinary(const char* p)
+{
+ return this->CurrentLocalGenerator->
+ ConvertToRelativePath(this->ProjectOutputDirectoryComponents, p);
+}
+
+//----------------------------------------------------------------------------
+std::string cmGlobalXCodeGenerator::XCodeEscapePath(const char* p)
+{
+ std::string ret = p;
+ if(ret.find(' ') != ret.npos)
+ {
+ std::string t = ret;
+ ret = "\"";
+ ret += t;
+ ret += "\"";
+ }
+ return ret;
+}
+
+//----------------------------------------------------------------------------
+void
+cmGlobalXCodeGenerator
+::AppendDirectoryForConfig(const char* prefix,
+ const char* config,
+ const char* suffix,
+ std::string& dir)
+{
+ if(this->XcodeVersion > 20)
+ {
+ if(config)
+ {
+ dir += prefix;
+ dir += config;
+ dir += suffix;
+ }
+ }
+}
+
+//----------------------------------------------------------------------------
+std::string cmGlobalXCodeGenerator::LookupFlags(const char* varNamePrefix,
+ const char* varNameLang,
+ const char* varNameSuffix,
+ const char* default_flags)
+{
+ if(varNameLang)
+ {
+ std::string varName = varNamePrefix;
+ varName += varNameLang;
+ varName += varNameSuffix;
+ if(const char* varValue =
+ this->CurrentMakefile->GetDefinition(varName.c_str()))
+ {
+ if(*varValue)
+ {
+ return varValue;
+ }
+ }
+ }
+ return default_flags;
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalXCodeGenerator::AppendDefines(BuildObjectListOrString& defs,
+ const char* defines_list,
+ bool dflag)
+{
+ // Skip this if there are no definitions.
+ if(!defines_list)
+ {
+ return;
+ }
+
+ // Expand the list of definitions.
+ std::vector<std::string> defines;
+ cmSystemTools::ExpandListArgument(defines_list, defines);
+
+ // Store the definitions in the string.
+ this->AppendDefines(defs, defines, dflag);
+}
+
+//----------------------------------------------------------------------------
+void
+cmGlobalXCodeGenerator::AppendDefines(BuildObjectListOrString& defs,
+ std::vector<std::string> const& defines,
+ bool dflag)
+{
+ // GCC_PREPROCESSOR_DEFINITIONS is a space-separated list of definitions.
+ std::string def;
+ for(std::vector<std::string>::const_iterator di = defines.begin();
+ di != defines.end(); ++di)
+ {
+ // Start with -D if requested.
+ def = dflag? "-D": "";
+ def += *di;
+
+ // Append the flag with needed escapes.
+ std::string tmp;
+ this->AppendFlag(tmp, def);
+ defs.Add(tmp.c_str());
+ }
+}
+
+//----------------------------------------------------------------------------
+void cmGlobalXCodeGenerator::AppendFlag(std::string& flags,
+ std::string const& flag)
+{
+ // Short-circuit for an empty flag.
+ if(flag.empty())
+ {
+ return;
+ }
+
+ // Separate from previous flags.
+ if(!flags.empty())
+ {
+ flags += " ";
+ }
+
+ // Check if the flag needs quoting.
+ bool quoteFlag =
+ flag.find_first_of("`~!@#$%^&*()+={}[]|:;\"'<>,.? ") != flag.npos;
+
+ // We escape a flag as follows:
+ // - Place each flag in single quotes ''
+ // - Escape a single quote as \\'
+ // - Escape a backslash as \\\\ since it itself is an escape
+ // Note that in the code below we need one more level of escapes for
+ // C string syntax in this source file.
+ //
+ // The final level of escaping is done when the string is stored
+ // into the project file by cmXCodeObject::PrintString.
+
+ if(quoteFlag)
+ {
+ // Open single quote.
+ flags += "'";
+ }
+
+ // Flag value with escaped quotes and backslashes.
+ for(const char* c = flag.c_str(); *c; ++c)
+ {
+ if(*c == '\'')
+ {
+ if (this->XcodeVersion >= 40)
+ {
+ flags += "'\\\\''";
+ }
+ else
+ {
+ flags += "\\\\'";
+ }
+ }
+ else if(*c == '\\')
+ {
+ flags += "\\\\\\\\";
+ }
+ else
+ {
+ flags += *c;
+ }
+ }
+
+ if(quoteFlag)
+ {
+ // Close single quote.
+ flags += "'";
+ }
+}
+
+//----------------------------------------------------------------------------
+std::string
+cmGlobalXCodeGenerator::ComputeInfoPListLocation(cmTarget& target)
+{
+ std::string plist = target.GetMakefile()->GetCurrentOutputDirectory();
+ plist += cmake::GetCMakeFilesDirectory();
+ plist += "/";
+ plist += target.GetName();
+ plist += ".dir/Info.plist";
+ return plist;
+}
+
+//----------------------------------------------------------------------------
+// Return true if the generated build tree may contain multiple builds.
+// i.e. "Can I build Debug and Release in the same tree?"
+bool cmGlobalXCodeGenerator::IsMultiConfig()
+{
+ // Old Xcode 1.5 is single config:
+ if(this->XcodeVersion == 15)
+ {
+ return false;
+ }
+
+ // Newer Xcode versions are multi config:
+ return true;
+}
+
+ //----------------------------------------------------------------------------
+void
+cmGlobalXCodeGenerator
+::ComputeTargetObjects(cmGeneratorTarget* gt) const
+{
+ // Count the number of object files with each name. Warn about duplicate
+ // names since Xcode names them uniquely automatically with a numeric suffix
+ // to avoid exact duplicate file names. Note that Mac file names are not
+ // typically case sensitive, hence the LowerCase.
+ std::map<cmStdString, int> counts;
+ for(std::vector<cmSourceFile*>::const_iterator
+ si = gt->ObjectSources.begin();
+ si != gt->ObjectSources.end(); ++si)
+ {
+ cmSourceFile* sf = *si;
+ std::string objectName =
+ cmSystemTools::GetFilenameWithoutLastExtension(sf->GetFullPath());
+ objectName += ".o";
+
+ std::string objectNameLower = cmSystemTools::LowerCase(objectName);
+ counts[objectNameLower] += 1;
+ if (2 == counts[objectNameLower])
+ {
+ // TODO: emit warning about duplicate name?
+ }
+
+ gt->Objects[sf] = objectName;
+ }
+
+ const char* configName = this->GetCMakeCFGIntDir();
+ std::string dir = this->GetObjectsNormalDirectory(
+ this->CurrentProject, configName, gt->Target);
+ if(this->XcodeVersion >= 21)
+ {
+ dir += "$(CURRENT_ARCH)/";
+ }
+ else
+ {
+#ifdef __ppc__
+ dir += "ppc/";
+#endif
+#ifdef __i386
+ dir += "i386/";
+#endif
+ }
+ gt->ObjectDirectory = dir;
+}