2009-09-28 19:43:28 +04:00
|
|
|
/*============================================================================
|
|
|
|
CMake - Cross Platform Makefile Generator
|
|
|
|
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
|
2005-01-25 01:35:54 +03:00
|
|
|
|
2009-09-28 19:43:28 +04: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
|
|
|
|
2009-09-28 19:43:28 +04: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
|
|
|
#ifndef cmGlobalXCodeGenerator_h
|
|
|
|
#define cmGlobalXCodeGenerator_h
|
|
|
|
|
|
|
|
#include "cmGlobalGenerator.h"
|
|
|
|
#include "cmXCodeObject.h"
|
2005-02-16 01:25:40 +03:00
|
|
|
#include "cmCustomCommand.h"
|
2012-11-19 18:48:33 +04:00
|
|
|
class cmGlobalGeneratorFactory;
|
2005-01-25 01:35:54 +03:00
|
|
|
class cmTarget;
|
2005-01-28 00:11:44 +03:00
|
|
|
class cmSourceFile;
|
2005-03-17 23:35:44 +03:00
|
|
|
class cmSourceGroup;
|
|
|
|
|
2005-01-25 01:35:54 +03:00
|
|
|
|
|
|
|
/** \class cmGlobalXCodeGenerator
|
|
|
|
* \brief Write a Unix makefiles.
|
|
|
|
*
|
|
|
|
* cmGlobalXCodeGenerator manages UNIX build process for a tree
|
|
|
|
*/
|
|
|
|
class cmGlobalXCodeGenerator : public cmGlobalGenerator
|
|
|
|
{
|
|
|
|
public:
|
2015-05-24 12:31:14 +03:00
|
|
|
cmGlobalXCodeGenerator(cmake* cm, std::string const& version);
|
2012-11-19 18:48:33 +04:00
|
|
|
static cmGlobalGeneratorFactory* NewFactory();
|
2005-11-18 22:12:09 +03:00
|
|
|
|
2005-01-25 01:35:54 +03:00
|
|
|
///! Get the name for the generator.
|
2014-02-25 02:36:27 +04:00
|
|
|
virtual std::string GetName() const {
|
2005-01-25 01:35:54 +03:00
|
|
|
return cmGlobalXCodeGenerator::GetActualName();}
|
2014-02-25 02:36:27 +04:00
|
|
|
static std::string GetActualName() {return "Xcode";}
|
2005-01-25 01:35:54 +03:00
|
|
|
|
|
|
|
/** Get the documentation entry for this generator. */
|
2012-11-19 19:42:24 +04:00
|
|
|
static void GetDocumentation(cmDocumentationEntry& entry);
|
2012-08-13 21:42:58 +04:00
|
|
|
|
2005-01-25 01:35:54 +03:00
|
|
|
///! Create a local generator appropriate to this Global Generator
|
2015-08-02 12:41:51 +03:00
|
|
|
virtual cmLocalGenerator *CreateLocalGenerator(cmMakefile *mf);
|
2005-01-25 01:35:54 +03:00
|
|
|
|
|
|
|
/**
|
2014-10-10 03:22:45 +04:00
|
|
|
* Try to determine system information such as shared library
|
2012-08-13 21:42:58 +04:00
|
|
|
* extension, pthreads, byte order etc.
|
2005-01-25 01:35:54 +03:00
|
|
|
*/
|
2012-08-13 21:42:58 +04:00
|
|
|
virtual void EnableLanguage(std::vector<std::string>const& languages,
|
2007-06-28 17:09:26 +04:00
|
|
|
cmMakefile *, bool optional);
|
2005-01-25 01:35:54 +03:00
|
|
|
/**
|
|
|
|
* Try running cmake and building a file. This is used for dynalically
|
|
|
|
* loaded commands, not as part of the usual build process.
|
|
|
|
*/
|
2013-11-15 22:33:32 +04:00
|
|
|
virtual void GenerateBuildCommand(
|
|
|
|
std::vector<std::string>& makeCommand,
|
2014-02-25 02:38:55 +04:00
|
|
|
const std::string& makeProgram,
|
2014-02-08 00:40:05 +04:00
|
|
|
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,
|
2014-02-10 07:48:34 +04:00
|
|
|
const std::string& config,
|
2015-02-26 13:32:26 +03:00
|
|
|
bool fast, bool verbose,
|
2013-11-15 22:33:32 +04:00
|
|
|
std::vector<std::string> const& makeOptions = std::vector<std::string>()
|
|
|
|
);
|
2005-01-25 01:35:54 +03:00
|
|
|
|
2006-02-03 20:03:57 +03:00
|
|
|
/** Append the subdirectory for the given configuration. */
|
2014-02-22 04:05:55 +04:00
|
|
|
virtual void AppendDirectoryForConfig(const std::string& prefix,
|
2014-02-10 07:48:34 +04:00
|
|
|
const std::string& config,
|
2014-02-22 04:05:55 +04:00
|
|
|
const std::string& suffix,
|
2006-03-03 20:58:48 +03:00
|
|
|
std::string& dir);
|
2006-02-03 20:03:57 +03:00
|
|
|
|
2015-01-28 22:00:02 +03:00
|
|
|
virtual void FindMakeProgram(cmMakefile*);
|
|
|
|
|
2006-02-25 01:35:35 +03:00
|
|
|
///! What is the configurations directory variable called?
|
2012-03-09 01:18:55 +04:00
|
|
|
virtual const char* GetCMakeCFGIntDir() const;
|
2014-02-02 08:18:04 +04:00
|
|
|
///! expand CFGIntDir
|
|
|
|
virtual std::string ExpandCFGIntDir(const std::string& str,
|
|
|
|
const std::string& config) const;
|
2006-02-25 01:35:35 +03:00
|
|
|
|
2007-02-17 00:12:17 +03:00
|
|
|
void SetCurrentLocalGenerator(cmLocalGenerator*);
|
2009-12-04 20:09:01 +03:00
|
|
|
|
|
|
|
/** Return true if the generated build tree may contain multiple builds.
|
|
|
|
i.e. "Can I build Debug and Release in the same tree?" */
|
|
|
|
virtual bool IsMultiConfig();
|
|
|
|
|
2014-06-04 21:21:55 +04:00
|
|
|
virtual bool SetGeneratorToolset(std::string const& ts, cmMakefile* mf);
|
2013-06-27 19:49:06 +04:00
|
|
|
void AppendFlag(std::string& flags, std::string const& flag);
|
2014-07-22 23:01:05 +04:00
|
|
|
protected:
|
2015-09-15 21:37:57 +03:00
|
|
|
virtual void AddExtraIDETargets();
|
2014-07-22 23:01:05 +04:00
|
|
|
virtual void Generate();
|
2012-08-13 21:42:58 +04:00
|
|
|
private:
|
2005-03-17 23:35:44 +03:00
|
|
|
cmXCodeObject* CreateOrGetPBXGroup(cmTarget& cmtarget,
|
|
|
|
cmSourceGroup* sg);
|
2011-02-15 16:34:14 +03:00
|
|
|
cmXCodeObject* CreatePBXGroup(cmXCodeObject *parent,
|
2014-02-10 09:21:34 +04:00
|
|
|
std::string name);
|
2015-01-19 16:27:15 +03:00
|
|
|
bool CreateGroups(cmLocalGenerator* root,
|
2005-03-17 23:35:44 +03:00
|
|
|
std::vector<cmLocalGenerator*>&
|
|
|
|
generators);
|
2005-02-24 23:34:14 +03:00
|
|
|
std::string XCodeEscapePath(const char* p);
|
2009-09-23 00:18:31 +04:00
|
|
|
std::string RelativeToSource(const char* p);
|
|
|
|
std::string RelativeToBinary(const char* p);
|
2005-02-25 01:46:49 +03:00
|
|
|
std::string ConvertToRelativeForXCode(const char* p);
|
|
|
|
std::string ConvertToRelativeForMake(const char* p);
|
2005-02-16 01:25:40 +03:00
|
|
|
void CreateCustomCommands(cmXCodeObject* buildPhases,
|
|
|
|
cmXCodeObject* sourceBuildPhase,
|
|
|
|
cmXCodeObject* headerBuildPhase,
|
2007-08-14 19:45:15 +04:00
|
|
|
cmXCodeObject* resourceBuildPhase,
|
|
|
|
std::vector<cmXCodeObject*> contentBuildPhases,
|
2005-02-16 01:25:40 +03:00
|
|
|
cmXCodeObject* frameworkBuildPhase,
|
|
|
|
cmTarget& cmtarget);
|
2007-08-14 19:45:15 +04:00
|
|
|
|
2008-07-03 21:28:54 +04:00
|
|
|
std::string ComputeInfoPListLocation(cmTarget& target);
|
|
|
|
|
2005-02-16 01:25:40 +03:00
|
|
|
void AddCommandsToBuildPhase(cmXCodeObject* buildphase,
|
|
|
|
cmTarget& target,
|
2012-08-13 21:42:58 +04:00
|
|
|
std::vector<cmCustomCommand>
|
2005-02-16 01:25:40 +03:00
|
|
|
const & commands,
|
|
|
|
const char* commandFileName);
|
2012-08-13 21:42:58 +04:00
|
|
|
|
|
|
|
void CreateCustomRulesMakefile(const char* makefileBasename,
|
2007-05-09 16:25:45 +04:00
|
|
|
cmTarget& target,
|
2007-05-10 19:38:23 +04:00
|
|
|
std::vector<cmCustomCommand> const & commands,
|
2014-12-05 17:50:31 +03:00
|
|
|
const std::string& configName);
|
2012-08-13 21:42:58 +04:00
|
|
|
|
2013-12-10 18:16:23 +04:00
|
|
|
cmXCodeObject* FindXCodeTarget(cmTarget const*);
|
2014-02-07 02:31:47 +04:00
|
|
|
std::string GetOrCreateId(const std::string& name, const std::string& id);
|
2011-08-24 02:22:33 +04:00
|
|
|
|
2005-01-25 23:26:57 +03:00
|
|
|
// create cmXCodeObject from these functions so that memory can be managed
|
2006-03-15 19:02:08 +03:00
|
|
|
// correctly. All objects created are stored in this->XCodeObjects.
|
2005-01-28 00:11:44 +03:00
|
|
|
cmXCodeObject* CreateObject(cmXCodeObject::PBXType ptype);
|
|
|
|
cmXCodeObject* CreateObject(cmXCodeObject::Type type);
|
2014-02-04 06:16:12 +04:00
|
|
|
cmXCodeObject* CreateString(const std::string& s);
|
2005-01-29 00:00:10 +03:00
|
|
|
cmXCodeObject* CreateObjectReference(cmXCodeObject*);
|
2005-02-03 01:16:07 +03:00
|
|
|
cmXCodeObject* CreateXCodeTarget(cmTarget& target,
|
|
|
|
cmXCodeObject* buildPhases);
|
2009-07-11 00:51:44 +04:00
|
|
|
void ForceLinkerLanguages();
|
2015-10-21 21:38:10 +03:00
|
|
|
void ForceLinkerLanguage(cmGeneratorTarget* gtgt);
|
2014-07-28 19:41:53 +04:00
|
|
|
const char* GetTargetLinkFlagsVar(cmTarget const& cmtarget) const;
|
2015-10-17 16:20:23 +03:00
|
|
|
const char* GetTargetFileType(cmGeneratorTarget* target);
|
|
|
|
const char* GetTargetProductType(cmGeneratorTarget* target);
|
2009-07-02 22:14:03 +04:00
|
|
|
std::string AddConfigurations(cmXCodeObject* target, cmTarget& cmtarget);
|
2012-08-13 21:42:58 +04:00
|
|
|
void AppendOrAddBuildSetting(cmXCodeObject* settings, const char* attr,
|
2005-09-08 22:35:37 +04:00
|
|
|
const char* value);
|
2012-08-13 21:42:58 +04:00
|
|
|
void AppendBuildSettingAttribute(cmXCodeObject* target, const char* attr,
|
2014-02-10 07:48:34 +04:00
|
|
|
const char* value,
|
|
|
|
const std::string& configName);
|
2005-02-04 01:42:55 +03:00
|
|
|
cmXCodeObject* CreateUtilityTarget(cmTarget& target);
|
|
|
|
void AddDependAndLinkInformation(cmXCodeObject* target);
|
2005-02-03 01:16:07 +03:00
|
|
|
void CreateBuildSettings(cmTarget& target,
|
|
|
|
cmXCodeObject* buildSettings,
|
2014-02-10 07:48:34 +04:00
|
|
|
const std::string& buildType);
|
2005-09-03 00:29:32 +04:00
|
|
|
std::string ExtractFlag(const char* flag, std::string& flags);
|
2015-04-07 20:14:52 +03:00
|
|
|
void SortXCodeObjects();
|
2006-03-15 19:02:08 +03:00
|
|
|
// delete all objects in the this->XCodeObjects vector.
|
2005-01-25 01:35:54 +03:00
|
|
|
void ClearXCodeObjects();
|
2015-01-19 16:27:15 +03:00
|
|
|
bool CreateXCodeObjects(cmLocalGenerator* root,
|
2005-01-25 01:35:54 +03:00
|
|
|
std::vector<cmLocalGenerator*>& generators);
|
|
|
|
void OutputXCodeProject(cmLocalGenerator* root,
|
|
|
|
std::vector<cmLocalGenerator*>& generators);
|
2009-09-19 20:00:09 +04:00
|
|
|
void WriteXCodePBXProj(std::ostream& fout, cmLocalGenerator* root,
|
|
|
|
std::vector<cmLocalGenerator*>& generators);
|
2012-03-15 20:05:31 +04:00
|
|
|
cmXCodeObject* CreateXCodeFileReferenceFromPath(const std::string &fullpath,
|
|
|
|
cmTarget& cmtarget,
|
2014-05-15 21:50:53 +04:00
|
|
|
const std::string &lang,
|
|
|
|
cmSourceFile* sf);
|
2012-03-15 20:05:31 +04:00
|
|
|
cmXCodeObject* CreateXCodeSourceFileFromPath(const std::string &fullpath,
|
|
|
|
cmTarget& cmtarget,
|
2014-05-15 21:50:53 +04:00
|
|
|
const std::string &lang,
|
|
|
|
cmSourceFile* sf);
|
2008-10-10 16:11:08 +04:00
|
|
|
cmXCodeObject* CreateXCodeFileReference(cmSourceFile* sf,
|
|
|
|
cmTarget& cmtarget);
|
2012-08-13 21:42:58 +04:00
|
|
|
cmXCodeObject* CreateXCodeSourceFile(cmLocalGenerator* gen,
|
2006-01-25 16:38:06 +03:00
|
|
|
cmSourceFile* sf,
|
|
|
|
cmTarget& cmtarget);
|
2015-01-19 16:27:15 +03:00
|
|
|
bool CreateXCodeTargets(cmLocalGenerator* gen,
|
2006-05-11 23:39:46 +04:00
|
|
|
std::vector<cmXCodeObject*>&);
|
2009-03-16 21:30:24 +03:00
|
|
|
bool IsHeaderFile(cmSourceFile*);
|
2005-02-04 01:42:55 +03:00
|
|
|
void AddDependTarget(cmXCodeObject* target,
|
|
|
|
cmXCodeObject* dependTarget);
|
2005-02-18 01:54:14 +03:00
|
|
|
void CreateXCodeDependHackTarget(std::vector<cmXCodeObject*>& targets);
|
2005-02-18 21:32:51 +03:00
|
|
|
bool SpecialTargetEmitted(std::string const& tname);
|
2007-05-11 21:52:33 +04:00
|
|
|
void SetGenerationRoot(cmLocalGenerator* root);
|
2012-08-13 21:42:58 +04:00
|
|
|
void AddExtraTargets(cmLocalGenerator* root,
|
2005-02-18 21:32:51 +03:00
|
|
|
std::vector<cmLocalGenerator*>& gens);
|
2012-08-13 21:42:58 +04:00
|
|
|
cmXCodeObject* CreateBuildPhase(const char* name,
|
2005-02-28 23:07:13 +03:00
|
|
|
const char* name2,
|
|
|
|
cmTarget& cmtarget,
|
|
|
|
const std::vector<cmCustomCommand>&);
|
2011-01-13 20:07:23 +03:00
|
|
|
void CreateReRunCMakeFile(cmLocalGenerator* root,
|
|
|
|
std::vector<cmLocalGenerator*> const& gens);
|
2006-02-24 21:13:14 +03:00
|
|
|
|
2014-02-04 06:20:56 +04:00
|
|
|
std::string LookupFlags(const std::string& varNamePrefix,
|
|
|
|
const std::string& varNameLang,
|
|
|
|
const std::string& varNameSuffix,
|
|
|
|
const std::string& default_flags);
|
2007-02-17 00:12:17 +03:00
|
|
|
|
2012-11-19 18:48:33 +04:00
|
|
|
class Factory;
|
2009-06-29 21:02:05 +04:00
|
|
|
class BuildObjectListOrString;
|
|
|
|
friend class BuildObjectListOrString;
|
|
|
|
|
|
|
|
void AppendDefines(BuildObjectListOrString& defs, const char* defines_list,
|
2008-01-14 17:20:58 +03:00
|
|
|
bool dflag = false);
|
2009-07-30 00:40:07 +04:00
|
|
|
void AppendDefines(BuildObjectListOrString& defs,
|
|
|
|
std::vector<std::string> const& defines,
|
|
|
|
bool dflag = false);
|
2008-01-14 17:20:58 +03:00
|
|
|
|
2014-03-13 00:09:20 +04:00
|
|
|
void ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const;
|
2005-07-20 00:40:44 +04:00
|
|
|
protected:
|
2011-10-07 16:22:05 +04:00
|
|
|
virtual const char* GetInstallTargetName() const { return "install"; }
|
|
|
|
virtual const char* GetPackageTargetName() const { return "package"; }
|
2006-03-01 16:28:39 +03:00
|
|
|
|
2009-09-23 16:48:39 +04:00
|
|
|
unsigned int XcodeVersion;
|
|
|
|
std::string VersionString;
|
2014-02-10 09:21:34 +04:00
|
|
|
std::set<std::string> XCodeObjectIDs;
|
2006-03-15 19:02:08 +03:00
|
|
|
std::vector<cmXCodeObject*> XCodeObjects;
|
|
|
|
cmXCodeObject* RootObject;
|
2005-09-03 00:29:32 +04:00
|
|
|
private:
|
2015-01-28 21:31:18 +03:00
|
|
|
std::string const& GetXcodeBuildCommand();
|
|
|
|
std::string FindXcodeBuildCommand();
|
|
|
|
std::string XcodeBuildCommand;
|
|
|
|
bool XcodeBuildCommandInitialized;
|
|
|
|
|
2014-02-04 06:20:56 +04:00
|
|
|
void PrintCompilerAdvice(std::ostream&, std::string const&,
|
|
|
|
const char*) const {}
|
2012-03-14 00:41:28 +04:00
|
|
|
|
2012-03-15 01:46:56 +04:00
|
|
|
std::string GetObjectsNormalDirectory(
|
|
|
|
const std::string &projName,
|
|
|
|
const std::string &configName,
|
|
|
|
const cmTarget *t) const;
|
|
|
|
|
2011-08-24 02:22:33 +04:00
|
|
|
void addObject(cmXCodeObject *obj);
|
2011-06-07 01:34:43 +04:00
|
|
|
std::string PostBuildMakeTarget(std::string const& tName,
|
|
|
|
std::string const& configName);
|
2006-03-15 19:02:08 +03:00
|
|
|
cmXCodeObject* MainGroupChildren;
|
|
|
|
cmXCodeObject* SourcesGroupChildren;
|
2007-08-14 19:45:15 +04:00
|
|
|
cmXCodeObject* ResourcesGroupChildren;
|
2006-03-15 19:02:08 +03:00
|
|
|
cmMakefile* CurrentMakefile;
|
|
|
|
cmLocalGenerator* CurrentLocalGenerator;
|
|
|
|
std::vector<std::string> CurrentConfigurationTypes;
|
|
|
|
std::string CurrentReRunCMakeMakefile;
|
|
|
|
std::string CurrentXCodeHackMakefile;
|
|
|
|
std::string CurrentProject;
|
2014-02-10 09:21:34 +04:00
|
|
|
std::set<std::string> TargetDoneSet;
|
2006-03-15 19:02:08 +03:00
|
|
|
std::vector<std::string> CurrentOutputDirectoryComponents;
|
2009-09-23 00:18:31 +04:00
|
|
|
std::vector<std::string> ProjectSourceDirectoryComponents;
|
2006-03-15 19:02:08 +03:00
|
|
|
std::vector<std::string> ProjectOutputDirectoryComponents;
|
2014-02-10 09:21:34 +04:00
|
|
|
std::map<std::string, cmXCodeObject* > GroupMap;
|
|
|
|
std::map<std::string, cmXCodeObject* > GroupNameMap;
|
|
|
|
std::map<std::string, cmXCodeObject* > TargetGroup;
|
|
|
|
std::map<std::string, cmXCodeObject* > FileRefs;
|
2014-12-01 20:56:46 +03:00
|
|
|
std::map<cmTarget const*, cmXCodeObject* > XCodeObjectMap;
|
2006-05-16 17:54:49 +04:00
|
|
|
std::vector<std::string> Architectures;
|
2014-06-04 21:07:08 +04:00
|
|
|
std::string GeneratorToolset;
|
2005-01-25 01:35:54 +03:00
|
|
|
};
|
|
|
|
|
|
|
|
#endif
|