CMake/Source/cmGlobalXCodeGenerator.cxx

834 lines
30 KiB
C++
Raw Normal View History

2005-01-25 01:35:54 +03:00
/*=========================================================================
Program: CMake - Cross-Platform Makefile Generator
Module: $RCSfile$
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#include "cmGlobalXCodeGenerator.h"
#include "cmLocalXCodeGenerator.h"
#include "cmMakefile.h"
#include "cmXCodeObject.h"
#include "cmake.h"
#include "cmGeneratedFileStream.h"
2005-01-28 00:11:44 +03:00
#include "cmSourceFile.h"
2005-01-25 01:35:54 +03:00
2005-02-04 01:42:55 +03:00
//TODO
2005-02-11 22:25:05 +03:00
// EXECUTABLE_OUTPUT_PATH/LIBRARY_OUTPUT_PATH
// LinkDirectories
// correct placment of include paths
// custom commands
// custom targets
// ALL_BUILD
// RUN_TESTS
// per file flags howto
2005-02-09 01:12:38 +03:00
// 115281011528101152810000 = {
// fileEncoding = 4;
// isa = PBXFileReference;
// lastKnownFileType = sourcecode.cpp.cpp;
// path = /Users/kitware/Bill/CMake/Source/cmakemain.cxx;
// refType = 0;
// sourceTree = "<absolute>";
// };
// 115285011528501152850000 = {
// fileRef = 115281011528101152810000;
// isa = PBXBuildFile;
// settings = {
// COMPILER_FLAGS = "-Dcmakemakeindefflag";
// };
// };
2005-02-05 01:58:58 +03:00
// custom commands and clean up custom targets
2005-02-09 01:12:38 +03:00
// do I need an ALL_BUILD yes
2005-02-04 01:42:55 +03:00
// exe/lib output paths
2005-01-25 01:35:54 +03:00
//----------------------------------------------------------------------------
cmGlobalXCodeGenerator::cmGlobalXCodeGenerator()
{
m_FindMakeProgramFile = "CMakeFindXCode.cmake";
m_RootObject = 0;
2005-02-09 01:12:38 +03:00
m_MainGroupChildren = 0;
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,
2005-02-01 21:07:42 +03:00
cmMakefile * mf)
{
mf->AddDefinition("CMAKE_GENERATOR_CC", "gcc");
mf->AddDefinition("CMAKE_GENERATOR_CXX", "g++");
2005-02-01 23:48:33 +03:00
mf->AddDefinition("CMAKE_GENERATOR_NO_COMPILER_ENV", "1");
2005-02-01 21:07:42 +03:00
this->cmGlobalGenerator::EnableLanguage(lang, mf);
2005-01-25 01:35:54 +03:00
}
//----------------------------------------------------------------------------
int cmGlobalXCodeGenerator::TryCompile(const char *,
2005-02-01 21:07:42 +03:00
const char * bindir,
const char * projectName,
const char * targetName,
std::string * output,
2005-02-01 22:28:46 +03:00
cmMakefile*)
2005-01-25 01:35:54 +03:00
{
2005-02-01 21:07:42 +03:00
// now build the test
std::string makeCommand =
m_CMakeInstance->GetCacheManager()->GetCacheValue("CMAKE_MAKE_PROGRAM");
if(makeCommand.size() == 0)
{
cmSystemTools::Error(
"Generator cannot find the appropriate make command.");
return 1;
}
makeCommand = cmSystemTools::ConvertToOutputPath(makeCommand.c_str());
std::string lowerCaseCommand = makeCommand;
cmSystemTools::LowerCase(lowerCaseCommand);
/**
* Run an executable command and put the stdout in output.
*/
std::string cwd = cmSystemTools::GetCurrentWorkingDirectory();
cmSystemTools::ChangeDirectory(bindir);
// Usage: xcodebuild [-project <projectname>] [-activetarget]
// [-alltargets] [-target <targetname>]... [-activebuildstyle]
// [-buildstyle <buildstylename>] [-optionalbuildstyle <buildstylename>]
// [<buildsetting>=<value>]... [<buildaction>]...
// xcodebuild [-list]
makeCommand += " -project ";
makeCommand += projectName;
2005-02-01 23:48:33 +03:00
makeCommand += ".xcode";
2005-02-01 21:07:42 +03:00
makeCommand += " build ";
if (targetName)
{
makeCommand += "-target ";
makeCommand += targetName;
}
2005-02-01 23:48:33 +03:00
makeCommand += " -buildstyle Development ";
2005-02-02 01:17:12 +03:00
makeCommand += " SYMROOT=";
makeCommand += cmSystemTools::ConvertToOutputPath(bindir);
2005-02-01 21:07:42 +03:00
int retVal;
int timeout = cmGlobalGenerator::s_TryCompileTimeout;
if (!cmSystemTools::RunSingleCommand(makeCommand.c_str(), output, &retVal,
0, false, timeout))
{
cmSystemTools::Error("Generator: execution of xcodebuild failed.");
// return to the original directory
cmSystemTools::ChangeDirectory(cwd.c_str());
return 1;
}
cmSystemTools::ChangeDirectory(cwd.c_str());
return retVal;
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()
{
this->cmGlobalGenerator::Generate();
std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it;
for(it = m_ProjectMap.begin(); it!= m_ProjectMap.end(); ++it)
{
this->OutputXCodeProject(it->second[0], it->second);
}
}
//----------------------------------------------------------------------------
void cmGlobalXCodeGenerator::ClearXCodeObjects()
{
for(unsigned int i = 0; i < m_XCodeObjects.size(); ++i)
{
delete m_XCodeObjects[i];
}
m_XCodeObjects.clear();
}
//----------------------------------------------------------------------------
cmXCodeObject*
cmGlobalXCodeGenerator::CreateObject(cmXCodeObject::PBXType ptype)
2005-01-25 01:35:54 +03:00
{
2005-01-28 00:11:44 +03:00
cmXCodeObject* obj = new cmXCodeObject(ptype, cmXCodeObject::OBJECT);
2005-01-25 01:35:54 +03:00
m_XCodeObjects.push_back(obj);
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);
m_XCodeObjects.push_back(obj);
2005-01-28 00:11:44 +03:00
return obj;
}
cmXCodeObject*
cmGlobalXCodeGenerator::CreateString(const char* s)
2005-01-28 00:11:44 +03:00
{
cmXCodeObject* obj = this->CreateObject(cmXCodeObject::STRING);
obj->SetString(s);
return obj;
}
2005-01-29 00:00:10 +03:00
cmXCodeObject* cmGlobalXCodeGenerator::CreateObjectReference(cmXCodeObject* ref)
{
cmXCodeObject* obj = this->CreateObject(cmXCodeObject::OBJECT_REF);
obj->SetObject(ref);
return obj;
}
2005-01-28 00:11:44 +03:00
cmXCodeObject*
cmGlobalXCodeGenerator::CreateXCodeSourceFile(cmLocalGenerator* lg,
2005-02-09 01:12:38 +03:00
cmSourceFile* sf)
2005-01-28 00:11:44 +03:00
{
2005-02-11 22:25:05 +03:00
std::string flags;
// Add flags from source file properties.
m_CurrentLocalGenerator
->AppendFlags(flags, sf->GetProperty("COMPILE_FLAGS"));
2005-01-28 00:11:44 +03:00
cmXCodeObject* fileRef = this->CreateObject(cmXCodeObject::PBXFileReference);
2005-02-09 01:12:38 +03:00
m_MainGroupChildren->AddObject(fileRef);
2005-01-28 00:11:44 +03:00
cmXCodeObject* buildFile = this->CreateObject(cmXCodeObject::PBXBuildFile);
2005-01-29 00:00:10 +03:00
buildFile->AddAttribute("fileRef", this->CreateObjectReference(fileRef));
2005-01-28 00:11:44 +03:00
cmXCodeObject* settings = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
2005-02-11 22:25:05 +03:00
settings->AddAttribute("COMPILER_FLAGS", this->CreateString(flags.c_str()));
2005-01-28 00:11:44 +03:00
buildFile->AddAttribute("settings", settings);
fileRef->AddAttribute("fileEncoding", this->CreateString("4"));
2005-02-02 01:17:12 +03:00
const char* lang =
2005-02-01 23:48:33 +03:00
this->GetLanguageFromExtension(sf->GetSourceExtension().c_str());
std::string sourcecode = "sourcecode";
2005-02-02 01:17:12 +03:00
if(!lang)
2005-02-01 23:48:33 +03:00
{
2005-02-02 01:17:12 +03:00
std::string ext = ".";
ext = sf->GetSourceExtension();
sourcecode += ext;
sourcecode += ext;
}
else if(strcmp(lang, "C") == 0)
{
sourcecode += ".c.c";
2005-02-01 23:48:33 +03:00
}
// default to c++
else
{
2005-02-11 22:25:05 +03:00
sourcecode += ".cpp.cpp";
2005-02-01 23:48:33 +03:00
}
fileRef->AddAttribute("lastKnownFileType",
2005-02-01 23:48:33 +03:00
this->CreateString(sourcecode.c_str()));
2005-01-28 00:11:44 +03:00
fileRef->AddAttribute("path", this->CreateString(
lg->ConvertToRelativeOutputPath(sf->GetFullPath().c_str()).c_str()));
fileRef->AddAttribute("refType", this->CreateString("4"));
2005-02-03 01:16:07 +03:00
fileRef->AddAttribute("sourceTree", this->CreateString("<absolute>"));
2005-01-28 00:11:44 +03:00
return buildFile;
}
2005-01-25 01:35:54 +03:00
//----------------------------------------------------------------------------
2005-02-04 01:42:55 +03:00
void
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-03 01:16:07 +03:00
m_CurrentLocalGenerator = gen;
2005-02-02 01:17:12 +03:00
m_CurrentMakefile = gen->GetMakefile();
2005-01-28 00:11:44 +03:00
cmTargets &tgts = gen->GetMakefile()->GetTargets();
for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); l++)
{
2005-02-04 01:42:55 +03:00
cmTarget& cmtarget = l->second;
if(cmtarget.GetType() == cmTarget::UTILITY ||
cmtarget.GetType() == cmTarget::INSTALL_FILES ||
cmtarget.GetType() == cmTarget::INSTALL_PROGRAMS)
{
targets.push_back(this->CreateUtilityTarget(cmtarget));
continue;
}
2005-01-28 00:11:44 +03:00
// create source build phase
cmXCodeObject* sourceBuildPhase =
this->CreateObject(cmXCodeObject::PBXSourcesBuildPhase);
sourceBuildPhase->AddAttribute("buildActionMask",
this->CreateString("2147483647"));
2005-01-28 00:11:44 +03:00
cmXCodeObject* buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
sourceBuildPhase->AddAttribute("files", buildFiles);
sourceBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
this->CreateString("0"));
2005-01-28 00:11:44 +03:00
std::vector<cmSourceFile*> &classes = l->second.GetSourceFiles();
// add all the sources
for(std::vector<cmSourceFile*>::iterator i = classes.begin();
i != classes.end(); ++i)
{
2005-02-09 01:12:38 +03:00
buildFiles->AddObject(this->CreateXCodeSourceFile(gen, *i));
2005-01-28 00:11:44 +03:00
}
// create header build phase
cmXCodeObject* headerBuildPhase =
this->CreateObject(cmXCodeObject::PBXHeadersBuildPhase);
headerBuildPhase->AddAttribute("buildActionMask",
this->CreateString("2147483647"));
2005-01-28 00:11:44 +03:00
buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
headerBuildPhase->AddAttribute("files", buildFiles);
headerBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
this->CreateString("0"));
2005-01-28 00:11:44 +03:00
// create framework build phase
cmXCodeObject* frameworkBuildPhase =
this->CreateObject(cmXCodeObject::PBXFrameworksBuildPhase);
frameworkBuildPhase->AddAttribute("buildActionMask",
this->CreateString("2147483647"));
2005-01-28 00:11:44 +03:00
buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
frameworkBuildPhase->AddAttribute("files", buildFiles);
frameworkBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
this->CreateString("0"));
2005-01-28 00:11:44 +03:00
2005-02-04 01:42:55 +03:00
cmXCodeObject* buildPhases =
this->CreateObject(cmXCodeObject::OBJECT_LIST);
2005-01-28 00:11:44 +03:00
buildPhases->AddObject(sourceBuildPhase);
buildPhases->AddObject(headerBuildPhase);
buildPhases->AddObject(frameworkBuildPhase);
2005-02-03 01:16:07 +03:00
targets.push_back(this->CreateXCodeTarget(l->second, buildPhases));
2005-01-28 00:11:44 +03:00
}
2005-02-03 01:16:07 +03:00
}
2005-02-01 21:07:42 +03:00
2005-01-28 00:11:44 +03:00
2005-02-03 01:16:07 +03:00
void cmGlobalXCodeGenerator::CreateBuildSettings(cmTarget& target,
cmXCodeObject* buildSettings,
std::string& fileType,
std::string& productType,
std::string& productName)
2005-02-01 21:07:42 +03:00
{
2005-02-03 01:16:07 +03:00
std::string flags;
bool shared = ((target.GetType() == cmTarget::SHARED_LIBRARY) ||
(target.GetType() == cmTarget::MODULE_LIBRARY));
2005-02-11 22:25:05 +03:00
if(shared)
{
flags += "-D";
if(const char* custom_export_name = target.GetProperty("DEFINE_SYMBOL"))
{
flags += custom_export_name;
}
else
{
std::string in = target.GetName();
in += "_EXPORTS";
flags += cmSystemTools::MakeCindentifier(in.c_str());
}
}
2005-02-03 01:16:07 +03:00
const char* lang = target.GetLinkerLanguage(this);
if(lang)
{
// Add language-specific flags.
m_CurrentLocalGenerator->AddLanguageFlags(flags, lang);
// Add shared-library flags if needed.
m_CurrentLocalGenerator->AddSharedFlags(flags, lang, shared);
}
2005-02-11 22:25:05 +03:00
2005-02-03 01:16:07 +03:00
// Add include directory flags.
2005-02-04 01:42:55 +03:00
m_CurrentLocalGenerator->
AppendFlags(flags, m_CurrentLocalGenerator->GetIncludeFlags(lang));
2005-02-03 01:16:07 +03:00
2005-02-04 01:42:55 +03:00
// Add include directory flags.
m_CurrentLocalGenerator->AppendFlags(flags,
2005-02-03 01:16:07 +03:00
m_CurrentMakefile->GetDefineFlags());
cmSystemTools::ReplaceString(flags, "\"", "\\\"");
productName = target.GetName();
switch(target.GetType())
{
case cmTarget::STATIC_LIBRARY:
2005-02-05 01:58:58 +03:00
{
2005-02-03 01:16:07 +03:00
productName += ".a";
2005-02-05 01:58:58 +03:00
std::string t = "lib";
t += productName;
productName = t;
2005-02-03 01:16:07 +03:00
productType = "com.apple.product-type.library.static";
2005-02-05 01:58:58 +03:00
fileType = "archive.ar";
2005-02-03 01:16:07 +03:00
buildSettings->AddAttribute("LIBRARY_STYLE",
this->CreateString("STATIC"));
break;
2005-02-05 01:58:58 +03:00
}
2005-02-03 01:16:07 +03:00
case cmTarget::MODULE_LIBRARY:
buildSettings->AddAttribute("LIBRARY_STYLE",
this->CreateString("DYNAMIC"));
productName += ".so";
buildSettings->AddAttribute("OTHER_LDFLAGS",
this->CreateString("-bundle"));
productType = "com.apple.product-type.library.dynamic";
fileType = "compiled.mach-o.dylib";
break;
case cmTarget::SHARED_LIBRARY:
buildSettings->AddAttribute("LIBRARY_STYLE",
this->CreateString("DYNAMIC"));
productName += ".dylib";
buildSettings->AddAttribute("DYLIB_COMPATIBILITY_VERSION",
this->CreateString("1"));
buildSettings->AddAttribute("DYLIB_CURRENT_VERSION",
this->CreateString("1"));
buildSettings->AddAttribute("OTHER_LDFLAGS",
this->CreateString("-dynamiclib"));
productType = "com.apple.product-type.library.dynamic";
fileType = "compiled.mach-o.dylib";
break;
2005-02-04 01:42:55 +03:00
case cmTarget::EXECUTABLE:
2005-02-03 01:16:07 +03:00
fileType = "compiled.mach-o.executable";
productType = "com.apple.product-type.tool";
break;
case cmTarget::UTILITY:
2005-02-04 01:42:55 +03:00
2005-02-03 01:16:07 +03:00
break;
case cmTarget::INSTALL_FILES:
break;
case cmTarget::INSTALL_PROGRAMS:
break;
}
2005-02-05 01:58:58 +03:00
buildSettings->AddAttribute("GCC_OPTIMIZATION_LEVEL",
this->CreateString("0"));
2005-02-01 21:07:42 +03:00
buildSettings->AddAttribute("INSTALL_PATH",
this->CreateString("/usr/local/bin"));
buildSettings->AddAttribute("OPTIMIZATION_CFLAGS",
this->CreateString(""));
buildSettings->AddAttribute("OTHER_CFLAGS",
2005-02-03 01:16:07 +03:00
this->CreateString(flags.c_str()));
2005-02-01 21:07:42 +03:00
buildSettings->AddAttribute("OTHER_LDFLAGS",
this->CreateString(""));
buildSettings->AddAttribute("OTHER_REZFLAGS",
this->CreateString(""));
buildSettings->AddAttribute("SECTORDER_FLAGS",
this->CreateString(""));
2005-02-03 01:16:07 +03:00
buildSettings->AddAttribute("WARNING_CFLAGS",
this->CreateString(
"-Wmost -Wno-four-char-constants"
" -Wno-unknown-pragmas"));
buildSettings->AddAttribute("PRODUCT_NAME",
this->CreateString(target.GetName()));
2005-02-01 21:07:42 +03:00
}
2005-02-04 01:42:55 +03:00
cmXCodeObject*
cmGlobalXCodeGenerator::CreateUtilityTarget(cmTarget& cmtarget)
{
cmXCodeObject* shellBuildPhase =
this->CreateObject(cmXCodeObject::PBXShellScriptBuildPhase);
shellBuildPhase->AddAttribute("buildActionMask",
this->CreateString("2147483647"));
cmXCodeObject* buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
shellBuildPhase->AddAttribute("files", buildFiles);
cmXCodeObject* inputPaths = this->CreateObject(cmXCodeObject::OBJECT_LIST);
shellBuildPhase->AddAttribute("inputPaths", inputPaths);
cmXCodeObject* outputPaths = this->CreateObject(cmXCodeObject::OBJECT_LIST);
shellBuildPhase->AddAttribute("outputPaths", outputPaths);
shellBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
this->CreateString("0"));
shellBuildPhase->AddAttribute("shellPath",
this->CreateString("/bin/sh"));
shellBuildPhase->AddAttribute("shellScript",
this->CreateString(
"# shell script goes here\nexit 0"));
cmXCodeObject* target =
this->CreateObject(cmXCodeObject::PBXAggregateTarget);
cmXCodeObject* buildPhases =
this->CreateObject(cmXCodeObject::OBJECT_LIST);
buildPhases->AddObject(shellBuildPhase);
target->AddAttribute("buildPhases", buildPhases);
cmXCodeObject* buildSettings =
this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
std::string fileTypeString;
std::string productTypeString;
std::string productName;
this->CreateBuildSettings(cmtarget,
buildSettings, fileTypeString,
productTypeString, productName);
target->AddAttribute("buildSettings", buildSettings);
cmXCodeObject* dependencies = this->CreateObject(cmXCodeObject::OBJECT_LIST);
target->AddAttribute("dependencies", dependencies);
target->AddAttribute("name", this->CreateString(cmtarget.GetName()));
target->AddAttribute("productName",this->CreateString(cmtarget.GetName()));
target->SetcmTarget(&cmtarget);
return target;
}
2005-02-03 01:16:07 +03:00
cmXCodeObject*
cmGlobalXCodeGenerator::CreateXCodeTarget(cmTarget& cmtarget,
cmXCodeObject* buildPhases)
2005-02-01 21:07:42 +03:00
{
2005-02-04 01:42:55 +03:00
cmXCodeObject* target =
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);
cmXCodeObject* buildSettings =
this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
2005-02-03 01:16:07 +03:00
std::string fileTypeString;
std::string productTypeString;
std::string productName;
this->CreateBuildSettings(cmtarget,
buildSettings, fileTypeString,
productTypeString, productName);
2005-02-01 21:07:42 +03:00
target->AddAttribute("buildSettings", buildSettings);
cmXCodeObject* dependencies = this->CreateObject(cmXCodeObject::OBJECT_LIST);
target->AddAttribute("dependencies", dependencies);
target->AddAttribute("name", this->CreateString(cmtarget.GetName()));
target->AddAttribute("productName",this->CreateString(cmtarget.GetName()));
2005-02-08 01:36:34 +03:00
2005-02-01 21:07:42 +03:00
cmXCodeObject* fileRef = this->CreateObject(cmXCodeObject::PBXFileReference);
fileRef->AddAttribute("explicitFileType",
2005-02-03 01:16:07 +03:00
this->CreateString(fileTypeString.c_str()));
fileRef->AddAttribute("path", this->CreateString(productName.c_str()));
2005-02-01 21:07:42 +03:00
fileRef->AddAttribute("refType", this->CreateString("3"));
2005-02-08 01:36:34 +03:00
fileRef->AddAttribute("sourceTree",
this->CreateString("BUILT_PRODUCTS_DIR"));
target->AddAttribute("productReference",
this->CreateObjectReference(fileRef));
2005-02-01 21:07:42 +03:00
target->AddAttribute("productType",
2005-02-03 01:16:07 +03:00
this->CreateString(productTypeString.c_str()));
2005-02-04 01:42:55 +03:00
target->SetcmTarget(&cmtarget);
2005-02-01 21:07:42 +03:00
return target;
}
2005-02-04 01:42:55 +03:00
cmXCodeObject* cmGlobalXCodeGenerator::FindXCodeTarget(cmTarget* t)
{
if(!t)
{
return 0;
}
for(std::vector<cmXCodeObject*>::iterator i = m_XCodeObjects.begin();
i != m_XCodeObjects.end(); ++i)
{
cmXCodeObject* o = *i;
if(o->GetcmTarget() == t)
{
return o;
}
}
return 0;
}
void cmGlobalXCodeGenerator::AddDependTarget(cmXCodeObject* target,
cmXCodeObject* dependTarget)
{
2005-02-05 01:58:58 +03:00
cmXCodeObject* targetdep = dependTarget->GetPBXTargetDependency();
if(!targetdep)
{
cmXCodeObject* container =
this->CreateObject(cmXCodeObject::PBXContainerItemProxy);
container->AddAttribute("containerPortal",
this->CreateObjectReference(m_RootObject));
container->AddAttribute("proxyType", this->CreateString("1"));
container->AddAttribute("remoteGlobalIDString",
this->CreateObjectReference(dependTarget));
container->AddAttribute("remoteInfo",
this->CreateString(
dependTarget->GetcmTarget()->GetName()));
targetdep =
this->CreateObject(cmXCodeObject::PBXTargetDependency);
targetdep->AddAttribute("target",
this->CreateObjectReference(dependTarget));
targetdep->AddAttribute("targetProxy",
this->CreateObjectReference(container));
dependTarget->SetPBXTargetDependency(targetdep);
}
2005-02-04 01:42:55 +03:00
cmXCodeObject* depends = target->GetObject("dependencies");
if(!depends)
{
std::cerr << "target does not have dependencies attribute error...\n";
}
else
{
depends->AddObject(targetdep);
}
}
2005-02-05 01:58:58 +03:00
void cmGlobalXCodeGenerator::AddLinkTarget(cmXCodeObject* target ,
cmXCodeObject* dependTarget )
2005-02-04 01:42:55 +03:00
{
2005-02-05 01:58:58 +03:00
cmXCodeObject* ref = dependTarget->GetObject("productReference");
2005-02-08 01:36:34 +03:00
cmXCodeObject* buildfile = this->CreateObject(cmXCodeObject::PBXBuildFile);
2005-02-05 01:58:58 +03:00
buildfile->AddAttribute("fileRef", ref);
cmXCodeObject* settings =
this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
buildfile->AddAttribute("settings", settings);
cmXCodeObject* buildPhases = target->GetObject("buildPhases");
cmXCodeObject* frameworkBuildPhase =
buildPhases->GetObject(cmXCodeObject::PBXFrameworksBuildPhase);
cmXCodeObject* files = frameworkBuildPhase->GetObject("files");
files->AddObject(buildfile);
2005-02-04 01:42:55 +03:00
}
2005-02-11 22:25:05 +03:00
void cmGlobalXCodeGenerator::AddLinkLibrary(cmXCodeObject* target,
const char* library)
2005-02-04 01:42:55 +03:00
{
2005-02-11 22:25:05 +03:00
// if the library is a full path then create a file reference
// and build file and add them to the PBXFrameworksBuildPhase
// for the target
if(cmSystemTools::FileIsFullPath(library))
2005-02-09 01:12:38 +03:00
{
2005-02-11 22:25:05 +03:00
std::string libPath = library;
2005-02-09 01:12:38 +03:00
cmXCodeObject* fileRef =
this->CreateObject(cmXCodeObject::PBXFileReference);
if(libPath[libPath.size()-1] == 'a')
{
fileRef->AddAttribute("lastKnownFileType",
this->CreateString("archive.ar"));
}
else
{
fileRef->AddAttribute("lastKnownFileType",
this->CreateString("compiled.mach-o.dylib"));
}
fileRef->AddAttribute("name",
this->CreateString(
cmSystemTools::GetFilenameName(libPath).c_str()));
fileRef->AddAttribute("path", this->CreateString(libPath.c_str()));
fileRef->AddAttribute("refType", this->CreateString("0"));
fileRef->AddAttribute("sourceTree", this->CreateString("<absolute>"));
cmXCodeObject* buildfile = this->CreateObject(cmXCodeObject::PBXBuildFile);
buildfile->AddAttribute("fileRef", this->CreateObjectReference(fileRef));
cmXCodeObject* settings =
this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
buildfile->AddAttribute("settings", settings);
// get the framework build phase from the target
cmXCodeObject* buildPhases = target->GetObject("buildPhases");
cmXCodeObject* frameworkBuildPhase =
buildPhases->GetObject(cmXCodeObject::PBXFrameworksBuildPhase);
cmXCodeObject* files = frameworkBuildPhase->GetObject("files");
files->AddObject(buildfile);
m_MainGroupChildren->AddObject(fileRef);
}
else
{
2005-02-11 22:25:05 +03:00
// if the library is not a full path then add it with a -l flag
// to the settings of the target
2005-02-09 01:12:38 +03:00
cmXCodeObject* settings = target->GetObject("buildSettings");
cmXCodeObject* ldflags = settings->GetObject("OTHER_LDFLAGS");
std::string link = ldflags->GetString();
cmSystemTools::ReplaceString(link, "\"", "");
2005-02-11 22:25:05 +03:00
cmsys::RegularExpression reg("^([ \t]*\\-[lWRB])|([ \t]*\\-framework)|(\\${)|([ \t]*\\-pthread)|([ \t]*`)");
// if the library is not already in the form required by the compiler
// add a -l infront of the name
if(!reg.find(library))
{
link += " -l";
}
link += library;
2005-02-09 01:12:38 +03:00
ldflags->SetString(link.c_str());
}
2005-02-04 01:42:55 +03:00
}
void cmGlobalXCodeGenerator::AddDependAndLinkInformation(cmXCodeObject* target)
{
cmTarget* cmtarget = target->GetcmTarget();
if(!cmtarget)
{
std::cerr << "Error no target on xobject\n";
return;
}
cmTarget::LinkLibraries::const_iterator j, jend;
j = cmtarget->GetLinkLibraries().begin();
jend = cmtarget->GetLinkLibraries().end();
for(;j!= jend; ++j)
{
cmTarget* t = this->FindTarget(j->first.c_str());
cmXCodeObject* dptarget = this->FindXCodeTarget(t);
if(dptarget)
{
this->AddDependTarget(target, dptarget);
2005-02-08 01:36:34 +03:00
if(cmtarget->GetType() != cmTarget::STATIC_LIBRARY)
{
this->AddLinkTarget(target, dptarget);
}
2005-02-04 01:42:55 +03:00
}
else
{
2005-02-09 01:12:38 +03:00
if(cmtarget->GetType() != cmTarget::STATIC_LIBRARY)
{
2005-02-11 22:25:05 +03:00
this->AddLinkLibrary(target, j->first.c_str());
2005-02-09 01:12:38 +03:00
}
2005-02-04 01:42:55 +03:00
}
}
std::set<cmStdString>::const_iterator i, end;
// write utility dependencies.
i = cmtarget->GetUtilities().begin();
end = cmtarget->GetUtilities().end();
for(;i!= end; ++i)
{
cmTarget* t = this->FindTarget(i->c_str());
cmXCodeObject* dptarget = this->FindXCodeTarget(t);
if(dptarget)
{
this->AddDependTarget(target, dptarget);
}
else
{
2005-02-05 01:58:58 +03:00
std::cerr << "Error External Util???: " << i->c_str() << "\n";
2005-02-04 01:42:55 +03:00
}
}
}
2005-02-03 01:16:07 +03:00
// to force the location of a target
//6FE4372B07AAF276004FB461 = {
//buildSettings = {
//COPY_PHASE_STRIP = NO;
//SYMROOT = "/Users/kitware/Bill/CMake-build/test/build/bin";
//};
//isa = PBXBuildStyle;
//name = Development;
//};
2005-01-28 00:11:44 +03:00
//----------------------------------------------------------------------------
2005-01-28 03:24:51 +03:00
void cmGlobalXCodeGenerator::CreateXCodeObjects(cmLocalGenerator* ,
2005-01-28 00:11:44 +03:00
std::vector<cmLocalGenerator*>&
generators
2005-02-01 21:07:42 +03:00
)
2005-01-25 01:35:54 +03:00
{
this->ClearXCodeObjects();
2005-02-02 01:17:12 +03:00
m_RootObject = 0;
2005-02-09 01:12:38 +03:00
m_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"));
2005-02-11 22:25:05 +03:00
cmXCodeObject* developBuildStyle =
this->CreateObject(cmXCodeObject::PBXBuildStyle);
developBuildStyle->AddAttribute("name", this->CreateString("Development"));
2005-01-25 01:35:54 +03:00
developBuildStyle->AddAttribute("buildSettings", group);
2005-01-28 00:11:44 +03:00
group = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
group->AddAttribute("COPY_PHASE_STRIP", this->CreateString("YES"));
2005-02-11 22:25:05 +03:00
cmXCodeObject* deployBuildStyle =
this->CreateObject(cmXCodeObject::PBXBuildStyle);
deployBuildStyle->AddAttribute("name", this->CreateString("Deployment"));
2005-01-25 01:35:54 +03:00
deployBuildStyle->AddAttribute("buildSettings", group);
2005-01-28 00:11:44 +03:00
cmXCodeObject* listObjs = this->CreateObject(cmXCodeObject::OBJECT_LIST);
2005-01-25 01:35:54 +03:00
listObjs->AddObject(developBuildStyle);
listObjs->AddObject(deployBuildStyle);
2005-01-29 00:00:10 +03:00
cmXCodeObject* mainGroup = this->CreateObject(cmXCodeObject::PBXGroup);
2005-02-09 01:12:38 +03:00
m_MainGroupChildren =
2005-02-05 01:58:58 +03:00
this->CreateObject(cmXCodeObject::OBJECT_LIST);
2005-02-09 01:12:38 +03:00
mainGroup->AddAttribute("children", m_MainGroupChildren);
2005-01-29 00:00:10 +03:00
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-05 01:58:58 +03:00
cmXCodeObject* productGroup = this->CreateObject(cmXCodeObject::PBXGroup);
productGroup->AddAttribute("name", this->CreateString("Products"));
productGroup->AddAttribute("refType", this->CreateString("4"));
productGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
cmXCodeObject* productGroupChildren =
this->CreateObject(cmXCodeObject::OBJECT_LIST);
productGroup->AddAttribute("children", productGroupChildren);
2005-02-09 01:12:38 +03:00
m_MainGroupChildren->AddObject(productGroup);
2005-02-05 01:58:58 +03:00
2005-01-28 00:11:44 +03:00
m_RootObject = this->CreateObject(cmXCodeObject::PBXProject);
group = this->CreateObject(cmXCodeObject::ATTRIBUTE_GROUP);
2005-02-05 01:58:58 +03:00
m_RootObject->AddAttribute("mainGroup",
this->CreateObjectReference(mainGroup));
2005-01-25 01:35:54 +03:00
m_RootObject->AddAttribute("buildSettings", group);
m_RootObject->AddAttribute("buildSyles", listObjs);
2005-02-05 01:58:58 +03:00
m_RootObject->AddAttribute("hasScannedForEncodings",
this->CreateString("0"));
2005-01-28 00:11:44 +03:00
std::vector<cmXCodeObject*> targets;
for(std::vector<cmLocalGenerator*>::iterator i = generators.begin();
i != generators.end(); ++i)
{
2005-02-09 01:12:38 +03:00
this->CreateXCodeTargets(*i, targets);
2005-01-28 00:11:44 +03:00
}
cmXCodeObject* allTargets = this->CreateObject(cmXCodeObject::OBJECT_LIST);
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);
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
}
m_RootObject->AddAttribute("targets", allTargets);
2005-01-25 01:35:54 +03:00
}
//----------------------------------------------------------------------------
2005-02-11 22:25:05 +03:00
void
cmGlobalXCodeGenerator::OutputXCodeProject(cmLocalGenerator* root,
std::vector<cmLocalGenerator*>&
generators)
2005-01-25 01:35:54 +03:00
{
if(generators.size() == 0)
{
return;
}
this->CreateXCodeObjects(root,
generators);
std::string xcodeDir = root->GetMakefile()->GetStartOutputDirectory();
xcodeDir += "/";
xcodeDir += root->GetMakefile()->GetProjectName();
xcodeDir += ".xcode";
cmSystemTools::MakeDirectory(xcodeDir.c_str());
xcodeDir += "/project.pbxproj";
cmGeneratedFileStream fout(xcodeDir.c_str());
fout.SetCopyIfDifferent(true);
if(!fout)
{
return;
}
this->WriteXCodePBXProj(fout, root, generators);
this->ClearXCodeObjects();
}
//----------------------------------------------------------------------------
2005-02-11 22:25:05 +03:00
void
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);
fout << "objectVersion = 39;\n";
cmXCodeObject::PrintList(m_XCodeObjects, fout);
cmXCodeObject::Indent(1, fout);
fout << "rootObject = " << m_RootObject->GetId() << ";\n";
fout << "}\n";
}
//----------------------------------------------------------------------------
2005-02-11 22:25:05 +03:00
void cmGlobalXCodeGenerator::GetDocumentation(cmDocumentationEntry& entry)
const
2005-01-25 01:35:54 +03:00
{
entry.name = this->GetName();
2005-02-11 22:25:05 +03:00
entry.brief = "Generate XCode project files.";
2005-01-25 01:35:54 +03:00
entry.full = "";
}