CMake/Source/cmGlobalXCodeGenerator.h

262 lines
12 KiB
C
Raw Normal View History

/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
2005-01-25 01:35:54 +03:00
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
2005-01-25 01:35:54 +03:00
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
2005-01-25 01:35:54 +03:00
#ifndef cmGlobalXCodeGenerator_h
#define cmGlobalXCodeGenerator_h
#include "cmGlobalGenerator.h"
#include "cmCustomCommand.h"
#include "cmXCodeObject.h"
class cmGlobalGeneratorFactory;
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:
cmGlobalXCodeGenerator(cmake* cm, std::string const& version);
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.
virtual std::string GetName() const {
2005-01-25 01:35:54 +03:00
return cmGlobalXCodeGenerator::GetActualName();}
static std::string GetActualName() {return "Xcode";}
2005-01-25 01:35:54 +03:00
/** Get the documentation entry for this generator. */
static void GetDocumentation(cmDocumentationEntry& entry);
2005-01-25 01:35:54 +03:00
///! Create a local generator appropriate to this Global Generator
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
* extension, pthreads, byte order etc.
2005-01-25 01:35:54 +03:00
*/
virtual void EnableLanguage(std::vector<std::string>const& languages,
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.
*/
virtual void GenerateBuildCommand(
std::vector<std::string>& makeCommand,
const std::string& makeProgram,
const std::string& projectName,
2014-02-25 02:38:30 +04:00
const std::string& projectDir,
2014-02-07 02:31:47 +04:00
const std::string& targetName,
const std::string& config,
bool fast, bool verbose,
std::vector<std::string> const& makeOptions = std::vector<std::string>()
);
2005-01-25 01:35:54 +03:00
/** Append the subdirectory for the given configuration. */
virtual void AppendDirectoryForConfig(const std::string& prefix,
const std::string& config,
const std::string& suffix,
std::string& dir);
virtual void FindMakeProgram(cmMakefile*);
2006-02-25 01:35:35 +03:00
///! What is the configurations directory variable called?
virtual const char* GetCMakeCFGIntDir() const;
///! expand CFGIntDir
virtual std::string ExpandCFGIntDir(const std::string& str,
const std::string& config) const;
2006-02-25 01:35:35 +03:00
void SetCurrentLocalGenerator(cmLocalGenerator*);
/** 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();
virtual bool SetGeneratorToolset(std::string const& ts, cmMakefile* mf);
void AppendFlag(std::string& flags, std::string const& flag);
protected:
virtual void AddExtraIDETargets();
virtual void Generate();
private:
2015-10-19 22:23:29 +03:00
cmXCodeObject* CreateOrGetPBXGroup(cmGeneratorTarget* gtgt,
2005-03-17 23:35:44 +03:00
cmSourceGroup* sg);
cmXCodeObject* CreatePBXGroup(cmXCodeObject *parent,
std::string name);
bool CreateGroups(cmLocalGenerator* root,
2005-03-17 23:35:44 +03:00
std::vector<cmLocalGenerator*>&
generators);
std::string XCodeEscapePath(const std::string& p);
std::string RelativeToSource(const char* p);
std::string RelativeToBinary(const char* p);
2005-02-25 01:46:49 +03:00
std::string ConvertToRelativeForMake(const char* p);
void CreateCustomCommands(cmXCodeObject* buildPhases,
cmXCodeObject* sourceBuildPhase,
cmXCodeObject* headerBuildPhase,
cmXCodeObject* resourceBuildPhase,
std::vector<cmXCodeObject*> contentBuildPhases,
cmXCodeObject* frameworkBuildPhase,
2015-10-19 22:23:29 +03:00
cmGeneratorTarget *gtgt);
2015-10-19 22:23:29 +03:00
std::string ComputeInfoPListLocation(cmGeneratorTarget *target);
void AddCommandsToBuildPhase(cmXCodeObject* buildphase,
2015-10-19 22:23:29 +03:00
cmGeneratorTarget *target,
std::vector<cmCustomCommand>
const & commands,
const char* commandFileName);
void CreateCustomRulesMakefile(const char* makefileBasename,
2015-10-19 22:23:29 +03:00
cmGeneratorTarget* target,
2007-05-10 19:38:23 +04:00
std::vector<cmCustomCommand> const & commands,
const std::string& configName);
2015-10-19 22:23:29 +03:00
cmXCodeObject* FindXCodeTarget(const cmGeneratorTarget *);
2014-02-07 02:31:47 +04:00
std::string GetOrCreateId(const std::string& name, const std::string& id);
// 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);
cmXCodeObject* CreateString(const std::string& s);
2005-01-29 00:00:10 +03:00
cmXCodeObject* CreateObjectReference(cmXCodeObject*);
cmXCodeObject* CreateFlatClone(cmXCodeObject*);
2015-10-19 22:23:29 +03:00
cmXCodeObject* CreateXCodeTarget(cmGeneratorTarget *gtgt,
2005-02-03 01:16:07 +03:00
cmXCodeObject* buildPhases);
void ForceLinkerLanguages();
void ForceLinkerLanguage(cmGeneratorTarget* gtgt);
2015-10-19 22:23:29 +03:00
const char* GetTargetLinkFlagsVar(const cmGeneratorTarget *target) const;
const char* GetTargetFileType(cmGeneratorTarget* target);
const char* GetTargetProductType(cmGeneratorTarget* target);
2015-10-19 22:23:29 +03:00
std::string AddConfigurations(cmXCodeObject* target,
cmGeneratorTarget *gtgt);
void AppendOrAddBuildSetting(cmXCodeObject* settings, const char* attr,
const char* value);
void AppendBuildSettingAttribute(cmXCodeObject* target, const char* attr,
const char* value,
const std::string& configName);
2015-10-19 22:23:29 +03:00
cmXCodeObject* CreateUtilityTarget(cmGeneratorTarget *gtgt);
2005-02-04 01:42:55 +03:00
void AddDependAndLinkInformation(cmXCodeObject* target);
2015-10-19 22:23:29 +03:00
void CreateBuildSettings(cmGeneratorTarget *gtgt,
2005-02-03 01:16:07 +03:00
cmXCodeObject* buildSettings,
const std::string& buildType);
2005-09-03 00:29:32 +04:00
std::string ExtractFlag(const char* flag, std::string& flags);
std::string ExtractFlagRegex(const char* exp, int matchIndex,
std::string& flags);
void FilterConfigurationAttribute(std::string const& configName,
std::string& attribute);
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();
bool CreateXCodeObjects(cmLocalGenerator* root,
2005-01-25 01:35:54 +03:00
std::vector<cmLocalGenerator*>& generators);
void OutputXCodeProject(cmLocalGenerator* root,
std::vector<cmLocalGenerator*>& generators);
void WriteXCodePBXProj(std::ostream& fout, cmLocalGenerator* root,
std::vector<cmLocalGenerator*>& generators);
cmXCodeObject* CreateXCodeFileReferenceFromPath(const std::string &fullpath,
2015-10-19 22:23:29 +03:00
cmGeneratorTarget *target,
const std::string &lang,
cmSourceFile* sf);
cmXCodeObject* CreateXCodeSourceFileFromPath(const std::string &fullpath,
2015-10-19 22:23:29 +03:00
cmGeneratorTarget *target,
const std::string &lang,
cmSourceFile* sf);
2008-10-10 16:11:08 +04:00
cmXCodeObject* CreateXCodeFileReference(cmSourceFile* sf,
2015-10-19 22:23:29 +03:00
cmGeneratorTarget *target);
cmXCodeObject* CreateXCodeSourceFile(cmLocalGenerator* gen,
2006-01-25 16:38:06 +03:00
cmSourceFile* sf,
2015-10-19 22:23:29 +03:00
cmGeneratorTarget *gtgt);
bool CreateXCodeTargets(cmLocalGenerator* gen,
2006-05-11 23:39:46 +04:00
std::vector<cmXCodeObject*>&);
bool IsHeaderFile(cmSourceFile*);
2005-02-04 01:42:55 +03:00
void AddDependTarget(cmXCodeObject* target,
cmXCodeObject* dependTarget);
void CreateXCodeDependHackTarget(std::vector<cmXCodeObject*>& targets);
2005-02-18 21:32:51 +03:00
bool SpecialTargetEmitted(std::string const& tname);
void SetGenerationRoot(cmLocalGenerator* root);
void AddExtraTargets(cmLocalGenerator* root,
2005-02-18 21:32:51 +03:00
std::vector<cmLocalGenerator*>& gens);
cmXCodeObject* CreateBuildPhase(const char* name,
2005-02-28 23:07:13 +03:00
const char* name2,
2015-10-19 22:23:29 +03:00
cmGeneratorTarget *target,
2005-02-28 23:07:13 +03:00
const std::vector<cmCustomCommand>&);
void CreateReRunCMakeFile(cmLocalGenerator* root,
std::vector<cmLocalGenerator*> const& gens);
std::string LookupFlags(const std::string& varNamePrefix,
const std::string& varNameLang,
const std::string& varNameSuffix,
const std::string& default_flags);
class Factory;
class BuildObjectListOrString;
friend class BuildObjectListOrString;
void AppendDefines(BuildObjectListOrString& defs, const char* defines_list,
bool dflag = false);
void AppendDefines(BuildObjectListOrString& defs,
std::vector<std::string> const& defines,
bool dflag = false);
void ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const;
protected:
virtual const char* GetInstallTargetName() const { return "install"; }
virtual const char* GetPackageTargetName() const { return "package"; }
unsigned int XcodeVersion;
std::string VersionString;
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:
std::string const& GetXcodeBuildCommand();
std::string FindXcodeBuildCommand();
std::string XcodeBuildCommand;
bool XcodeBuildCommandInitialized;
void PrintCompilerAdvice(std::ostream&, std::string const&,
const char*) const {}
2015-10-19 22:23:29 +03:00
std::string GetObjectsNormalDirectory(const std::string &projName,
const std::string &configName,
2015-10-19 22:23:29 +03:00
const cmGeneratorTarget *t) const;
void addObject(cmXCodeObject *obj);
std::string PostBuildMakeTarget(std::string const& tName,
std::string const& configName);
2006-03-15 19:02:08 +03:00
cmXCodeObject* MainGroupChildren;
cmXCodeObject* SourcesGroupChildren;
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;
std::set<std::string> TargetDoneSet;
2006-03-15 19:02:08 +03:00
std::vector<std::string> CurrentOutputDirectoryComponents;
std::vector<std::string> ProjectSourceDirectoryComponents;
2006-03-15 19:02:08 +03:00
std::vector<std::string> ProjectOutputDirectoryComponents;
std::map<std::string, cmXCodeObject* > GroupMap;
std::map<std::string, cmXCodeObject* > GroupNameMap;
std::map<std::string, cmXCodeObject* > TargetGroup;
std::map<std::string, cmXCodeObject* > FileRefs;
2015-10-19 22:23:29 +03:00
std::map<cmGeneratorTarget const*, cmXCodeObject* > XCodeObjectMap;
std::vector<std::string> Architectures;
std::string GeneratorToolset;
2005-01-25 01:35:54 +03:00
};
#endif