CMake/Source/cmGlobalXCodeGenerator.cxx

1268 lines
46 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
// custom commands
// custom targets
// ALL_BUILD
// RUN_TESTS
2005-02-15 00:46:32 +03:00
// add a group for Sources Headers, and other cmake group stuff
2005-02-11 22:25:05 +03:00
2005-02-15 00:46:32 +03:00
// for each target create a custom build phase that is run first
// it can have inputs and outputs should just be a makefile
2005-02-11 22:25:05 +03:00
// 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-02-15 00:46:32 +03:00
m_SourcesGroupChildren = 0;
m_ExternalGroupChildren = 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-17 02:47:30 +03:00
makeCommand += " build -target ";
2005-02-01 21:07:42 +03:00
if (targetName)
{
makeCommand += targetName;
}
2005-02-17 02:47:30 +03:00
else
{
makeCommand += "ALL_BUILD";
}
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
}
2005-02-15 00:46:32 +03:00
void cmGlobalXCodeGenerator::ConfigureOutputPaths()
{
// Format the library and executable output paths.
m_LibraryOutputPath =
m_CurrentMakefile->GetSafeDefinition("LIBRARY_OUTPUT_PATH");
if(m_LibraryOutputPath.size() == 0)
{
m_LibraryOutputPath = m_CurrentMakefile->GetCurrentOutputDirectory();
}
// make sure there is a trailing slash
if(m_LibraryOutputPath.size() &&
m_LibraryOutputPath[m_LibraryOutputPath.size()-1] != '/')
{
m_LibraryOutputPath += "/";
if(!cmSystemTools::MakeDirectory(m_LibraryOutputPath.c_str()))
{
cmSystemTools::Error("Error creating directory ",
m_LibraryOutputPath.c_str());
}
}
m_CurrentMakefile->AddLinkDirectory(m_LibraryOutputPath.c_str());
m_ExecutableOutputPath =
m_CurrentMakefile->GetSafeDefinition("EXECUTABLE_OUTPUT_PATH");
if(m_ExecutableOutputPath.size() == 0)
{
m_ExecutableOutputPath = m_CurrentMakefile->GetCurrentOutputDirectory();
}
// make sure there is a trailing slash
if(m_ExecutableOutputPath.size() &&
m_ExecutableOutputPath[m_ExecutableOutputPath.size()-1] != '/')
{
m_ExecutableOutputPath += "/";
if(!cmSystemTools::MakeDirectory(m_ExecutableOutputPath.c_str()))
{
cmSystemTools::Error("Error creating directory ",
m_ExecutableOutputPath.c_str());
}
}
}
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();
2005-02-17 00:35:32 +03:00
std::vector<std::string> srcs;
2005-01-25 01:35:54 +03:00
std::map<cmStdString, std::vector<cmLocalGenerator*> >::iterator it;
for(it = m_ProjectMap.begin(); it!= m_ProjectMap.end(); ++it)
{
2005-02-17 00:35:32 +03:00
// add a ALL_BUILD target to the first makefile of each project
it->second[0]->GetMakefile()->
AddUtilityCommand("ALL_BUILD", "echo",
"\"Build all projects\"",false,srcs);
cmTarget* allbuild =
it->second[0]->GetMakefile()->FindTarget("ALL_BUILD");
// now make the allbuild depend on all the non-utility targets
// in the project
for(std::vector<cmLocalGenerator*>::iterator i = it->second.begin();
i != it->second.end(); ++i)
{
cmLocalGenerator* lg = *i;
cmTargets& tgts = lg->GetMakefile()->GetTargets();
for(cmTargets::iterator l = tgts.begin(); l != tgts.end(); l++)
{
cmTarget& target = l->second;
if(target.GetType() < cmTarget::UTILITY)
{
allbuild->AddUtility(target.GetName());
}
}
}
// now create the project
2005-01-25 01:35:54 +03:00
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-15 00:46:32 +03:00
m_SourcesGroupChildren->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;
2005-02-17 00:35:32 +03:00
// make sure ALL_BUILD is only done once
if(l->first == "ALL_BUILD")
{
if(m_DoneAllBuild)
{
continue;
}
m_DoneAllBuild = true;
}
2005-02-04 01:42:55 +03:00
if(cmtarget.GetType() == cmTarget::UTILITY ||
cmtarget.GetType() == cmTarget::INSTALL_FILES ||
cmtarget.GetType() == cmTarget::INSTALL_PROGRAMS)
{
2005-02-15 00:46:32 +03:00
if(cmtarget.GetType() == cmTarget::UTILITY)
{
targets.push_back(this->CreateUtilityTarget(cmtarget));
}
2005-02-04 01:42:55 +03:00
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-02-04 01:42:55 +03:00
cmXCodeObject* buildPhases =
this->CreateObject(cmXCodeObject::OBJECT_LIST);
this->CreateCustomCommands(buildPhases, sourceBuildPhase,
headerBuildPhase, frameworkBuildPhase,
cmtarget);
targets.push_back(this->CreateXCodeTarget(l->second, buildPhases));
}
}
void cmGlobalXCodeGenerator::CreateCustomCommands(cmXCodeObject* buildPhases,
cmXCodeObject*
sourceBuildPhase,
cmXCodeObject*
headerBuildPhase,
cmXCodeObject*
frameworkBuildPhase,
cmTarget& cmtarget)
{
std::vector<cmCustomCommand> const & prebuild
= cmtarget.GetPreBuildCommands();
std::vector<cmCustomCommand> const & prelink
= cmtarget.GetPreLinkCommands();
std::vector<cmCustomCommand> const & postbuild
= cmtarget.GetPostBuildCommands();
cmtarget.TraceVSDependencies(cmtarget.GetName(), m_CurrentMakefile);
std::vector<cmSourceFile*> &classes = cmtarget.GetSourceFiles();
// add all the sources
std::vector<cmCustomCommand> commands;
for(std::vector<cmSourceFile*>::iterator i = classes.begin();
i != classes.end(); ++i)
{
if((*i)->GetCustomCommand())
{
commands.push_back(*(*i)->GetCustomCommand());
}
}
// create prebuild phase
cmXCodeObject* cmakeRulesBuildPhase = 0;
if(commands.size())
{
cmakeRulesBuildPhase =
this->CreateObject(cmXCodeObject::PBXShellScriptBuildPhase);
cmakeRulesBuildPhase->AddAttribute("buildActionMask",
this->CreateString("2147483647"));
cmXCodeObject* buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
cmakeRulesBuildPhase->AddAttribute("files", buildFiles);
cmakeRulesBuildPhase->AddAttribute("name",
this->CreateString("CMake Rules"));
cmakeRulesBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
this->CreateString("0"));
cmakeRulesBuildPhase->AddAttribute("shellPath",
this->CreateString("/bin/sh"));
this->AddCommandsToBuildPhase(cmakeRulesBuildPhase, cmtarget, commands,
"cmakeRulesCommands");
}
// create prebuild phase
cmXCodeObject* preBuildPhase = 0;
if(prebuild.size())
{
preBuildPhase =
this->CreateObject(cmXCodeObject::PBXShellScriptBuildPhase);
preBuildPhase->AddAttribute("buildActionMask",
this->CreateString("2147483647"));
cmXCodeObject* buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
preBuildPhase->AddAttribute("files", buildFiles);
preBuildPhase->AddAttribute("name",
this->CreateString("CMake PreBuild Rules"));
preBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
this->CreateString("0"));
preBuildPhase->AddAttribute("shellPath", this->CreateString("/bin/sh"));
this->AddCommandsToBuildPhase(preBuildPhase, cmtarget, prebuild,
"preBuildCommands");
}
// create prebuild phase
cmXCodeObject* preLinkPhase = 0;
if(prelink.size())
{
preLinkPhase =
this->CreateObject(cmXCodeObject::PBXShellScriptBuildPhase);
preLinkPhase->AddAttribute("buildActionMask",
this->CreateString("2147483647"));
cmXCodeObject* buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
preLinkPhase->AddAttribute("files", buildFiles);
preLinkPhase->AddAttribute("name",
this->CreateString("CMake PreLink Rules"));
preLinkPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
this->CreateString("0"));
preLinkPhase->AddAttribute("shellPath", this->CreateString("/bin/sh"));
this->AddCommandsToBuildPhase(preLinkPhase, cmtarget, prelink,
"preLinkCommands");
}
// create prebuild phase
cmXCodeObject* postBuildPhase = 0;
if(postbuild.size())
{
postBuildPhase =
this->CreateObject(cmXCodeObject::PBXShellScriptBuildPhase);
postBuildPhase->AddAttribute("buildActionMask",
this->CreateString("2147483647"));
cmXCodeObject* buildFiles = this->CreateObject(cmXCodeObject::OBJECT_LIST);
postBuildPhase->AddAttribute("files", buildFiles);
postBuildPhase->AddAttribute("name",
this->CreateString("CMake PostBuild Rules"));
postBuildPhase->AddAttribute("runOnlyForDeploymentPostprocessing",
this->CreateString("0"));
postBuildPhase->AddAttribute("shellPath", this->CreateString("/bin/sh"));
this->AddCommandsToBuildPhase(postBuildPhase, cmtarget, postbuild,
"postBuildCommands");
}
// the order here is the order they will be built in
if(preBuildPhase)
{
buildPhases->AddObject(preBuildPhase);
}
if(cmakeRulesBuildPhase)
{
buildPhases->AddObject(cmakeRulesBuildPhase);
}
if(sourceBuildPhase)
{
2005-01-28 00:11:44 +03:00
buildPhases->AddObject(sourceBuildPhase);
}
if(headerBuildPhase)
{
2005-01-28 00:11:44 +03:00
buildPhases->AddObject(headerBuildPhase);
}
if(preLinkPhase)
{
buildPhases->AddObject(preLinkPhase);
}
if(frameworkBuildPhase)
{
2005-01-28 00:11:44 +03:00
buildPhases->AddObject(frameworkBuildPhase);
}
if(postBuildPhase)
{
buildPhases->AddObject(postBuildPhase);
}
}
void
cmGlobalXCodeGenerator::AddCommandsToBuildPhase(cmXCodeObject* buildphase,
cmTarget& target,
std::vector<cmCustomCommand>
const & commands,
const char* name)
{
std::string makefile = m_CurrentMakefile->GetCurrentOutputDirectory();
cmSystemTools::MakeDirectory(makefile.c_str());
makefile += "/";
makefile += target.GetName();
makefile += "_";
makefile += name;
makefile += ".make";
cmGeneratedFileStream makefileStream(makefile.c_str());
if(!makefileStream)
{
return;
}
makefileStream << "# Generated by CMake, DO NOT EDIT\n";
makefileStream << "# Custom rules for " << target.GetName() << "\n";
// have all depend on all outputs
makefileStream << "all: ";
for(std::vector<cmCustomCommand>::const_iterator i = commands.begin();
i != commands.end(); ++i)
{
cmCustomCommand const& cc = *i;
if(cc.GetCommand().size())
{
if(cc.GetOutput().size())
{
makefileStream << "\\\n\t" << m_CurrentLocalGenerator
->ConvertToRelativeOutputPath(cc.GetOutput().c_str());
}
else
{
makefileStream << "\\\n\t" << target.GetName();
}
}
}
makefileStream << "\n\n";
for(std::vector<cmCustomCommand>::const_iterator i = commands.begin();
i != commands.end(); ++i)
{
cmCustomCommand const& cc = *i;
if(cc.GetCommand().size())
{
makefileStream << "\n#" << "Custom command rule: " <<
cc.GetComment() << "\n";
if(cc.GetOutput().size())
{
makefileStream << m_CurrentLocalGenerator
->ConvertToRelativeOutputPath(cc.GetOutput().c_str()) << ": ";
}
else
{
// if no outputs then use the target name as this must
// be a utility target
makefileStream << target.GetName() << ": ";
}
for(std::vector<std::string>::const_iterator d = cc.GetDepends().begin();
d != cc.GetDepends().end(); ++d)
{
if(!this->FindTarget(d->c_str()))
{
makefileStream << "\\\n" << *d;
}
else
{
// if the depend is a target then make
// the target with the source that is a custom command
// depend on the that target via a AddUtility call
target.AddUtility(d->c_str());
}
}
makefileStream << "\n";
makefileStream << "\t" << cc.GetCommand() << " "
<< cc.GetArguments() << "\n";
}
2005-01-28 00:11:44 +03:00
}
2005-02-03 01:16:07 +03:00
std::string dir = cmSystemTools::ConvertToOutputPath(
m_CurrentMakefile->GetCurrentOutputDirectory());
std::string makecmd = "make -C ";
makecmd += dir;
makecmd += " -f ";
makecmd += makefile;
buildphase->AddAttribute("shellScript", this->CreateString(makecmd.c_str()));
}
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-15 00:46:32 +03:00
this->ConfigureOutputPaths();
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-15 00:46:32 +03:00
// Add define flags
2005-02-04 01:42:55 +03:00
m_CurrentLocalGenerator->AppendFlags(flags,
2005-02-03 01:16:07 +03:00
m_CurrentMakefile->GetDefineFlags());
cmSystemTools::ReplaceString(flags, "\"", "\\\"");
productName = target.GetName();
2005-02-15 00:46:32 +03:00
bool needLinkDirs = true;
2005-02-03 01:16:07 +03:00
switch(target.GetType())
{
case cmTarget::STATIC_LIBRARY:
2005-02-05 01:58:58 +03:00
{
2005-02-15 00:46:32 +03:00
needLinkDirs = false;
if(m_LibraryOutputPath.size())
{
buildSettings->AddAttribute("SYMROOT",
this->CreateString
(m_LibraryOutputPath.c_str()));
}
2005-02-03 01:16:07 +03:00
productName += ".a";
2005-02-05 01:58:58 +03:00
std::string t = "lib";
t += productName;
2005-02-15 00:46:32 +03:00
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:
2005-02-15 00:46:32 +03:00
{
if(m_LibraryOutputPath.size())
{
buildSettings->AddAttribute("SYMROOT",
this->CreateString
(m_LibraryOutputPath.c_str()));
}
2005-02-17 00:35:32 +03:00
buildSettings->AddAttribute("EXECUTABLE_PREFIX",
this->CreateString("lib"));
buildSettings->AddAttribute("EXECUTABLE_EXTENSION",
this->CreateString("so"));
2005-02-03 01:16:07 +03:00
buildSettings->AddAttribute("LIBRARY_STYLE",
2005-02-17 00:35:32 +03:00
this->CreateString("BUNDLE"));
2005-02-03 01:16:07 +03:00
productName += ".so";
2005-02-15 00:46:32 +03:00
std::string t = "lib";
t += productName;
productName = t;
2005-02-03 01:16:07 +03:00
buildSettings->AddAttribute("OTHER_LDFLAGS",
this->CreateString("-bundle"));
productType = "com.apple.product-type.library.dynamic";
fileType = "compiled.mach-o.dylib";
break;
2005-02-15 00:46:32 +03:00
}
2005-02-03 01:16:07 +03:00
case cmTarget::SHARED_LIBRARY:
2005-02-15 00:46:32 +03:00
{
if(m_LibraryOutputPath.size())
{
buildSettings->AddAttribute("SYMROOT",
this->CreateString
(m_LibraryOutputPath.c_str()));
}
2005-02-03 01:16:07 +03:00
buildSettings->AddAttribute("LIBRARY_STYLE",
this->CreateString("DYNAMIC"));
productName += ".dylib";
2005-02-15 00:46:32 +03:00
std::string t = "lib";
t += productName;
productName = t;
2005-02-03 01:16:07 +03:00
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-15 00:46:32 +03:00
}
2005-02-04 01:42:55 +03:00
case cmTarget::EXECUTABLE:
2005-02-15 00:46:32 +03:00
if(m_ExecutableOutputPath.size())
{
buildSettings->AddAttribute("SYMROOT",
this->CreateString
(m_ExecutableOutputPath.c_str()));
}
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-15 00:46:32 +03:00
std::string dirs;
if(needLinkDirs)
{
// Try to emit each search path once
std::set<cmStdString> emitted;
// Some search paths should never be emitted
emitted.insert("");
emitted.insert("/usr/lib");
std::vector<std::string> const& linkdirs =
target.GetLinkDirectories();
for(std::vector<std::string>::const_iterator l = linkdirs.begin();
l != linkdirs.end(); ++l)
{
std::string libpath =
m_CurrentLocalGenerator->ConvertToOutputForExisting(l->c_str());
if(emitted.insert(libpath).second)
{
dirs += libpath + " ";
}
}
if(dirs.size())
{
buildSettings->AddAttribute("LIBRARY_SEARCH_PATHS",
this->CreateString(dirs.c_str()));
}
}
dirs = "";
std::vector<std::string>& includes =
m_CurrentMakefile->GetIncludeDirectories();
std::vector<std::string>::iterator i = includes.begin();
for(;i != includes.end(); ++i)
{
std::string incpath =
m_CurrentLocalGenerator->ConvertToOutputForExisting(i->c_str());
dirs += incpath + " ";
}
if(dirs.size())
{
buildSettings->AddAttribute("HEADER_SEARCH_PATHS",
this->CreateString(dirs.c_str()));
}
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",
2005-02-17 00:35:32 +03:00
this->CreateString(""));
2005-02-01 21:07:42 +03:00
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"));
2005-02-17 00:35:32 +03:00
std::string pname;
if(target.GetType() == cmTarget::SHARED_LIBRARY)
{
pname = "lib";
}
pname += target.GetName();
2005-02-03 01:16:07 +03:00
buildSettings->AddAttribute("PRODUCT_NAME",
2005-02-17 00:35:32 +03:00
this->CreateString(pname.c_str()));
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);
this->CreateCustomCommands(buildPhases, 0, 0, 0, cmtarget);
2005-02-04 01:42:55 +03:00
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-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"));
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);
2005-02-17 00:35:32 +03:00
// add the library path to the search path for the target
cmXCodeObject* bset = target->GetObject("buildSettings");
if(bset)
{
std::string dir;
std::string file;
cmSystemTools::SplitProgramPath(library, dir, file);
cmXCodeObject* spath = bset->GetObject("LIBRARY_SEARCH_PATHS");
if(spath)
{
std::string libs = spath->GetString();
// remove double quotes
libs = libs.substr(1, libs.size()-2);
libs += " ";
libs +=
m_CurrentLocalGenerator->ConvertToOutputForExisting(dir.c_str());
spath->SetString(libs.c_str());
}
else
{
std::string libs =
m_CurrentLocalGenerator->ConvertToOutputForExisting(dir.c_str());
bset->AddAttribute("LIBRARY_SEARCH_PATHS",
this->CreateString(libs.c_str()));
}
}
2005-02-09 01:12:38 +03:00
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);
2005-02-15 00:46:32 +03:00
m_ExternalGroupChildren->AddObject(fileRef);
2005-02-09 01:12:38 +03:00
}
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
2005-02-17 00:35:32 +03:00
link += " ";
2005-02-11 22:25:05 +03:00
if(!reg.find(library))
{
2005-02-17 00:35:32 +03:00
link += "-l";
2005-02-11 22:25:05 +03:00
}
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
2005-02-15 00:46:32 +03:00
// add this to build settings of target SYMROOT = /tmp/;
2005-02-03 01:16:07 +03:00
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-15 00:46:32 +03:00
m_ExternalGroupChildren = 0;
m_SourcesGroupChildren = 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-15 00:46:32 +03:00
cmXCodeObject* sourcesGroup = this->CreateObject(cmXCodeObject::PBXGroup);
m_SourcesGroupChildren =
this->CreateObject(cmXCodeObject::OBJECT_LIST);
sourcesGroup->AddAttribute("name", this->CreateString("Sources"));
sourcesGroup->AddAttribute("children", m_SourcesGroupChildren);
sourcesGroup->AddAttribute("refType", this->CreateString("4"));
sourcesGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
m_MainGroupChildren->AddObject(sourcesGroup);
cmXCodeObject* externalGroup = this->CreateObject(cmXCodeObject::PBXGroup);
m_ExternalGroupChildren =
this->CreateObject(cmXCodeObject::OBJECT_LIST);
externalGroup->AddAttribute("name",
this->CreateString("External Libraries and Frameworks"));
externalGroup->AddAttribute("children", m_ExternalGroupChildren);
externalGroup->AddAttribute("refType", this->CreateString("4"));
externalGroup->AddAttribute("sourceTree", this->CreateString("<group>"));
m_MainGroupChildren->AddObject(externalGroup);
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;
2005-02-17 00:35:32 +03:00
m_DoneAllBuild = false;
2005-01-28 00:11:44 +03:00
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 = "";
}