CMake/Source/cmGlobalXCodeGenerator.cxx

3965 lines
130 KiB
C++
Raw Normal View History

/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
2005-01-25 01:35:54 +03:00
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
2005-01-25 01:35:54 +03:00
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.
============================================================================*/
2005-01-25 01:35:54 +03:00
#include "cmGlobalXCodeGenerator.h"
#include "cmLocalXCodeGenerator.h"
#include "cmMakefile.h"
#include "cmXCodeObject.h"
2005-09-03 00:29:32 +04:00
#include "cmXCode21Object.h"
2005-01-25 01:35:54 +03:00
#include "cmake.h"
#include "cmGeneratedFileStream.h"
#include "cmComputeLinkInformation.h"
2005-01-28 00:11:44 +03:00
#include "cmSourceFile.h"
#include "cmCustomCommandGenerator.h"
#include "cmGeneratorTarget.h"
#include "cmGlobalGeneratorFactory.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 std::string&, const char**)
{
2006-03-15 19:02:08 +03:00
this->Data = "";
}
void EndElement(const std::string& name)
{
if(name == "key")
{
2006-03-15 19:02:08 +03:00
this->Key = this->Data;
}
else if(name == "string")
{
2006-03-15 19:02:08 +03:00
if(this->Key == "CFBundleShortVersionString")
{
this->Version = this->Data;
}
}
}
void CharacterDataHandler(const char* data, int length)
{
2006-03-15 19:02:08 +03:00
this->Data.append(data, length);
}
std::string Version;
2006-03-15 20:02:34 +03:00
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());
}
}
};
class cmGlobalXCodeGenerator::Factory : public cmGlobalGeneratorFactory
{
public:
virtual cmGlobalGenerator* CreateGlobalGenerator(
const std::string& name) const;
virtual void GetDocumentation(cmDocumentationEntry& entry) const {
cmGlobalXCodeGenerator::GetDocumentation(entry); }
virtual void GetGenerators(std::vector<std::string>& names) const {
names.push_back(cmGlobalXCodeGenerator::GetActualName()); }
};
2005-01-25 01:35:54 +03:00
//----------------------------------------------------------------------------
cmGlobalXCodeGenerator::cmGlobalXCodeGenerator(std::string const& version)
2005-01-25 01:35:54 +03:00
{
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];
2006-03-15 19:02:08 +03:00
this->FindMakeProgramFile = "CMakeFindXCode.cmake";
this->RootObject = 0;
this->MainGroupChildren = 0;
this->SourcesGroupChildren = 0;
this->ResourcesGroupChildren = 0;
2006-03-15 19:02:08 +03:00
this->CurrentMakefile = 0;
this->CurrentLocalGenerator = 0;
}
//----------------------------------------------------------------------------
cmGlobalGeneratorFactory* cmGlobalXCodeGenerator::NewFactory()
{
return new Factory;
}
//----------------------------------------------------------------------------
cmGlobalGenerator* cmGlobalXCodeGenerator::Factory
::CreateGlobalGenerator(const std::string& name) const
{
if (name != GetActualName())
return 0;
#if defined(CMAKE_BUILD_WITH_CMAKE)
cmXcodeVersionParser parser;
std::string versionFile;
{
std::string out;
std::string::size_type pos;
if(cmSystemTools::RunSingleCommand("xcode-select --print-path", &out, 0, 0,
cmSystemTools::OUTPUT_NONE) &&
(pos = out.find(".app/"), pos != out.npos))
{
versionFile = out.substr(0, pos+5)+"Contents/version.plist";
}
}
if(!versionFile.empty() && cmSystemTools::FileExists(versionFile.c_str()))
{
parser.ParseFile(versionFile.c_str());
}
else 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, "
2006-05-11 19:47:03 +04:00
"default to Xcode 1.5\n";
return new cmGlobalXCodeGenerator;
#endif
2005-01-25 01:35:54 +03:00
}
//----------------------------------------------------------------------------
bool cmGlobalXCodeGenerator::SetGeneratorToolset(std::string const& ts,
cmMakefile* mf)
{
if(this->XcodeVersion >= 30)
{
this->GeneratorToolset = ts;
if(!this->GeneratorToolset.empty())
{
mf->AddDefinition("CMAKE_XCODE_PLATFORM_TOOLSET",
this->GeneratorToolset.c_str());
}
return true;
}
else
{
return cmGlobalGenerator::SetGeneratorToolset(ts, mf);
}
}
2005-01-25 01:35:54 +03:00
//----------------------------------------------------------------------------
2005-02-05 01:58:58 +03:00
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());
2006-03-15 19:02:08 +03:00
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);
}
}
2005-02-01 23:48:33 +03:00
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);
}
2005-01-25 01:35:54 +03:00
}
//----------------------------------------------------------------------------
void
cmGlobalXCodeGenerator::GenerateBuildCommand(
std::vector<std::string>& makeCommand,
const std::string& makeProgram,
const std::string& projectName,
2014-02-25 02:38:30 +04:00
const std::string& /*projectDir*/,
2014-02-07 02:31:47 +04:00
const std::string& targetName,
const std::string& config,
bool /*fast*/,
std::vector<std::string> const& makeOptions)
2005-01-25 01:35:54 +03:00
{
2005-02-01 21:07:42 +03:00
// now build the test
makeCommand.push_back(
this->SelectMakeProgram(makeProgram, "xcodebuild")
);
2005-02-01 21:07:42 +03:00
makeCommand.push_back("-project");
std::string projectArg = projectName;
projectArg += ".xcode";
2006-03-15 19:02:08 +03:00
if(this->XcodeVersion > 20)
2005-09-03 00:29:32 +04:00
{
projectArg += "proj";
2005-09-03 00:29:32 +04:00
}
makeCommand.push_back(projectArg);
2005-09-03 00:29:32 +04:00
bool clean = false;
2014-02-07 02:31:47 +04:00
std::string realTarget = targetName;
if ( realTarget == "clean" )
{
clean = true;
2014-02-07 02:31:47 +04:00
realTarget = "ALL_BUILD";
}
2005-02-25 01:46:49 +03:00
if(clean)
{
makeCommand.push_back("clean");
}
else
{
makeCommand.push_back("build");
2005-02-25 01:46:49 +03:00
}
makeCommand.push_back("-target");
2014-02-07 02:31:47 +04:00
if (!realTarget.empty())
2005-02-01 21:07:42 +03:00
{
2014-02-07 02:31:47 +04:00
makeCommand.push_back(realTarget);
2005-02-01 21:07:42 +03:00
}
2005-02-17 02:47:30 +03:00
else
{
makeCommand.push_back("ALL_BUILD");
2005-02-17 02:47:30 +03:00
}
2006-03-15 19:02:08 +03:00
if(this->XcodeVersion == 15)
{
makeCommand.push_back("-buildstyle");
makeCommand.push_back("Development");
}
else
{
makeCommand.push_back("-configuration");
makeCommand.push_back(!config.empty()?config:"Debug");
}
makeCommand.insert(makeCommand.end(),
makeOptions.begin(), makeOptions.end());
2005-01-25 01:35:54 +03:00
}
//----------------------------------------------------------------------------
///! 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<std::string, std::vector<cmLocalGenerator*> >::iterator it;
2007-05-10 18:05:36 +04:00
// make sure extra targets are added before calling
// the parent generate which will call trace depends
2006-03-15 19:02:08 +03:00
for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
{
cmLocalGenerator* root = it->second[0];
this->SetGenerationRoot(root);
2005-02-18 21:32:51 +03:00
// add ALL_BUILD, INSTALL, etc
this->AddExtraTargets(root, it->second);
2007-05-10 18:05:36 +04:00
}
this->cmGlobalGenerator::Generate();
if(cmSystemTools::GetErrorOccuredFlag())
{
return;
}
2007-05-10 18:05:36 +04:00
for(it = this->ProjectMap.begin(); it!= this->ProjectMap.end(); ++it)
{
2007-05-10 18:05:36 +04:00
cmLocalGenerator* root = it->second[0];
this->SetGenerationRoot(root);
2005-02-18 21:32:51 +03:00
// 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"
2005-02-18 21:32:51 +03:00
//----------------------------------------------------------------------------
void
cmGlobalXCodeGenerator::AddExtraTargets(cmLocalGenerator* root,
2005-02-18 21:32:51 +03:00
std::vector<cmLocalGenerator*>& gens)
{
cmMakefile* mf = root->GetMakefile();
2005-02-18 21:32:51 +03:00
// Add ALL_BUILD
2006-02-08 18:58:36 +03:00
const char* no_working_directory = 0;
std::vector<std::string> no_depends;
2007-03-13 22:18:27 +03:00
mf->AddUtilityCommand("ALL_BUILD", true, no_depends,
2006-02-08 18:58:36 +03:00
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->AddSourceCMP0049(listfile.c_str());
// Add XCODE depend helper
2005-02-18 23:45:19 +03:00
std::string dir = mf->GetCurrentOutputDirectory();
cmCustomCommandLine makeHelper;
if(this->XcodeVersion < 50)
{
makeHelper.push_back("make");
makeHelper.push_back("-C");
makeHelper.push_back(dir.c_str());
makeHelper.push_back("-f");
makeHelper.push_back(this->CurrentXCodeHackMakefile.c_str());
makeHelper.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());
}
2005-02-28 23:07:13 +03:00
2005-02-18 21:32:51 +03:00
// 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;
2005-02-18 21:32:51 +03:00
if(this->IsExcluded(root, *i))
{
continue;
}
2005-02-18 21:32:51 +03:00
cmTargets& tgts = lg->GetMakefile()->GetTargets();
for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); l++)
2005-02-17 00:35:32 +03:00
{
2005-02-18 21:32:51 +03:00
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(!makeHelper.empty() &&
(target.GetType() == cmTarget::EXECUTABLE ||
// Nope - no post-build for OBJECT_LIRBRARY
// target.GetType() == cmTarget::OBJECT_LIBRARY ||
target.GetType() == cmTarget::STATIC_LIBRARY ||
2005-02-18 21:32:51 +03:00
target.GetType() == cmTarget::SHARED_LIBRARY ||
target.GetType() == cmTarget::MODULE_LIBRARY))
{
makeHelper[makeHelper.size()-1] = // fill placeholder
this->PostBuildMakeTarget(target.GetName(), "$(CONFIGURATION)");
cmCustomCommandLines commandLines;
commandLines.push_back(makeHelper);
Add an option for explicit BYPRODUCTS of custom commands (#14963) A common idiom in CMake-based build systems is to have custom commands that generate files not listed explicitly as outputs so that these files do not have to be newer than the inputs. The file modification times of such "byproducts" are updated only when their content changes. Then other build rules can depend on the byproducts explicitly so that their dependents rebuild when the content of the original byproducts really does change. This "undeclared byproduct" approach is necessary for Makefile, VS, and Xcode build tools because if a byproduct were listed as an output of a rule then the rule would always rerun when the input is newer than the byproduct but the byproduct may never be updated. Ninja solves this problem by offering a 'restat' feature to check whether an output was really modified after running a rule and tracking the fact that it is up to date separately from its timestamp. However, Ninja also stats all dependencies up front and will only restat files that are listed as outputs of rules with the 'restat' option enabled. Therefore an undeclared byproduct that does not exist at the start of the build will be considered missing and the build will fail even if other dependencies would cause the byproduct to be available before its dependents build. CMake works around this limitation by adding 'phony' build rules for custom command dependencies in the build tree that do not have any explicit specification of what produces them. This is not optimal because it prevents Ninja from reporting an error when an input to a rule really is missing. A better approach is to allow projects to explicitly specify the byproducts of their custom commands so that no phony rules are needed for them. In order to work with the non-Ninja generators, the byproducts must be known separately from the outputs. Add a new "BYPRODUCTS" option to the add_custom_command and add_custom_target commands to specify byproducts explicitly. Teach the Ninja generator to specify byproducts as outputs of the custom commands. In the case of POST_BUILD, PRE_LINK, and PRE_BUILD events on targets that link, the byproducts must be specified as outputs of the link rule that runs the commands. Activate 'restat' for such rules so that Ninja knows it needs to check the byproducts, but not for link rules that have no byproducts.
2014-11-14 02:54:52 +03:00
std::vector<std::string> no_byproducts;
lg->GetMakefile()->AddCustomCommandToTarget(target.GetName(),
Add an option for explicit BYPRODUCTS of custom commands (#14963) A common idiom in CMake-based build systems is to have custom commands that generate files not listed explicitly as outputs so that these files do not have to be newer than the inputs. The file modification times of such "byproducts" are updated only when their content changes. Then other build rules can depend on the byproducts explicitly so that their dependents rebuild when the content of the original byproducts really does change. This "undeclared byproduct" approach is necessary for Makefile, VS, and Xcode build tools because if a byproduct were listed as an output of a rule then the rule would always rerun when the input is newer than the byproduct but the byproduct may never be updated. Ninja solves this problem by offering a 'restat' feature to check whether an output was really modified after running a rule and tracking the fact that it is up to date separately from its timestamp. However, Ninja also stats all dependencies up front and will only restat files that are listed as outputs of rules with the 'restat' option enabled. Therefore an undeclared byproduct that does not exist at the start of the build will be considered missing and the build will fail even if other dependencies would cause the byproduct to be available before its dependents build. CMake works around this limitation by adding 'phony' build rules for custom command dependencies in the build tree that do not have any explicit specification of what produces them. This is not optimal because it prevents Ninja from reporting an error when an input to a rule really is missing. A better approach is to allow projects to explicitly specify the byproducts of their custom commands so that no phony rules are needed for them. In order to work with the non-Ninja generators, the byproducts must be known separately from the outputs. Add a new "BYPRODUCTS" option to the add_custom_command and add_custom_target commands to specify byproducts explicitly. Teach the Ninja generator to specify byproducts as outputs of the custom commands. In the case of POST_BUILD, PRE_LINK, and PRE_BUILD events on targets that link, the byproducts must be specified as outputs of the link rule that runs the commands. Activate 'restat' for such rules so that Ninja knows it needs to check the byproducts, but not for link rules that have no byproducts.
2014-11-14 02:54:52 +03:00
no_byproducts,
no_depends,
commandLines,
cmTarget::POST_BUILD,
"Depend check for xcode",
dir.c_str());
}
if(target.GetType() != cmTarget::INTERFACE_LIBRARY
&& !target.GetPropertyAsBool("EXCLUDE_FROM_ALL"))
2005-02-17 00:35:32 +03:00
{
2005-02-18 21:32:51 +03:00
allbuild->AddUtility(target.GetName());
2005-02-17 00:35:32 +03:00
}
// Refer to the build configuration file for easy editing.
listfile = lg->GetMakefile()->GetStartDirectory();
listfile += "/";
listfile += "CMakeLists.txt";
target.AddSourceCMP0049(listfile.c_str());
2005-02-17 00:35:32 +03:00
}
2005-01-25 01:35:54 +03:00
}
}
2005-02-28 23:07:13 +03:00
//----------------------------------------------------------------------------
void cmGlobalXCodeGenerator::CreateReRunCMakeFile(
cmLocalGenerator* root, std::vector<cmLocalGenerator*> const& gens)
2005-02-28 23:07:13 +03:00
{
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());
}
2005-02-28 23:07:13 +03:00
// sort the array
std::sort(lfiles.begin(), lfiles.end(), std::less<std::string>());
std::vector<std::string>::iterator new_end =
2005-02-28 23:07:13 +03:00
std::unique(lfiles.begin(), lfiles.end());
lfiles.erase(new_end, lfiles.end());
this->CurrentReRunCMakeMakefile = mf->GetStartOutputDirectory();
2006-03-15 19:02:08 +03:00
this->CurrentReRunCMakeMakefile += "/CMakeScripts";
cmSystemTools::MakeDirectory(this->CurrentReRunCMakeMakefile.c_str());
this->CurrentReRunCMakeMakefile += "/ReRunCMake.make";
2006-05-11 23:39:46 +04:00
cmGeneratedFileStream makefileStream
(this->CurrentReRunCMakeMakefile.c_str());
makefileStream.SetCopyIfDifferent(true);
2005-02-28 23:07:13 +03:00
makefileStream << "# Generated by CMake, DO NOT EDIT\n";
std::string checkCache = mf->GetHomeOutputDirectory();
checkCache += "/";
checkCache += cmake::GetCMakeFilesDirectoryPostSlash();
checkCache += "cmake.check_cache";
makefileStream << this->ConvertToRelativeForMake(checkCache.c_str())
<< ": ";
2005-02-28 23:07:13 +03:00
for(std::vector<std::string>::const_iterator i = lfiles.begin();
i != lfiles.end(); ++i)
{
2005-03-01 19:25:23 +03:00
makefileStream << "\\\n" << this->ConvertToRelativeForMake(i->c_str());
2005-02-28 23:07:13 +03:00
}
std::string cmake = mf->GetRequiredDefinition("CMAKE_COMMAND");
makefileStream << "\n\t" << this->ConvertToRelativeForMake(cmake.c_str())
2005-02-28 23:07:13 +03:00
<< " -H" << this->ConvertToRelativeForMake(
mf->GetHomeDirectory())
<< " -B" << this->ConvertToRelativeForMake(
mf->GetHomeOutputDirectory()) << "\n";
}
2005-01-25 01:35:54 +03:00
//----------------------------------------------------------------------------
void cmGlobalXCodeGenerator::ClearXCodeObjects()
{
2006-03-15 19:02:08 +03:00
this->TargetDoneSet.clear();
for(unsigned int i = 0; i < this->XCodeObjects.size(); ++i)
2005-01-25 01:35:54 +03:00
{
2006-03-15 19:02:08 +03:00
delete this->XCodeObjects[i];
2005-01-25 01:35:54 +03:00
}
2006-03-15 19:02:08 +03:00
this->XCodeObjects.clear();
this->XCodeObjectIDs.clear();
this->XCodeObjectMap.clear();
2006-03-15 19:02:08 +03:00
this->GroupMap.clear();
this->GroupNameMap.clear();
this->TargetGroup.clear();
this->FileRefs.clear();
2005-01-25 01:35:54 +03:00
}
//----------------------------------------------------------------------------
void cmGlobalXCodeGenerator::addObject(cmXCodeObject *obj)
{
if(obj->GetType() == cmXCodeObject::OBJECT)
{
std::string 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);
}
2005-01-25 01:35:54 +03:00
//----------------------------------------------------------------------------
cmXCodeObject*
cmGlobalXCodeGenerator::CreateObject(cmXCodeObject::PBXType ptype)
2005-01-25 01:35:54 +03:00
{
2005-09-03 00:29:32 +04:00
cmXCodeObject* obj;
2006-03-15 19:02:08 +03:00
if(this->XcodeVersion == 15)
2005-09-03 00:29:32 +04:00
{
obj = new cmXCodeObject(ptype, cmXCodeObject::OBJECT);
}
else
{
obj = new cmXCode21Object(ptype, cmXCodeObject::OBJECT);
}
this->addObject(obj);
2005-01-25 01:35:54 +03:00
return obj;
}
2005-01-28 00:11:44 +03:00
//----------------------------------------------------------------------------
cmXCodeObject*
cmGlobalXCodeGenerator::CreateObject(cmXCodeObject::Type type)
{
2005-01-28 00:11:44 +03:00
cmXCodeObject* obj = new cmXCodeObject(cmXCodeObject::None, type);
this->addObject(obj);
2005-01-28 00:11:44 +03:00
return obj;
}
2005-02-18 21:32:51 +03:00
//----------------------------------------------------------------------------
cmXCodeObject*
cmGlobalXCodeGenerator::CreateString(const std::string& s)
2005-01-28 00:11:44 +03:00
{
cmXCodeObject* obj = this->CreateObject(cmXCodeObject::STRING);
obj->SetString(s);
return obj;
}
2005-02-18 21:32:51 +03:00
//----------------------------------------------------------------------------
2006-05-11 23:39:46 +04:00
cmXCodeObject* cmGlobalXCodeGenerator
::CreateObjectReference(cmXCodeObject* ref)
2005-01-29 00:00:10 +03:00
{
cmXCodeObject* obj = this->CreateObject(cmXCodeObject::OBJECT_REF);
obj->SetObject(ref);
return obj;
}
//----------------------------------------------------------------------------
std::string
GetGroupMapKeyFromPath(cmTarget& cmtarget, const std::string& fullpath)
{
std::string key(cmtarget.GetName());
key += "-";
key += fullpath;
return key;
}
//----------------------------------------------------------------------------
std::string
GetGroupMapKey(cmTarget& cmtarget, cmSourceFile* sf)
{
return GetGroupMapKeyFromPath(cmtarget, sf->GetFullPath());
}
//----------------------------------------------------------------------------
cmXCodeObject*
cmGlobalXCodeGenerator::CreateXCodeSourceFileFromPath(
const std::string &fullpath,
cmTarget& cmtarget,
const std::string &lang,
cmSourceFile* sf)
{
// 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, sf);
cmXCodeObject* buildFile = this->CreateObject(cmXCodeObject::PBXBuildFile);
buildFile->SetComment(fileRef->GetComment());
buildFile->AddAttribute("fileRef", this->CreateObjectReference(fileRef));
return buildFile;
}
2005-02-18 21:32:51 +03:00
//----------------------------------------------------------------------------
cmXCodeObject*
cmGlobalXCodeGenerator::CreateXCodeSourceFile(cmLocalGenerator* lg,
2006-01-25 16:38:06 +03:00
cmSourceFile* sf,
cmTarget& cmtarget)
2005-01-28 00:11:44 +03:00
{
// Add flags from target and source file properties.
2005-02-11 22:25:05 +03:00
std::string 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;
}
2005-02-18 22:32:55 +03:00
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();
}
std::string lang =
this->CurrentLocalGenerator->GetSourceFileLanguage(*sf);
cmXCodeObject* buildFile =
this->CreateXCodeSourceFileFromPath(sf->GetFullPath(), cmtarget, lang, sf);
cmXCodeObject* fileRef = buildFile->GetObject("fileRef")->GetObject();
cmXCodeObject* settings =
2006-05-11 23:39:46 +04:00
this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
2005-02-11 22:25:05 +03:00
settings->AddAttribute("COMPILER_FLAGS", this->CreateString(flags.c_str()));
// Is this a resource file in this target? Add it to the resources group...
//
cmGeneratorTarget::SourceFileFlags tsFlags =
this->GetGeneratorTarget(&cmtarget)->GetTargetSourceFileFlags(sf);
bool isResource = tsFlags.Type == cmGeneratorTarget::SourceFileTypeResource;
// Is this a "private" or "public" framework header file?
// Set the ATTRIBUTES attribute appropriately...
//
if(cmtarget.IsFrameworkOnApple())
{
if(tsFlags.Type == cmGeneratorTarget::SourceFileTypePrivateHeader)
{
cmXCodeObject* attrs = this->CreateObject(cmXCodeObject::OBJECT_LIST);
attrs->AddObject(this->CreateString("Private"));
settings->AddAttribute("ATTRIBUTES", attrs);
isResource = true;
}
else if(tsFlags.Type == cmGeneratorTarget::SourceFileTypePublicHeader)
{
cmXCodeObject* attrs = this->CreateObject(cmXCodeObject::OBJECT_LIST);
attrs->AddObject(this->CreateString("Public"));
settings->AddAttribute("ATTRIBUTES", attrs);
isResource = true;
}
}
// 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);
}
2005-01-28 00:11:44 +03:00
buildFile->AddAttribute("settings", settings);
return buildFile;
}
//----------------------------------------------------------------------------
std::string
GetSourcecodeValueFromFileExtension(const std::string& _ext,
const std::string& lang,
bool& keepLastKnownFileType)
{
std::string ext = cmSystemTools::LowerCase(_ext);
2005-02-01 23:48:33 +03:00
std::string sourcecode = "sourcecode";
if(ext == "o")
2005-02-01 23:48:33 +03:00
{
2005-02-18 21:32:51 +03:00
sourcecode = "compiled.mach-o.objfile";
2005-02-02 01:17:12 +03:00
}
else if(ext == "xib")
{
keepLastKnownFileType = true;
sourcecode = "file.xib";
}
else if(ext == "storyboard")
{
keepLastKnownFileType = true;
sourcecode = "file.storyboard";
}
else if(ext == "mm")
{
sourcecode += ".cpp.objcpp";
}
else if(ext == "m")
{
sourcecode += ".c.objc";
}
2006-01-05 17:13:06 +03:00
else if(ext == "plist")
{
sourcecode += ".text.plist";
}
else if(ext == "h")
2005-02-02 01:17:12 +03:00
{
sourcecode += ".c.h";
}
else if(ext == "hxx" || ext == "hpp" || ext == "txx"
2010-10-12 17:06:33 +04:00
|| ext == "pch" || ext == "hh")
{
sourcecode += ".cpp.h";
2005-02-01 23:48:33 +03:00
}
else if(ext == "png" || ext == "gif" || ext == "jpg")
2005-02-01 23:48:33 +03:00
{
keepLastKnownFileType = true;
sourcecode = "image";
2005-02-01 23:48:33 +03:00
}
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 if(lang == "ASM")
{
sourcecode += ".asm";
}
//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 explicitFileType value.
// }
return sourcecode;
}
//----------------------------------------------------------------------------
cmXCodeObject*
cmGlobalXCodeGenerator::CreateXCodeFileReferenceFromPath(
const std::string &fullpath,
cmTarget& cmtarget,
const std::string &lang,
cmSourceFile* sf)
{
std::string key = GetGroupMapKeyFromPath(cmtarget, fullpath);
cmXCodeObject* fileRef = this->FileRefs[key];
if(!fileRef)
{
fileRef = this->CreateObject(cmXCodeObject::PBXFileReference);
fileRef->SetComment(fullpath);
this->FileRefs[key] = fileRef;
}
cmXCodeObject* group = this->GroupMap[key];
cmXCodeObject* children = group->GetObject("children");
if (!children->HasObject(fileRef))
{
children->AddObject(fileRef);
}
fileRef->AddAttribute("fileEncoding", this->CreateString("4"));
bool useLastKnownFileType = false;
std::string fileType;
if(sf)
{
if(const char* e = sf->GetProperty("XCODE_EXPLICIT_FILE_TYPE"))
{
fileType = e;
}
else if(const char* l = sf->GetProperty("XCODE_LAST_KNOWN_FILE_TYPE"))
{
useLastKnownFileType = true;
fileType = l;
}
}
if(fileType.empty())
{
// Compute the extension without leading '.'.
std::string ext = cmSystemTools::GetFilenameLastExtension(fullpath);
if(!ext.empty())
{
ext = ext.substr(1);
}
// If fullpath references a directory, then we need to specify
// lastKnownFileType as folder in order for Xcode to be able to
// open the contents of the folder.
// (Xcode 4.6 does not like explicitFileType=folder).
if(cmSystemTools::FileIsDirectory(fullpath.c_str()))
{
fileType = (ext == "xcassets"? "folder.assetcatalog" : "folder");
useLastKnownFileType = true;
}
else
{
fileType = GetSourcecodeValueFromFileExtension(
ext, lang, useLastKnownFileType);
}
}
fileRef->AddAttribute(useLastKnownFileType? "lastKnownFileType"
: "explicitFileType",
this->CreateString(fileType));
// 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()));
2005-02-18 21:32:51 +03:00
fileRef->AddAttribute("path", this->CreateString(path.c_str()));
fileRef->AddAttribute("sourceTree", this->CreateString(sourceTree));
2006-03-15 19:02:08 +03:00
if(this->XcodeVersion == 15)
{
fileRef->AddAttribute("refType", this->CreateString("4"));
}
return fileRef;
2005-01-28 00:11:44 +03:00
}
2005-02-18 21:32:51 +03:00
//----------------------------------------------------------------------------
cmXCodeObject*
cmGlobalXCodeGenerator::CreateXCodeFileReference(cmSourceFile* sf,
cmTarget& cmtarget)
{
std::string lang =
this->CurrentLocalGenerator->GetSourceFileLanguage(*sf);
return this->CreateXCodeFileReferenceFromPath(
sf->GetFullPath(), cmtarget, lang, sf);
}
2005-02-18 21:32:51 +03:00
//----------------------------------------------------------------------------
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 )
2005-02-18 21:32:51 +03:00
{
2006-03-15 19:02:08 +03:00
if(this->TargetDoneSet.find(tname) != this->TargetDoneSet.end())
2005-02-18 21:32:51 +03:00
{
return true;
}
2006-03-15 19:02:08 +03:00
this->TargetDoneSet.insert(tname);
2005-02-18 21:32:51 +03:00
return false;
}
return false;
}
//----------------------------------------------------------------------------
2005-02-25 01:46:49 +03:00
void cmGlobalXCodeGenerator::SetCurrentLocalGenerator(cmLocalGenerator* gen)
{
2006-03-15 19:02:08 +03:00
this->CurrentLocalGenerator = gen;
this->CurrentMakefile = gen->GetMakefile();
2005-02-25 01:46:49 +03:00
std::string outdir =
2006-03-15 19:02:08 +03:00
cmSystemTools::CollapseFullPath(this->CurrentMakefile->
GetCurrentOutputDirectory());
cmSystemTools::SplitPath(outdir.c_str(),
2006-05-11 23:39:46 +04:00
this->CurrentOutputDirectoryComponents);
// Select the current set of configuration types.
2006-03-15 19:02:08 +03:00
this->CurrentConfigurationTypes.clear();
this->CurrentMakefile->GetConfigurations(this->CurrentConfigurationTypes);
2006-03-15 19:02:08 +03:00
if(this->CurrentConfigurationTypes.empty())
{
this->CurrentConfigurationTypes.push_back("");
}
2005-02-25 01:46:49 +03:00
}
//----------------------------------------------------------------------------
struct cmSourceFilePathCompare
{
bool operator()(cmSourceFile* l, cmSourceFile* r)
{
return l->GetFullPath() < r->GetFullPath();
}
};
2005-01-25 01:35:54 +03:00
//----------------------------------------------------------------------------
void
2005-02-04 01:42:55 +03:00
cmGlobalXCodeGenerator::CreateXCodeTargets(cmLocalGenerator* gen,
std::vector<cmXCodeObject*>&
2005-02-09 01:12:38 +03:00
targets)
2005-01-28 00:11:44 +03:00
{
2005-02-25 01:46:49 +03:00
this->SetCurrentLocalGenerator(gen);
2006-03-15 19:02:08 +03:00
cmTargets &tgts = this->CurrentMakefile->GetTargets();
2005-01-28 00:11:44 +03:00
for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); l++)
{
2005-02-04 01:42:55 +03:00
cmTarget& cmtarget = l->second;
cmGeneratorTarget* gtgt = this->GetGeneratorTarget(&cmtarget);
2005-02-18 21:32:51 +03:00
// make sure ALL_BUILD, INSTALL, etc are only done once
if(this->SpecialTargetEmitted(l->first.c_str()))
{
2005-02-18 21:32:51 +03:00
continue;
}
if(cmtarget.GetType() == cmTarget::INTERFACE_LIBRARY)
{
continue;
}
if(cmtarget.GetType() == cmTarget::UTILITY ||
cmtarget.GetType() == cmTarget::GLOBAL_TARGET)
{
targets.push_back(this->CreateUtilityTarget(cmtarget));
2005-02-04 01:42:55 +03:00
continue;
}
// organize the sources
std::vector<cmSourceFile*> classes;
if (!cmtarget.GetConfigCommonSourceFiles(classes))
{
return;
}
std::sort(classes.begin(), classes.end(), cmSourceFilePathCompare());
gtgt->ComputeObjectMapping();
2005-02-18 21:32:51 +03:00
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();
2005-01-28 00:11:44 +03:00
i != classes.end(); ++i)
{
cmXCodeObject* xsf =
this->CreateXCodeSourceFile(this->CurrentLocalGenerator,
2006-05-11 23:39:46 +04:00
*i, cmtarget);
2005-02-18 21:32:51 +03:00
cmXCodeObject* fr = xsf->GetObject("fileRef");
cmXCodeObject* filetype =
fr->GetObject()->GetObject("explicitFileType");
cmGeneratorTarget::SourceFileFlags tsFlags =
gtgt->GetTargetSourceFileFlags(*i);
if(filetype &&
filetype->GetString() == "compiled.mach-o.objfile")
2005-02-18 21:32:51 +03:00
{
if ((*i)->GetObjectLibrary().empty())
{
externalObjFiles.push_back(xsf);
}
2005-02-18 21:32:51 +03:00
}
else if(this->IsHeaderFile(*i) ||
(tsFlags.Type == cmGeneratorTarget::SourceFileTypePrivateHeader) ||
(tsFlags.Type == cmGeneratorTarget::SourceFileTypePublicHeader))
{
headerFiles.push_back(xsf);
}
else if(tsFlags.Type == cmGeneratorTarget::SourceFileTypeResource)
{
resourceFiles.push_back(xsf);
}
else if(!(*i)->GetPropertyAsBool("HEADER_FILE_ONLY"))
2005-02-18 21:32:51 +03:00
{
// 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).empty() &&
!this->IgnoreFile((*i)->GetExtension().c_str()))
{
sourceFiles.push_back(xsf);
}
2005-02-18 21:32:51 +03:00
}
2005-01-28 00:11:44 +03:00
}
if(this->XcodeVersion < 50)
{
// 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;
gtgt->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, "", 0);
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)
2005-02-18 21:32:51 +03:00
{
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"));
2005-02-18 21:32:51 +03:00
}
// create resource build phase - only for framework or bundle targets
cmXCodeObject* resourceBuildPhase = 0;
if (!resourceFiles.empty() &&
(isFrameworkTarget || isBundleTarget || isCFBundleTarget))
2006-03-30 00:02:35 +04:00
{
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)
2006-03-30 00:02:35 +04:00
{
buildFiles->AddObject(*i);
2006-03-30 00:02:35 +04:00
}
resourceBuildPhase->AddAttribute("files", buildFiles);
resourceBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
this->CreateString("0"));
2006-03-30 00:02:35 +04:00
}
// create vector of "non-resource content file" build phases - only for
// framework or bundle targets
std::vector<cmXCodeObject*> contentBuildPhases;
if (isFrameworkTarget || isBundleTarget || isCFBundleTarget)
2006-03-30 00:02:35 +04:00
{
typedef std::map<std::string, std::vector<cmSourceFile*> >
mapOfVectorOfSourceFiles;
mapOfVectorOfSourceFiles bundleFiles;
for(std::vector<cmSourceFile*>::const_iterator i = classes.begin();
i != classes.end(); ++i)
{
cmGeneratorTarget::SourceFileFlags tsFlags =
gtgt->GetTargetSourceFileFlags(*i);
if(tsFlags.Type == cmGeneratorTarget::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"));
2006-03-30 00:02:35 +04:00
buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
frameworkBuildPhase->AddAttribute("files", buildFiles);
for(std::vector<cmXCodeObject*>::iterator i = externalObjFiles.begin();
i != externalObjFiles.end(); ++i)
2006-03-30 00:02:35 +04:00
{
buildFiles->AddObject(*i);
2006-03-30 00:02:35 +04:00
}
frameworkBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
this->CreateString("0"));
2006-03-30 00:02:35 +04:00
}
2007-05-25 01:06:32 +04:00
// 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(TargetMap::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;
}
std::string llang = cmtarget.GetLinkerLanguage("NOCONFIG");
if(llang.empty()) { 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.c_str());
cmtarget.AddSource(fname);
}
}
//----------------------------------------------------------------------------
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());
}
2005-02-28 23:07:13 +03:00
//----------------------------------------------------------------------------
cmXCodeObject*
cmGlobalXCodeGenerator::CreateBuildPhase(const char* name,
2005-02-28 23:07:13 +03:00
const char* name2,
cmTarget& cmtarget,
const std::vector<cmCustomCommand>&
commands)
{
if(commands.size() == 0 && strcmp(name, "CMake ReRun") != 0)
{
return 0;
}
cmXCodeObject* buildPhase =
2005-02-28 23:07:13 +03:00
this->CreateObject(cmXCodeObject::PBXShellScriptBuildPhase);
buildPhase->AddAttribute("buildActionMask",
2005-11-18 22:12:09 +03:00
this->CreateString("2147483647"));
2005-02-28 23:07:13 +03:00
cmXCodeObject* buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
buildPhase->AddAttribute("files", buildFiles);
buildPhase->AddAttribute("name",
2005-02-28 23:07:13 +03:00
this->CreateString(name));
buildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
2005-02-28 23:07:13 +03:00
this->CreateString("0"));
buildPhase->AddAttribute("shellPath",
this->CreateString("/bin/sh"));
this->AddCommandsToBuildPhase(buildPhase, cmtarget, commands,
name2);
return buildPhase;
}
2005-02-18 21:32:51 +03:00
//----------------------------------------------------------------------------
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> postbuild
= cmtarget.GetPostBuildCommands();
if(cmtarget.GetType() == cmTarget::SHARED_LIBRARY &&
!cmtarget.IsFrameworkOnApple())
{
cmCustomCommandLines cmd;
cmd.resize(1);
cmd[0].push_back(this->CurrentMakefile->GetDefinition("CMAKE_COMMAND"));
cmd[0].push_back("-E");
cmd[0].push_back("cmake_symlink_library");
std::string str_file = "$<TARGET_FILE:";
str_file += cmtarget.GetName();
str_file += ">";
std::string str_so_file = "$<TARGET_SONAME_FILE:";
str_so_file += cmtarget.GetName();
str_so_file += ">";
std::string str_link_file = "$<TARGET_LINKER_FILE:";
str_link_file += cmtarget.GetName();
str_link_file += ">";
cmd[0].push_back(str_file);
cmd[0].push_back(str_so_file);
cmd[0].push_back(str_link_file);
cmCustomCommand command(this->CurrentMakefile,
Add an option for explicit BYPRODUCTS of custom commands (#14963) A common idiom in CMake-based build systems is to have custom commands that generate files not listed explicitly as outputs so that these files do not have to be newer than the inputs. The file modification times of such "byproducts" are updated only when their content changes. Then other build rules can depend on the byproducts explicitly so that their dependents rebuild when the content of the original byproducts really does change. This "undeclared byproduct" approach is necessary for Makefile, VS, and Xcode build tools because if a byproduct were listed as an output of a rule then the rule would always rerun when the input is newer than the byproduct but the byproduct may never be updated. Ninja solves this problem by offering a 'restat' feature to check whether an output was really modified after running a rule and tracking the fact that it is up to date separately from its timestamp. However, Ninja also stats all dependencies up front and will only restat files that are listed as outputs of rules with the 'restat' option enabled. Therefore an undeclared byproduct that does not exist at the start of the build will be considered missing and the build will fail even if other dependencies would cause the byproduct to be available before its dependents build. CMake works around this limitation by adding 'phony' build rules for custom command dependencies in the build tree that do not have any explicit specification of what produces them. This is not optimal because it prevents Ninja from reporting an error when an input to a rule really is missing. A better approach is to allow projects to explicitly specify the byproducts of their custom commands so that no phony rules are needed for them. In order to work with the non-Ninja generators, the byproducts must be known separately from the outputs. Add a new "BYPRODUCTS" option to the add_custom_command and add_custom_target commands to specify byproducts explicitly. Teach the Ninja generator to specify byproducts as outputs of the custom commands. In the case of POST_BUILD, PRE_LINK, and PRE_BUILD events on targets that link, the byproducts must be specified as outputs of the link rule that runs the commands. Activate 'restat' for such rules so that Ninja knows it needs to check the byproducts, but not for link rules that have no byproducts.
2014-11-14 02:54:52 +03:00
std::vector<std::string>(),
std::vector<std::string>(),
std::vector<std::string>(),
cmd,
"Creating symlinks",
"");
postbuild.push_back(command);
}
std::vector<cmSourceFile*> classes;
if (!cmtarget.GetConfigCommonSourceFiles(classes))
{
return;
}
// 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
2005-02-28 23:07:13 +03:00
cmXCodeObject* cmakeRulesBuildPhase =
this->CreateBuildPhase("CMake Rules",
"cmakeRulesBuildPhase",
cmtarget, commands);
// create prebuild phase
cmXCodeObject* preBuildPhase =
2006-05-11 23:39:46 +04:00
this->CreateBuildPhase("CMake PreBuild Rules", "preBuildCommands",
cmtarget, prebuild);
// create prelink phase
cmXCodeObject* preLinkPhase =
2006-05-11 23:39:46 +04:00
this->CreateBuildPhase("CMake PreLink Rules", "preLinkCommands",
cmtarget, prelink);
// create postbuild phase
cmXCodeObject* postBuildPhase =
2006-05-11 23:39:46 +04:00
this->CreateBuildPhase("CMake PostBuild Rules", "postBuildPhase",
2005-02-28 23:07:13 +03:00
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)
{
2005-01-28 00:11:44 +03:00
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)
{
2005-01-28 00:11:44 +03:00
buildPhases->AddObject(frameworkBuildPhase);
}
if(postBuildPhase)
{
buildPhases->AddObject(postBuildPhase);
}
}
2005-09-03 00:29:32 +04:00
//----------------------------------------------------------------------------
// This function removes each occurrence of the flag and returns the last one
// (i.e., the dominant flag in GCC)
2005-09-03 00:29:32 +04:00
std::string cmGlobalXCodeGenerator::ExtractFlag(const char* flag,
std::string& flags)
{
std::string retFlag;
std::string::size_type lastOccurancePos = flags.rfind(flag);
bool saved = false;
while(lastOccurancePos != flags.npos)
2005-09-03 00:29:32 +04:00
{
//increment pos, we use lastOccurancePos to reduce search space on next inc
std::string::size_type pos = lastOccurancePos;
if(pos == 0 || flags[pos-1]==' ')
2005-09-03 00:29:32 +04:00
{
while(pos < flags.size() && flags[pos] != ' ')
{
if(!saved)
{
retFlag += flags[pos];
}
flags[pos] = ' ';
pos++;
}
saved = true;
}
//decrement lastOccurancePos while making sure we don't loop around
//and become a very large positive number since size_type is unsigned
lastOccurancePos = lastOccurancePos == 0 ? 0 : lastOccurancePos-1;
lastOccurancePos = flags.rfind(flag,lastOccurancePos);
2005-09-03 00:29:32 +04:00
}
return retFlag;
}
2005-02-18 21:32:51 +03:00
//----------------------------------------------------------------------------
void
cmGlobalXCodeGenerator::AddCommandsToBuildPhase(cmXCodeObject* buildphase,
cmTarget& target,
std::vector<cmCustomCommand>
const & commands,
const char* name)
{
2006-03-15 19:02:08 +03:00
std::string dir = this->CurrentMakefile->GetCurrentOutputDirectory();
2005-02-18 22:32:55 +03:00
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());
}
std::string cdir = this->CurrentMakefile->GetCurrentOutputDirectory();
cdir = this->ConvertToRelativeForXCode(cdir.c_str());
std::string makecmd = "make -C ";
makecmd += cdir;
makecmd += " -f ";
2007-05-14 19:23:37 +04:00
makecmd += this->ConvertToRelativeForMake(
(makefile+"$CONFIGURATION").c_str());
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 std::string& configName)
{
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*, std::string> tname;
int count = 0;
for(std::vector<cmCustomCommand>::const_iterator i = commands.begin();
i != commands.end(); ++i)
{
cmCustomCommandGenerator ccg(*i, configName, this->CurrentMakefile);
if(ccg.GetNumberOfCommands() > 0)
{
const std::vector<std::string>& outputs = ccg.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
{
2006-06-16 22:02:03 +04:00
cmOStringStream str;
str << "_buildpart_" << count++ ;
tname[&ccg.GetCC()] = std::string(target.GetName()) + str.str();
makefileStream << "\\\n\t" << tname[&ccg.GetCC()];
}
}
}
makefileStream << "\n\n";
for(std::vector<cmCustomCommand>::const_iterator i = commands.begin();
i != commands.end(); ++i)
{
cmCustomCommandGenerator ccg(*i, configName, this->CurrentMakefile);
if(ccg.GetNumberOfCommands() > 0)
{
2006-09-30 00:14:34 +04:00
makefileStream << "\n";
const std::vector<std::string>& outputs = ccg.GetOutputs();
if(!outputs.empty())
{
// There is at least one output, start the rule for it
const char* sep = "";
for(std::vector<std::string>::const_iterator oi = outputs.begin();
oi != outputs.end(); ++oi)
{
makefileStream << sep <<
this->ConvertToRelativeForMake(oi->c_str());
sep = " ";
}
makefileStream << ": ";
}
else
{
// There are no outputs. Use the generated force rule name.
makefileStream << tname[&ccg.GetCC()] << ": ";
}
for(std::vector<std::string>::const_iterator d =
ccg.GetDepends().begin();
d != ccg.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 = ccg.GetComment())
{
std::string echo_cmd = "echo ";
echo_cmd += (this->CurrentLocalGenerator->
EscapeForShell(comment, ccg.GetCC().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;
std::string wd = ccg.GetWorkingDirectory();
if(!wd.empty())
{
cmd += "cd ";
cmd += this->ConvertToRelativeForMake(wd.c_str());
cmd += " && ";
}
cmd += cmd2;
ccg.AppendArguments(c, cmd);
makefileStream << "\t" << cmd.c_str() << "\n";
}
}
2005-01-28 00:11:44 +03:00
}
}
2005-02-01 21:07:42 +03:00
2005-02-18 21:32:51 +03:00
//----------------------------------------------------------------------------
2005-02-03 01:16:07 +03:00
void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
cmXCodeObject* buildSettings,
const std::string& configName)
2005-02-01 21:07:42 +03:00
{
if(target.GetType() == cmTarget::INTERFACE_LIBRARY)
{
return;
}
2005-02-03 01:16:07 +03:00
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);
std::string lang = target.GetLinkerLanguage(configName);
std::string cflags;
if(!lang.empty())
2005-02-03 01:16:07 +03:00
{
// for c++ projects get the c flags as well
if(lang == "CXX")
{
2006-03-15 19:02:08 +03:00
this->CurrentLocalGenerator->AddLanguageFlags(cflags, "C", configName);
this->CurrentLocalGenerator->AddCMP0018Flags(cflags, &target,
"C", configName);
this->CurrentLocalGenerator->
AddCompileOptions(cflags, &target, "C", configName);
}
2005-02-03 01:16:07 +03:00
// Add language-specific flags.
2006-03-15 19:02:08 +03:00
this->CurrentLocalGenerator->AddLanguageFlags(flags, lang, configName);
2005-02-03 01:16:07 +03:00
// Add shared-library flags if needed.
this->CurrentLocalGenerator->AddCMP0018Flags(flags, &target,
lang, configName);
this->CurrentLocalGenerator->AddVisibilityPresetFlags(flags, &target,
lang);
this->CurrentLocalGenerator->
AddCompileOptions(flags, &target, lang, configName);
2005-02-03 01:16:07 +03:00
}
else if(binary)
{
cmSystemTools::Error
("CMake can not determine linker language for target: ",
2014-02-07 02:31:47 +04:00
target.GetName().c_str());
return;
}
2005-02-11 22:25:05 +03:00
2005-02-15 00:46:32 +03:00
// Add define flags
2006-05-11 23:39:46 +04:00
this->CurrentLocalGenerator->
AppendFlags(defFlags,
this->CurrentMakefile->GetDefineFlags());
// Add preprocessor definitions for this target and configuration.
BuildObjectListOrString ppDefs(this, this->XcodeVersion >= 30);
2006-03-15 19:02:08 +03:00
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);
}
cmGeneratorTarget *gtgt = this->GetGeneratorTarget(&target);
std::vector<std::string> targetDefines;
target.GetCompileDefinitions(targetDefines, configName);
this->AppendDefines(ppDefs, targetDefines);
buildSettings->AddAttribute
("GCC_PREPROCESSOR_DEFINITIONS", ppDefs.CreateList());
std::string extraLinkOptionsVar;
std::string extraLinkOptions;
if(target.GetType() == cmTarget::EXECUTABLE)
{
extraLinkOptionsVar = "CMAKE_EXE_LINKER_FLAGS";
}
else if(target.GetType() == cmTarget::SHARED_LIBRARY)
{
extraLinkOptionsVar = "CMAKE_SHARED_LINKER_FLAGS";
}
else if(target.GetType() == cmTarget::MODULE_LIBRARY)
{
extraLinkOptionsVar = "CMAKE_MODULE_LINKER_FLAGS";
}
if(extraLinkOptionsVar.size())
{
this->CurrentLocalGenerator
->AddConfigVariableFlags(extraLinkOptions,
extraLinkOptionsVar.c_str(),
configName);
}
if(target.GetType() == cmTarget::OBJECT_LIBRARY ||
target.GetType() == cmTarget::STATIC_LIBRARY)
{
this->CurrentLocalGenerator
->GetStaticLibraryFlags(extraLinkOptions,
cmSystemTools::UpperCase(configName),
&target);
}
else
{
const char* targetLinkFlags = target.GetProperty("LINK_FLAGS");
if(targetLinkFlags)
{
this->CurrentLocalGenerator->
AppendFlags(extraLinkOptions, targetLinkFlags);
}
if(!configName.empty())
{
std::string linkFlagsVar = "LINK_FLAGS_";
linkFlagsVar += cmSystemTools::UpperCase(configName);
if(const char* linkFlags = target.GetProperty(linkFlagsVar.c_str()))
{
this->CurrentLocalGenerator->
AppendFlags(extraLinkOptions, linkFlags);
}
}
}
// Set target-specific architectures.
std::vector<std::string> archs;
gtgt->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);
const char* version = target.GetProperty("VERSION");
const char* soversion = target.GetProperty("SOVERSION");
if(!target.HasSOName(configName) || target.IsFrameworkOnApple())
{
version = 0;
soversion = 0;
}
if(version && !soversion)
{
soversion = version;
}
if(!version && soversion)
{
version = soversion;
}
std::string realName = pnbase;
std::string soName = pnbase;
if(version && soversion)
{
realName += ".";
realName += version;
soName += ".";
soName += soversion;
}
// 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);
}
if(target.IsFrameworkOnApple() || target.IsCFBundleOnApple())
{
pnprefix = "";
}
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(realName.c_str()));
buildSettings->AddAttribute("SYMROOT",
this->CreateString(pndir.c_str()));
// Handle settings for each target type.
2005-02-03 01:16:07 +03:00
switch(target.GetType())
{
case cmTarget::OBJECT_LIBRARY:
2005-02-03 01:16:07 +03:00
case cmTarget::STATIC_LIBRARY:
2005-11-18 22:12:09 +03:00
{
buildSettings->AddAttribute("LIBRARY_STYLE",
2005-11-18 22:12:09 +03:00
this->CreateString("STATIC"));
break;
}
2005-02-03 01:16:07 +03:00
case cmTarget::MODULE_LIBRARY:
2005-11-18 22:12:09 +03:00
{
buildSettings->AddAttribute("LIBRARY_STYLE",
2005-11-18 22:12:09 +03:00
this->CreateString("BUNDLE"));
if (target.IsCFBundleOnApple())
{
// 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)
2005-11-18 22:12:09 +03:00
{
buildSettings->AddAttribute("MACH_O_TYPE",
2005-11-18 22:12:09 +03:00
this->CreateString("mh_bundle"));
buildSettings->AddAttribute("GCC_DYNAMIC_NO_PIC",
2005-11-18 22:12:09 +03:00
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;
}
2005-11-18 22:12:09 +03:00
}
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;
}
2005-02-15 00:46:32 +03:00
}
2005-11-18 22:12:09 +03:00
break;
}
2005-02-03 01:16:07 +03:00
case cmTarget::SHARED_LIBRARY:
2005-11-18 22:12:09 +03:00
{
2007-05-08 23:49:54 +04:00
if(target.GetPropertyAsBool("FRAMEWORK"))
{
std::string fw_version = target.GetFrameworkVersion();
buildSettings->AddAttribute("FRAMEWORK_VERSION",
this->CreateString(fw_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()));
2007-05-08 23:49:54 +04:00
}
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",
2005-11-18 22:12:09 +03:00
this->CreateString("DYNAMIC"));
break;
}
2005-02-04 01:42:55 +03:00
case cmTarget::EXECUTABLE:
2005-11-18 22:12:09 +03:00
{
// 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.
2005-11-18 22:12:09 +03:00
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",
2006-01-05 17:13:06 +03:00
this->CreateString(path.c_str()));
2005-07-14 00:23:32 +04:00
}
2005-11-18 22:12:09 +03:00
}
break;
default:
2005-02-03 01:16:07 +03:00
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, gtgt,
"C", configName);
std::set<std::string> emitted;
emitted.insert("/System/Library/Frameworks");
for(std::vector<std::string>::iterator i = includes.begin();
i != includes.end(); ++i)
2005-02-15 00:46:32 +03:00
{
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());
}
}
// Add framework search paths needed for linking.
if(cmComputeLinkInformation* cli = target.GetLinkInformation(configName))
{
std::vector<std::string> const& fwDirs = cli->GetFrameworkPaths();
for(std::vector<std::string>::const_iterator fdi = fwDirs.begin();
fdi != fwDirs.end(); ++fdi)
{
if(emitted.insert(*fdi).second)
{
fdirs.Add(this->XCodeEscapePath(fdi->c_str()).c_str());
}
}
}
if(!fdirs.IsEmpty())
{
buildSettings->AddAttribute("FRAMEWORK_SEARCH_PATHS",
fdirs.CreateList());
2005-02-15 00:46:32 +03:00
}
if(!dirs.IsEmpty())
2005-02-15 00:46:32 +03:00
{
buildSettings->AddAttribute("HEADER_SEARCH_PATHS",
dirs.CreateList());
2005-02-15 00:46:32 +03:00
}
2005-09-03 00:29:32 +04:00
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;
}
2005-09-03 00:29:32 +04:00
std::string gflag = this->ExtractFlag("-g", flags);
if(gflag == "-gdwarf-2")
{
flags += " ";
flags += gflag;
}
2005-09-03 00:29:32 +04:00
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 == "CXX") && gflag != gflagc )
{
cflags += " ";
cflags += gflagc;
flags += " ";
flags += gflag;
debugStr = "NO";
}
if( gflag == "-g0" || gflag.size() == 0 )
2005-09-03 00:29:32 +04:00
{
debugStr = "NO";
}
buildSettings->AddAttribute("COMBINE_HIDPI_IMAGES",
this->CreateString("YES"));
2005-09-03 00:29:32 +04:00
buildSettings->AddAttribute("GCC_GENERATE_DEBUGGING_SYMBOLS",
this->CreateString(debugStr));
buildSettings->AddAttribute("GCC_OPTIMIZATION_LEVEL",
2005-09-03 00:29:32 +04:00
this->CreateString(optLevel));
buildSettings->AddAttribute("GCC_SYMBOLS_PRIVATE_EXTERN",
this->CreateString("NO"));
buildSettings->AddAttribute("GCC_INLINES_ARE_PRIVATE_EXTERN",
this->CreateString("NO"));
if(lang == "CXX")
{
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);
// Xcode doesn't create the correct install_name in some cases.
// That is, if the INSTALL_PATH is empty, or if we have versioning
// of dylib libraries, we want to specify the install_name.
// This is done by adding a link flag to create an install_name
// with just the library soname.
std::string install_name;
if(!install_name_dir.empty())
{
// Convert to a path for the native build tool.
cmSystemTools::ConvertToUnixSlashes(install_name_dir);
install_name += install_name_dir;
install_name += "/";
}
install_name += target.GetSOName(configName);
if((realName != soName) || install_name_dir.empty())
{
install_name_dir = "";
extraLinkOptions += " -install_name ";
extraLinkOptions += XCodeEscapePath(install_name.c_str());
}
}
buildSettings->AddAttribute("INSTALL_PATH",
this->CreateString(install_name_dir.c_str()));
// Create the LD_RUNPATH_SEARCH_PATHS
cmComputeLinkInformation* pcli = target.GetLinkInformation(configName);
if(pcli)
{
std::string search_paths;
std::vector<std::string> runtimeDirs;
pcli->GetRPath(runtimeDirs, false);
// runpath dirs needs to be unique to prevent corruption
std::set<std::string> unique_dirs;
for(std::vector<std::string>::const_iterator i = runtimeDirs.begin();
i != runtimeDirs.end(); ++i)
{
std::string runpath = *i;
runpath = this->ExpandCFGIntDir(runpath, configName);
if(unique_dirs.find(runpath) == unique_dirs.end())
{
unique_dirs.insert(runpath);
if(!search_paths.empty())
{
search_paths += " ";
}
search_paths += this->XCodeEscapePath(runpath.c_str());
}
}
if(!search_paths.empty())
{
buildSettings->AddAttribute("LD_RUNPATH_SEARCH_PATHS",
this->CreateString(search_paths.c_str()));
}
}
buildSettings->AddAttribute(this->GetTargetLinkFlagsVar(target),
this->CreateString(extraLinkOptions.c_str()));
buildSettings->AddAttribute("OTHER_REZFLAGS",
2005-02-01 21:07:42 +03:00
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"));
group->AddObject(this->CreateString("$(inherited)"));
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)
{
std::string attribute = i->first.substr(16);
// Handle [variant=<config>] condition explicitly here.
std::string::size_type beginVariant =
attribute.find("[variant=");
if (beginVariant != std::string::npos)
{
std::string::size_type endVariant =
attribute.find("]", beginVariant+9);
if (endVariant != std::string::npos)
{
// Compare the variant to the configuration.
std::string variant =
attribute.substr(beginVariant+9, endVariant-beginVariant-9);
if (variant == configName)
{
// The variant matches the configuration so use this
// attribute but drop the [variant=<config>] condition.
attribute.erase(beginVariant, endVariant-beginVariant+1);
}
else
{
// The variant does not match the configuration so
// do not use this attribute.
attribute.clear();
}
}
}
if (!attribute.empty())
{
buildSettings->AddAttribute(attribute.c_str(),
this->CreateString(i->second.GetValue()));
}
}
}
}
2005-02-01 21:07:42 +03:00
}
2005-02-18 21:32:51 +03:00
//----------------------------------------------------------------------------
cmXCodeObject*
2005-02-04 01:42:55 +03:00
cmGlobalXCodeGenerator::CreateUtilityTarget(cmTarget& cmtarget)
{
cmXCodeObject* shellBuildPhase =
this->CreateObject(cmXCodeObject::PBXShellScriptBuildPhase);
shellBuildPhase->AddAttribute("buildActionMask",
2005-11-18 22:12:09 +03:00
this->CreateString("2147483647"));
2005-02-04 01:42:55 +03:00
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",
2005-11-18 22:12:09 +03:00
this->CreateString("0"));
2005-02-04 01:42:55 +03:00
shellBuildPhase->AddAttribute("shellPath",
2005-11-18 22:12:09 +03:00
this->CreateString("/bin/sh"));
2005-02-04 01:42:55 +03:00
shellBuildPhase->AddAttribute("shellScript",
2005-11-18 22:12:09 +03:00
this->CreateString(
"# shell script goes here\nexit 0"));
shellBuildPhase->AddAttribute("showEnvVarsInLog",
this->CreateString("0"));
cmXCodeObject* target =
2005-02-04 01:42:55 +03:00
this->CreateObject(cmXCodeObject::PBXAggregateTarget);
2014-02-07 02:31:47 +04:00
target->SetComment(cmtarget.GetName().c_str());
cmXCodeObject* buildPhases =
2005-02-04 01:42:55 +03:00
this->CreateObject(cmXCodeObject::OBJECT_LIST);
std::vector<cmXCodeObject*> emptyContentVector;
this->CreateCustomCommands(buildPhases, 0, 0, 0, emptyContentVector, 0,
cmtarget);
2005-02-04 01:42:55 +03:00
target->AddAttribute("buildPhases", buildPhases);
2006-03-15 19:02:08 +03:00
if(this->XcodeVersion > 20)
2005-09-03 00:29:32 +04:00
{
this->AddConfigurations(target, cmtarget);
}
else
{
std::string theConfig =
this->CurrentMakefile->GetSafeDefinition("CMAKE_BUILD_TYPE");
cmXCodeObject* buildSettings =
this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
this->CreateBuildSettings(cmtarget, buildSettings, theConfig);
target->AddAttribute("buildSettings", buildSettings);
}
cmXCodeObject* dependencies =
2006-05-11 23:39:46 +04:00
this->CreateObject(cmXCodeObject::OBJECT_LIST);
2005-02-04 01:42:55 +03:00
target->AddAttribute("dependencies", dependencies);
target->AddAttribute("name", this->CreateString(cmtarget.GetName()));
target->AddAttribute("productName",this->CreateString(cmtarget.GetName()));
2006-03-15 19:38:47 +03:00
target->SetTarget(&cmtarget);
this->XCodeObjectMap[&cmtarget] = target;
// Add source files without build rules for editing convenience.
if(cmtarget.GetType() == cmTarget::UTILITY)
{
std::vector<cmSourceFile*> sources;
if (!cmtarget.GetConfigCommonSourceFiles(sources))
{
return 0;
}
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());
2005-02-04 01:42:55 +03:00
return target;
}
2005-09-03 00:29:32 +04:00
//----------------------------------------------------------------------------
std::string cmGlobalXCodeGenerator::AddConfigurations(cmXCodeObject* target,
cmTarget& cmtarget)
2005-09-03 00:29:32 +04:00
{
std::string configTypes =
2006-05-11 23:39:46 +04:00
this->CurrentMakefile->GetRequiredDefinition("CMAKE_CONFIGURATION_TYPES");
2005-09-03 00:29:32 +04:00
std::vector<std::string> configVectorIn;
std::vector<std::string> configVector;
configVectorIn.push_back(configTypes);
cmSystemTools::ExpandList(configVectorIn, configVector);
cmXCodeObject* configlist =
2006-05-11 23:39:46 +04:00
this->CreateObject(cmXCodeObject::XCConfigurationList);
2005-09-03 00:29:32 +04:00
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",
2005-09-03 00:29:32 +04:00
this->CreateObjectReference(configlist));
for(unsigned int i = 0; i < configVector.size(); ++i)
{
cmXCodeObject* config =
2006-05-11 23:39:46 +04:00
this->CreateObject(cmXCodeObject::XCBuildConfiguration);
2005-09-03 00:29:32 +04:00
buildConfigurations->AddObject(config);
cmXCodeObject* buildSettings =
this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
this->CreateBuildSettings(cmtarget, buildSettings,
configVector[i].c_str());
2005-09-03 00:29:32 +04:00
config->AddAttribute("name", this->CreateString(configVector[i].c_str()));
config->SetComment(configVector[i].c_str());
2005-09-03 00:29:32 +04:00
config->AddAttribute("buildSettings", buildSettings);
}
if(configVector.size())
{
configlist->AddAttribute("defaultConfigurationName",
this->CreateString(configVector[0].c_str()));
configlist->AddAttribute("defaultConfigurationIsVisible",
2006-05-11 23:39:46 +04:00
this->CreateString("0"));
return configVector[0];
}
return "";
2005-09-03 00:29:32 +04:00
}
//----------------------------------------------------------------------------
const char*
cmGlobalXCodeGenerator::GetTargetLinkFlagsVar(cmTarget const& cmtarget) const
{
if(this->XcodeVersion >= 60 &&
(cmtarget.GetType() == cmTarget::STATIC_LIBRARY ||
cmtarget.GetType() == cmTarget::OBJECT_LIBRARY))
{
return "OTHER_LIBTOOLFLAGS";
}
else
{
return "OTHER_LDFLAGS";
}
}
//----------------------------------------------------------------------------
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;
}
2005-02-18 21:32:51 +03:00
//----------------------------------------------------------------------------
2005-02-03 01:16:07 +03:00
cmXCodeObject*
cmGlobalXCodeGenerator::CreateXCodeTarget(cmTarget& cmtarget,
cmXCodeObject* buildPhases)
2005-02-01 21:07:42 +03:00
{
if(cmtarget.GetType() == cmTarget::INTERFACE_LIBRARY)
{
return 0;
}
cmXCodeObject* target =
2005-02-04 01:42:55 +03:00
this->CreateObject(cmXCodeObject::PBXNativeTarget);
2005-02-01 21:07:42 +03:00
target->AddAttribute("buildPhases", buildPhases);
cmXCodeObject* buildRules = this->CreateObject(cmXCodeObject::OBJECT_LIST);
target->AddAttribute("buildRules", buildRules);
std::string defConfig;
2006-03-15 19:02:08 +03:00
if(this->XcodeVersion > 20)
2005-09-03 00:29:32 +04:00
{
defConfig = this->AddConfigurations(target, cmtarget);
2005-09-03 00:29:32 +04:00
}
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 =
2006-05-11 23:39:46 +04:00
this->CreateObject(cmXCodeObject::OBJECT_LIST);
2005-02-01 21:07:42 +03:00
target->AddAttribute("dependencies", dependencies);
target->AddAttribute("name", this->CreateString(cmtarget.GetName()));
target->AddAttribute("productName",this->CreateString(cmtarget.GetName()));
2005-02-08 01:36:34 +03:00
cmXCodeObject* fileRef =
2006-05-11 23:39:46 +04:00
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()));
2005-02-15 00:46:32 +03:00
fileRef->AddAttribute("refType", this->CreateString("0"));
2005-02-08 01:36:34 +03:00
fileRef->AddAttribute("sourceTree",
this->CreateString("BUILT_PRODUCTS_DIR"));
2014-02-07 02:31:47 +04:00
fileRef->SetComment(cmtarget.GetName().c_str());
target->AddAttribute("productReference",
2005-02-08 01:36:34 +03:00
this->CreateObjectReference(fileRef));
if(const char* productType = this->GetTargetProductType(cmtarget))
{
target->AddAttribute("productType", this->CreateString(productType));
}
2006-03-15 19:38:47 +03:00
target->SetTarget(&cmtarget);
this->XCodeObjectMap[&cmtarget] = target;
target->SetId(this->GetOrCreateId(
cmtarget.GetName(), target->GetId()).c_str());
2005-02-01 21:07:42 +03:00
return target;
}
2005-02-18 21:32:51 +03:00
//----------------------------------------------------------------------------
cmXCodeObject* cmGlobalXCodeGenerator::FindXCodeTarget(cmTarget const* t)
2005-02-04 01:42:55 +03:00
{
if(!t)
{
return 0;
}
std::map<cmTarget const*, cmXCodeObject*>::const_iterator const i =
this->XCodeObjectMap.find(t);
if (i == this->XCodeObjectMap.end())
2005-02-04 01:42:55 +03:00
{
return 0;
2005-02-04 01:42:55 +03:00
}
return i->second;
2005-02-04 01:42:55 +03:00
}
//----------------------------------------------------------------------------
2014-02-07 02:31:47 +04:00
std::string cmGlobalXCodeGenerator::GetOrCreateId(const std::string& name,
const std::string& 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(),
2014-02-07 02:31:47 +04:00
id.c_str(), "Stored Xcode object GUID", cmCacheManager::INTERNAL);
return id;
}
2005-02-18 21:32:51 +03:00
//----------------------------------------------------------------------------
2005-02-04 01:42:55 +03:00
void cmGlobalXCodeGenerator::AddDependTarget(cmXCodeObject* target,
cmXCodeObject* dependTarget)
{
// This is called once for every edge in the target dependency graph.
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()));
cmXCodeObject* targetdep =
this->CreateObject(cmXCodeObject::PBXTargetDependency);
targetdep->SetComment("PBXTargetDependency");
targetdep->AddAttribute("target",
this->CreateObjectReference(dependTarget));
targetdep->AddAttribute("targetProxy",
this->CreateObjectReference(container));
2005-02-04 01:42:55 +03:00
cmXCodeObject* depends = target->GetObject("dependencies");
if(!depends)
{
cmSystemTools::
Error("target does not have dependencies attribute error..");
2005-02-04 01:42:55 +03:00
}
else
{
depends->AddUniqueObject(targetdep);
2005-02-04 01:42:55 +03:00
}
}
//----------------------------------------------------------------------------
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());
}
}
}
2005-09-03 00:29:32 +04:00
//----------------------------------------------------------------------------
2006-05-11 23:39:46 +04:00
void cmGlobalXCodeGenerator
::AppendBuildSettingAttribute(cmXCodeObject* target,
const char* attribute,
const char* value,
const std::string& configName)
2005-09-03 00:29:32 +04:00
{
2006-03-15 19:02:08 +03:00
if(this->XcodeVersion < 21)
2005-09-03 00:29:32 +04:00
{
// 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 =
2006-05-11 23:39:46 +04:00
target->GetObject("buildConfigurationList")->GetObject();
cmXCodeObject* buildConfigs =
2006-05-11 23:39:46 +04:00
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();
2006-05-11 23:39:46 +04:00
i != list.end(); ++i)
{
if(!configName.empty())
{
if((*i)->GetObject("name")->GetString() == configName)
{
cmXCodeObject* settings = (*i)->GetObject("buildSettings");
this->AppendOrAddBuildSetting(settings, attribute, value);
}
}
else
{
cmXCodeObject* settings = (*i)->GetObject("buildSettings");
this->AppendOrAddBuildSetting(settings, attribute, value);
}
}
2005-09-03 00:29:32 +04:00
}
}
2005-02-18 21:32:51 +03:00
//----------------------------------------------------------------------------
2006-05-11 23:39:46 +04:00
void cmGlobalXCodeGenerator
::AddDependAndLinkInformation(cmXCodeObject* target)
2005-02-04 01:42:55 +03:00
{
2006-03-15 19:38:47 +03:00
cmTarget* cmtarget = target->GetTarget();
if(cmtarget->GetType() == cmTarget::INTERFACE_LIBRARY)
{
return;
}
2005-02-04 01:42:55 +03:00
if(!cmtarget)
{
cmSystemTools::Error("Error no target on xobject\n");
2005-02-04 01:42:55 +03:00
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))
2005-02-04 01:42:55 +03:00
{
this->AddDependTarget(target, dptarget);
2005-02-04 01:42:55 +03:00
}
}
// Loop over configuration types and set per-configuration info.
for(std::vector<std::string>::iterator i =
2006-03-15 19:02:08 +03:00
this->CurrentConfigurationTypes.begin();
i != this->CurrentConfigurationTypes.end(); ++i)
{
// Get the current configuration name.
std::string configName = *i;
if(this->XcodeVersion >= 50)
{
// Add object library contents as link flags.
std::string linkObjs;
const char* sep = "";
std::vector<std::string> objs;
this->GetGeneratorTarget(cmtarget)->UseObjectLibraries(objs, "");
for(std::vector<std::string>::const_iterator
oi = objs.begin(); oi != objs.end(); ++oi)
{
linkObjs += sep;
sep = " ";
linkObjs += this->XCodeEscapePath(oi->c_str());
}
this->AppendBuildSettingAttribute(
target, this->GetTargetLinkFlagsVar(*cmtarget),
linkObjs.c_str(), configName);
}
// Skip link information for object libraries.
if(cmtarget->GetType() == cmTarget::OBJECT_LIBRARY ||
cmtarget->GetType() == cmTarget::STATIC_LIBRARY)
{
continue;
}
// 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")
{
2006-03-15 19:02:08 +03:00
if(this->XcodeVersion > 15)
{
2011-07-19 19:33:01 +04:00
// 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);
}
// 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 if (!li->Target
|| li->Target->GetType() != cmTarget::INTERFACE_LIBRARY)
{
linkLibs += li->Value;
2007-05-08 23:49:54 +04:00
}
if(li->Target && !li->Target->IsImported())
{
target->AddDependTarget(configName, li->Target->GetName());
}
}
this->AppendBuildSettingAttribute(
target, this->GetTargetLinkFlagsVar(*cmtarget),
linkLibs.c_str(), configName);
}
2005-02-04 01:42:55 +03:00
}
}
2005-02-03 01:16:07 +03:00
2005-03-17 23:35:44 +03:00
//----------------------------------------------------------------------------
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++)
{
2005-03-17 23:35:44 +03:00
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;
}
if(cmtarget.GetType() == cmTarget::INTERFACE_LIBRARY)
{
continue;
}
2006-05-11 23:39:46 +04:00
// add the soon to be generated Info.plist file as a source for a
// MACOSX_BUNDLE file
2006-01-05 17:13:06 +03:00
if(cmtarget.GetPropertyAsBool("MACOSX_BUNDLE"))
{
std::string plist = this->ComputeInfoPListLocation(cmtarget);
mf->GetOrCreateSource(plist, true);
cmtarget.AddSource(plist);
2006-01-05 17:13:06 +03:00
}
std::vector<cmSourceFile*> classes;
if (!cmtarget.GetConfigCommonSourceFiles(classes))
{
return;
}
// Put cmSourceFile instances in proper groups:
for(std::vector<cmSourceFile*>::const_iterator s = classes.begin();
2005-03-17 23:35:44 +03:00
s != classes.end(); s++)
{
cmSourceFile* sf = *s;
// Add the file to the list of sources.
std::string const& source = sf->GetFullPath();
cmSourceGroup* sourceGroup =
2005-03-17 23:35:44 +03:00
mf->FindSourceGroup(source.c_str(), sourceGroups);
cmXCodeObject* pbxgroup =
this->CreateOrGetPBXGroup(cmtarget, sourceGroup);
std::string key = GetGroupMapKey(cmtarget, sf);
this->GroupMap[key] = pbxgroup;
2005-03-17 23:35:44 +03:00
}
// 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);
std::string key = GetGroupMapKeyFromPath(cmtarget, source);
this->GroupMap[key] = pbxgroup;
}
2005-03-17 23:35:44 +03:00
}
}
2005-03-17 23:35:44 +03:00
}
cmXCodeObject *cmGlobalXCodeGenerator
::CreatePBXGroup(cmXCodeObject *parent, std::string 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;
}
2005-03-17 23:35:44 +03:00
//----------------------------------------------------------------------------
2006-05-11 23:39:46 +04:00
cmXCodeObject* cmGlobalXCodeGenerator
::CreateOrGetPBXGroup(cmTarget& cmtarget, cmSourceGroup* sg)
2005-03-17 23:35:44 +03:00
{
std::string s;
std::string target;
const char *targetFolder= cmtarget.GetProperty("FOLDER");
if(targetFolder) {
target = targetFolder;
target += "/";
}
target += cmtarget.GetName();
s = target + "/";
s += sg->GetFullName();
std::map<std::string, cmXCodeObject* >::iterator it =
2006-05-11 23:39:46 +04:00
this->GroupNameMap.find(s);
if(it != this->GroupNameMap.end())
2005-03-17 23:35:44 +03:00
{
return it->second;
2005-03-17 23:35:44 +03:00
}
it = this->TargetGroup.find(target);
2005-03-17 23:35:44 +03:00
cmXCodeObject* tgroup = 0;
if(it != this->TargetGroup.end())
2005-03-17 23:35:44 +03:00
{
tgroup = it->second;
2005-03-17 23:35:44 +03:00
}
else
{
std::vector<std::string> tgt_folders =
cmSystemTools::tokenize(target, "/");
std::string curr_tgt_folder;
for(std::vector<std::string>::size_type i = 0; i < tgt_folders.size();i++)
{
if (i != 0)
{
curr_tgt_folder += "/";
}
curr_tgt_folder += tgt_folders[i];
it = this->TargetGroup.find(curr_tgt_folder);
if(it != this->TargetGroup.end())
{
tgroup = it->second;
continue;
}
tgroup = this->CreatePBXGroup(tgroup,tgt_folders[i]);
this->TargetGroup[curr_tgt_folder] = tgroup;
if(i == 0)
{
this->SourcesGroupChildren->AddObject(tgroup);
}
}
2005-03-17 23:35:44 +03:00
}
this->TargetGroup[target] = tgroup;
// If it's the default source group (empty name) then put the source file
// directly in the tgroup...
//
if (std::string(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(), "\\");
std::string curr_folder = target;
curr_folder += "/";
for(std::vector<std::string>::size_type i = 0; i < folders.size();i++)
{
curr_folder += folders[i];
std::map<std::string, 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());
2006-03-15 19:02:08 +03:00
this->GroupNameMap[s] = group;
2005-03-17 23:35:44 +03:00
return group;
}
2005-02-03 01:16:07 +03:00
2005-01-28 00:11:44 +03:00
//----------------------------------------------------------------------------
2006-05-11 23:39:46 +04:00
void cmGlobalXCodeGenerator
::CreateXCodeObjects(cmLocalGenerator* root,
std::vector<cmLocalGenerator*>&
generators)
2005-01-25 01:35:54 +03:00
{
this->ClearXCodeObjects();
2006-03-15 19:02:08 +03:00
this->RootObject = 0;
this->SourcesGroupChildren = 0;
this->ResourcesGroupChildren = 0;
2006-03-15 19:02:08 +03:00
this->MainGroupChildren = 0;
2005-01-28 00:11:44 +03:00
cmXCodeObject* group = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
group->AddAttribute("COPY_PHASE_STRIP", this->CreateString("NO"));
cmXCodeObject* developBuildStyle =
2005-02-11 22:25:05 +03:00
this->CreateObject(cmXCodeObject::PBXBuildStyle);
2006-04-10 19:39:32 +04:00
cmXCodeObject* listObjs = this->CreateObject(cmXCodeObject::OBJECT_LIST);
2006-03-15 19:02:08 +03:00
if(this->XcodeVersion == 15)
2005-09-03 00:29:32 +04:00
{
developBuildStyle->AddAttribute("name",
2006-05-11 23:39:46 +04:00
this->CreateString("Development"));
2006-04-10 19:39:32 +04:00
developBuildStyle->AddAttribute("buildSettings", group);
listObjs->AddObject(developBuildStyle);
group = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
group->AddAttribute("COPY_PHASE_STRIP", this->CreateString("YES"));
cmXCodeObject* deployBuildStyle =
2005-02-11 22:25:05 +03:00
this->CreateObject(cmXCodeObject::PBXBuildStyle);
2005-09-03 00:29:32 +04:00
deployBuildStyle->AddAttribute("name", this->CreateString("Deployment"));
2006-04-10 19:39:32 +04:00
deployBuildStyle->AddAttribute("buildSettings", group);
listObjs->AddObject(deployBuildStyle);
2005-09-03 00:29:32 +04:00
}
else
{
2006-04-10 19:39:32 +04:00
for(unsigned int i = 0; i < this->CurrentConfigurationTypes.size(); ++i)
{
cmXCodeObject* buildStyle =
2006-04-10 19:39:32 +04:00
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);
}
2005-09-03 00:29:32 +04:00
}
2005-01-29 00:00:10 +03:00
cmXCodeObject* mainGroup = this->CreateObject(cmXCodeObject::PBXGroup);
this->MainGroupChildren =
2005-02-05 01:58:58 +03:00
this->CreateObject(cmXCodeObject::OBJECT_LIST);
2006-03-15 19:02:08 +03:00
mainGroup->AddAttribute("children", this->MainGroupChildren);
if(this->XcodeVersion == 15)
{
mainGroup->AddAttribute("refType", this->CreateString("4"));
}
2005-02-03 01:16:07 +03:00
mainGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
2005-01-29 00:00:10 +03:00
2005-02-15 00:46:32 +03:00
cmXCodeObject* sourcesGroup = this->CreateObject(cmXCodeObject::PBXGroup);
this->SourcesGroupChildren =
2005-02-15 00:46:32 +03:00
this->CreateObject(cmXCodeObject::OBJECT_LIST);
sourcesGroup->AddAttribute("name", this->CreateString("Sources"));
2006-03-15 19:02:08 +03:00
sourcesGroup->AddAttribute("children", this->SourcesGroupChildren);
if(this->XcodeVersion == 15)
{
sourcesGroup->AddAttribute("refType", this->CreateString("4"));
}
2005-02-15 00:46:32 +03:00
sourcesGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
2006-03-15 19:02:08 +03:00
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
2005-03-17 23:35:44 +03:00
this->CreateGroups(root, generators);
2005-02-05 01:58:58 +03:00
cmXCodeObject* productGroup = this->CreateObject(cmXCodeObject::PBXGroup);
productGroup->AddAttribute("name", this->CreateString("Products"));
2006-03-15 19:02:08 +03:00
if(this->XcodeVersion == 15)
{
productGroup->AddAttribute("refType", this->CreateString("4"));
}
2005-02-05 01:58:58 +03:00
productGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
cmXCodeObject* productGroupChildren =
2005-02-05 01:58:58 +03:00
this->CreateObject(cmXCodeObject::OBJECT_LIST);
productGroup->AddAttribute("children", productGroupChildren);
2006-03-15 19:02:08 +03:00
this->MainGroupChildren->AddObject(productGroup);
2006-03-15 19:02:08 +03:00
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());
2005-01-28 00:11:44 +03:00
group = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
this->RootObject->AddAttribute("mainGroup",
2005-02-05 01:58:58 +03:00
this->CreateObjectReference(mainGroup));
2006-03-15 19:02:08 +03:00
this->RootObject->AddAttribute("buildSettings", group);
this->RootObject->AddAttribute("buildStyles", listObjs);
this->RootObject->AddAttribute("hasScannedForEncodings",
2005-02-05 01:58:58 +03:00
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 =
2006-04-10 19:39:32 +04:00
this->CreateObject(cmXCodeObject::XCConfigurationList);
2005-09-03 00:29:32 +04:00
cmXCodeObject* buildConfigurations =
this->CreateObject(cmXCodeObject::OBJECT_LIST);
2006-04-10 19:39:32 +04:00
std::vector<cmXCodeObject*> configs;
const char *defaultConfigName = "Debug";
2006-04-10 19:39:32 +04:00
if(this->XcodeVersion == 15)
{
cmXCodeObject* configDebug =
2006-04-10 19:39:32 +04:00
this->CreateObject(cmXCodeObject::XCBuildConfiguration);
configDebug->AddAttribute("name", this->CreateString("Debug"));
configs.push_back(configDebug);
cmXCodeObject* configRelease =
2006-04-10 19:39:32 +04:00
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 =
2006-04-10 19:39:32 +04:00
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);
}
2005-09-03 00:29:32 +04:00
configlist->AddAttribute("buildConfigurations", buildConfigurations);
2006-04-10 19:39:32 +04:00
std::string comment = "Build configuration list for PBXProject ";
comment += " \"";
2006-03-15 19:02:08 +03:00
comment += this->CurrentProject;
comment += "\"";
configlist->SetComment(comment.c_str());
configlist->AddAttribute("defaultConfigurationIsVisible",
2006-05-11 23:39:46 +04:00
this->CreateString("0"));
configlist->AddAttribute("defaultConfigurationName",
this->CreateString(defaultConfigName));
2005-09-03 00:29:32 +04:00
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)";
}
2009-10-07 16:15:14 +04:00
else if(this->XcodeVersion == 31)
{
osxArch = "$(ARCHS_STANDARD_32_BIT)";
}
else if(this->XcodeVersion <= 30)
{
#ifdef __ppc__
osxArch = "ppc";
#endif
2009-10-07 16:15:14 +04:00
#ifdef __i386
osxArch = "i386";
#endif
}
buildSettings->AddAttribute("ONLY_ACTIVE_ARCH",
this->CreateString("YES"));
}
const char* sysroot =
this->CurrentMakefile->GetDefinition("CMAKE_OSX_SYSROOT");
const char* deploymentTarget =
this->CurrentMakefile->GetDefinition("CMAKE_OSX_DEPLOYMENT_TARGET");
if(osxArch && sysroot)
{
2007-02-17 19:43:47 +03:00
// recompute this as it may have been changed since enable language
this->Architectures.clear();
cmSystemTools::ExpandListArgument(std::string(osxArch),
this->Architectures);
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(deploymentTarget && *deploymentTarget)
{
buildSettings->AddAttribute("MACOSX_DEPLOYMENT_TARGET",
this->CreateString(deploymentTarget));
}
if(!this->GeneratorToolset.empty())
{
buildSettings->AddAttribute("GCC_VERSION",
this->CreateString(this->GeneratorToolset.c_str()));
}
// 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()));
2006-04-10 19:39:32 +04:00
for( std::vector<cmXCodeObject*>::iterator i = configs.begin();
i != configs.end(); ++i)
{
(*i)->AddAttribute("buildSettings", buildSettings);
}
this->RootObject->AddAttribute("buildConfigurationList",
2005-11-18 22:12:09 +03:00
this->CreateObjectReference(configlist));
2005-09-03 00:29:32 +04:00
2005-01-28 00:11:44 +03:00
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);
}
2005-01-28 00:11:44 +03:00
}
// loop over all targets and add link and depend info
2005-01-28 00:11:44 +03:00
for(std::vector<cmXCodeObject*>::iterator i = targets.begin();
i != targets.end(); ++i)
{
2005-02-04 01:42:55 +03:00
cmXCodeObject* t = *i;
this->AddDependAndLinkInformation(t);
}
if(this->XcodeVersion < 50)
{
// 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;
2005-02-04 01:42:55 +03:00
allTargets->AddObject(t);
2005-02-05 01:58:58 +03:00
cmXCodeObject* productRef = t->GetObject("productReference");
if(productRef)
{
2005-02-08 01:36:34 +03:00
productGroupChildren->AddObject(productRef->GetObject());
2005-02-05 01:58:58 +03:00
}
2005-01-28 00:11:44 +03:00
}
2006-03-15 19:02:08 +03:00
this->RootObject->AddAttribute("targets", allTargets);
2005-01-25 01:35:54 +03:00
}
//----------------------------------------------------------------------------
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
2006-05-11 23:39:46 +04:00
makefileStream(this->CurrentXCodeHackMakefile.c_str());
if(!makefileStream)
{
cmSystemTools::Error("Could not create",
2006-03-15 19:02:08 +03:00
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<std::string> emitted;
for(std::vector<cmXCodeObject*>::iterator i = targets.begin();
i != targets.end(); ++i)
{
cmXCodeObject* target = *i;
std::map<std::string, cmXCodeObject::StringVec> const& deplibs =
target->GetDependLibraries();
for(std::map<std::string, cmXCodeObject::StringVec>::const_iterator ci
2006-05-11 23:39:46 +04:00
= 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
2006-03-15 19:02:08 +03:00
ct = this->CurrentConfigurationTypes.begin();
ct != this->CurrentConfigurationTypes.end(); ++ct)
{
std::string configName = *ct;
for(std::vector<cmXCodeObject*>::iterator i = targets.begin();
i != targets.end(); ++i)
{
cmXCodeObject* target = *i;
2006-03-15 19:38:47 +03:00
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<std::string, cmXCodeObject::StringVec>::const_iterator
y = target->GetDependTargets().find(*ct);
if(y != target->GetDependTargets().end())
{
std::vector<std::string> const& deptgts = y->second;
for(std::vector<std::string>::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<std::string, cmXCodeObject::StringVec>::const_iterator
x = target->GetDependLibraries().find(*ct);
if(x != target->GetDependLibraries().end())
{
std::vector<std::string> const& deplibs = x->second;
for(std::vector<std::string>::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();
2006-05-16 21:23:22 +04:00
arch != this->Architectures.end(); ++arch)
{
std::string universalFile = universal;
2006-05-16 21:23:22 +04:00
universalFile += *arch;
universalFile += "/";
2009-02-19 18:31:16 +03:00
universalFile += t->GetFullName(configName);
makefileStream << "\t/bin/rm -f "
<<
this->ConvertToRelativeForMake(universalFile.c_str())
<< "\n";
}
}
makefileStream << "\n\n";
}
}
}
}
//----------------------------------------------------------------------------
2005-02-11 22:25:05 +03:00
void
cmGlobalXCodeGenerator::OutputXCodeProject(cmLocalGenerator* root,
std::vector<cmLocalGenerator*>&
2005-02-11 22:25:05 +03:00
generators)
2005-01-25 01:35:54 +03:00
{
if(generators.size() == 0)
{
return;
}
// Skip local generators that are excluded from this project.
2006-01-14 18:27:04 +03:00
for(std::vector<cmLocalGenerator*>::iterator g = generators.begin();
g != generators.end(); ++g)
{
2006-01-14 18:27:04 +03:00
if(this->IsExcluded(root, *g))
{
continue;
}
}
2005-01-25 01:35:54 +03:00
this->CreateXCodeObjects(root,
generators);
std::string xcodeDir = root->GetMakefile()->GetStartOutputDirectory();
xcodeDir += "/";
xcodeDir += root->GetMakefile()->GetProjectName();
xcodeDir += ".xcode";
2006-03-15 19:02:08 +03:00
if(this->XcodeVersion > 20)
2005-09-03 00:29:32 +04:00
{
xcodeDir += "proj";
}
2005-01-25 01:35:54 +03:00
cmSystemTools::MakeDirectory(xcodeDir.c_str());
std::string xcodeProjFile = xcodeDir + "/project.pbxproj";
cmGeneratedFileStream fout(xcodeProjFile.c_str());
2005-01-25 01:35:54 +03:00
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());
2005-01-25 01:35:54 +03:00
}
//----------------------------------------------------------------------------
void
2005-02-11 22:25:05 +03:00
cmGlobalXCodeGenerator::WriteXCodePBXProj(std::ostream& fout,
cmLocalGenerator* ,
std::vector<cmLocalGenerator*>& )
2005-01-25 01:35:54 +03:00
{
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);
}
2005-01-25 01:35:54 +03:00
cmXCodeObject::Indent(1, fout);
2006-03-15 19:02:08 +03:00
fout << "rootObject = " << this->RootObject->GetId() << ";\n";
2005-01-25 01:35:54 +03:00
fout << "}\n";
}
//----------------------------------------------------------------------------
const char* cmGlobalXCodeGenerator::GetCMakeCFGIntDir() const
{
return this->XcodeVersion >= 21 ?
"$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)" : ".";
}
std::string cmGlobalXCodeGenerator::ExpandCFGIntDir(const std::string& str,
const std::string& config) const
{
std::string replace1 = "$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)";
std::string replace2 = "$(CONFIGURATION)";
std::string tmp = str;
for(std::string::size_type i = tmp.find(replace1);
i != std::string::npos;
i = tmp.find(replace1, i))
{
tmp.replace(i, replace1.size(), config);
i += config.size();
}
for(std::string::size_type i = tmp.find(replace2);
i != std::string::npos;
i = tmp.find(replace2, i))
{
tmp.replace(i, replace2.size(), config);
i += config.size();
}
return tmp;
}
2005-01-25 01:35:54 +03:00
//----------------------------------------------------------------------------
2005-02-11 22:25:05 +03:00
void cmGlobalXCodeGenerator::GetDocumentation(cmDocumentationEntry& entry)
2005-01-25 01:35:54 +03:00
{
entry.Name = cmGlobalXCodeGenerator::GetActualName();
entry.Brief = "Generate Xcode project files.";
2005-01-25 01:35:54 +03:00
}
2005-02-18 21:32:51 +03:00
//----------------------------------------------------------------------------
2005-02-25 01:46:49 +03:00
std::string cmGlobalXCodeGenerator::ConvertToRelativeForMake(const char* p)
2005-02-18 21:32:51 +03:00
{
2006-03-15 19:02:08 +03:00
if ( !this->CurrentMakefile->IsOn("CMAKE_USE_RELATIVE_PATHS") )
2005-02-18 21:32:51 +03:00
{
return cmSystemTools::ConvertToOutputPath(p);
}
2005-02-25 01:46:49 +03:00
else
2005-02-18 21:32:51 +03:00
{
std::string ret =
this->CurrentLocalGenerator->
ConvertToRelativePath(this->CurrentOutputDirectoryComponents, p);
2005-02-25 01:46:49 +03:00
return cmSystemTools::ConvertToOutputPath(ret.c_str());
2005-02-18 21:32:51 +03:00
}
2005-02-25 01:46:49 +03:00
}
//----------------------------------------------------------------------------
std::string cmGlobalXCodeGenerator::ConvertToRelativeForXCode(const char* p)
{
2006-03-15 19:02:08 +03:00
if ( !this->CurrentMakefile->IsOn("CMAKE_USE_RELATIVE_PATHS") )
2005-02-18 21:32:51 +03:00
{
2005-02-25 01:46:49 +03:00
return cmSystemTools::ConvertToOutputPath(p);
2005-02-18 21:32:51 +03:00
}
2005-02-25 01:46:49 +03:00
else
2005-02-18 21:32:51 +03:00
{
std::string ret =
this->CurrentLocalGenerator->
ConvertToRelativePath(this->ProjectOutputDirectoryComponents, p);
2005-02-25 01:46:49 +03:00
return cmSystemTools::ConvertToOutputPath(ret.c_str());
2005-02-18 21:32:51 +03:00
}
}
2005-02-24 23:34:14 +03:00
//----------------------------------------------------------------------------
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);
}
//----------------------------------------------------------------------------
2005-02-24 23:34:14 +03:00
std::string cmGlobalXCodeGenerator::XCodeEscapePath(const char* p)
{
std::string ret = p;
if(ret.find(' ') != ret.npos)
{
std::string t = ret;
ret = "\"";
2005-02-24 23:34:14 +03:00
ret += t;
ret += "\"";
2005-02-24 23:34:14 +03:00
}
return ret;
}
//----------------------------------------------------------------------------
void
cmGlobalXCodeGenerator
::AppendDirectoryForConfig(const std::string& prefix,
const std::string& config,
const std::string& suffix,
std::string& dir)
{
2006-03-15 19:02:08 +03:00
if(this->XcodeVersion > 20)
{
if(!config.empty())
{
dir += prefix;
dir += config;
dir += suffix;
}
}
}
//----------------------------------------------------------------------------
std::string cmGlobalXCodeGenerator::LookupFlags(
const std::string& varNamePrefix,
const std::string& varNameLang,
const std::string& varNameSuffix,
const std::string& default_flags)
{
if(!varNameLang.empty())
{
std::string varName = varNamePrefix;
varName += varNameLang;
varName += varNameSuffix;
if(const char* varValue =
2006-03-15 19:38:47 +03:00
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
::ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const
{
std::string configName = this->GetCMakeCFGIntDir();
std::string dir = this->GetObjectsNormalDirectory(
"$(PROJECT_NAME)", configName, gt->Target);
if(this->XcodeVersion >= 21)
{
dir += "$(CURRENT_ARCH)/";
}
else
{
#ifdef __ppc__
dir += "ppc/";
#endif
#ifdef __i386
dir += "i386/";
#endif
}
gt->ObjectDirectory = dir;
}