1 /*============================================================================
2 CMake - Cross Platform Makefile Generator
3 Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
5 Distributed under the OSI-approved BSD License (the "License");
6 see accompanying file Copyright.txt for details.
8 This software is distributed WITHOUT ANY WARRANTY; without even the
9 implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
10 See the License for more information.
11 ============================================================================*/
12 #ifndef cmGlobalXCodeGenerator_h
13 #define cmGlobalXCodeGenerator_h
15 #include "cmGlobalGenerator.h"
16 #include "cmXCodeObject.h"
17 #include "cmCustomCommand.h"
18 class cmGlobalGeneratorFactory;
24 /** \class cmGlobalXCodeGenerator
25 * \brief Write a Unix makefiles.
27 * cmGlobalXCodeGenerator manages UNIX build process for a tree
29 class cmGlobalXCodeGenerator : public cmGlobalGenerator
32 cmGlobalXCodeGenerator(std::string const& version);
33 static cmGlobalGeneratorFactory* NewFactory();
35 ///! Get the name for the generator.
36 virtual const char* GetName() const {
37 return cmGlobalXCodeGenerator::GetActualName();}
38 static const char* GetActualName() {return "Xcode";}
40 /** Get the documentation entry for this generator. */
41 static void GetDocumentation(cmDocumentationEntry& entry);
43 ///! Create a local generator appropriate to this Global Generator
44 virtual cmLocalGenerator *CreateLocalGenerator();
47 * Try to determine system infomation such as shared library
48 * extension, pthreads, byte order etc.
50 virtual void EnableLanguage(std::vector<std::string>const& languages,
51 cmMakefile *, bool optional);
53 * Try running cmake and building a file. This is used for dynalically
54 * loaded commands, not as part of the usual build process.
56 virtual std::string GenerateBuildCommand(const char* makeProgram,
57 const char *projectName,
58 const char *projectDir,
59 const char* additionalOptions,
60 const char *targetName,
66 * Generate the all required files for building this project/tree. This
67 * basically creates a series of LocalGenerators for each directory and
68 * requests that they Generate.
70 virtual void Generate();
72 /** Append the subdirectory for the given configuration. */
73 virtual void AppendDirectoryForConfig(const char* prefix,
78 ///! What is the configurations directory variable called?
79 virtual const char* GetCMakeCFGIntDir() const;
81 void SetCurrentLocalGenerator(cmLocalGenerator*);
83 /** Return true if the generated build tree may contain multiple builds.
84 i.e. "Can I build Debug and Release in the same tree?" */
85 virtual bool IsMultiConfig();
87 virtual bool SetGeneratorToolset(std::string const& ts);
88 void AppendFlag(std::string& flags, std::string const& flag);
90 cmXCodeObject* CreateOrGetPBXGroup(cmTarget& cmtarget,
92 cmXCodeObject* CreatePBXGroup(cmXCodeObject *parent,
94 void CreateGroups(cmLocalGenerator* root,
95 std::vector<cmLocalGenerator*>&
97 std::string XCodeEscapePath(const char* p);
98 std::string RelativeToSource(const char* p);
99 std::string RelativeToBinary(const char* p);
100 std::string ConvertToRelativeForXCode(const char* p);
101 std::string ConvertToRelativeForMake(const char* p);
102 void CreateCustomCommands(cmXCodeObject* buildPhases,
103 cmXCodeObject* sourceBuildPhase,
104 cmXCodeObject* headerBuildPhase,
105 cmXCodeObject* resourceBuildPhase,
106 std::vector<cmXCodeObject*> contentBuildPhases,
107 cmXCodeObject* frameworkBuildPhase,
110 std::string ComputeInfoPListLocation(cmTarget& target);
112 void AddCommandsToBuildPhase(cmXCodeObject* buildphase,
114 std::vector<cmCustomCommand>
116 const char* commandFileName);
118 void CreateCustomRulesMakefile(const char* makefileBasename,
120 std::vector<cmCustomCommand> const & commands,
121 const char* configName,
122 const std::map<cmStdString, cmStdString>&
126 cmXCodeObject* FindXCodeTarget(cmTarget*);
127 std::string GetOrCreateId(const char* name, const char* id);
129 // create cmXCodeObject from these functions so that memory can be managed
130 // correctly. All objects created are stored in this->XCodeObjects.
131 cmXCodeObject* CreateObject(cmXCodeObject::PBXType ptype);
132 cmXCodeObject* CreateObject(cmXCodeObject::Type type);
133 cmXCodeObject* CreateString(const char* s);
134 cmXCodeObject* CreateObjectReference(cmXCodeObject*);
135 cmXCodeObject* CreateXCodeTarget(cmTarget& target,
136 cmXCodeObject* buildPhases);
137 void ForceLinkerLanguages();
138 void ForceLinkerLanguage(cmTarget& cmtarget);
139 const char* GetTargetFileType(cmTarget& cmtarget);
140 const char* GetTargetProductType(cmTarget& cmtarget);
141 std::string AddConfigurations(cmXCodeObject* target, cmTarget& cmtarget);
142 void AppendOrAddBuildSetting(cmXCodeObject* settings, const char* attr,
144 void AppendBuildSettingAttribute(cmXCodeObject* target, const char* attr,
145 const char* value, const char* configName);
146 cmXCodeObject* CreateUtilityTarget(cmTarget& target);
147 void AddDependAndLinkInformation(cmXCodeObject* target);
148 void CreateBuildSettings(cmTarget& target,
149 cmXCodeObject* buildSettings,
150 const char* buildType);
151 std::string ExtractFlag(const char* flag, std::string& flags);
152 // delete all objects in the this->XCodeObjects vector.
153 void ClearXCodeObjects();
154 void CreateXCodeObjects(cmLocalGenerator* root,
155 std::vector<cmLocalGenerator*>& generators);
156 void OutputXCodeProject(cmLocalGenerator* root,
157 std::vector<cmLocalGenerator*>& generators);
158 void WriteXCodePBXProj(std::ostream& fout, cmLocalGenerator* root,
159 std::vector<cmLocalGenerator*>& generators);
160 cmXCodeObject* CreateXCodeFileReferenceFromPath(const std::string &fullpath,
162 const std::string &lang);
163 cmXCodeObject* CreateXCodeSourceFileFromPath(const std::string &fullpath,
165 const std::string &lang);
166 cmXCodeObject* CreateXCodeFileReference(cmSourceFile* sf,
168 cmXCodeObject* CreateXCodeSourceFile(cmLocalGenerator* gen,
171 void CreateXCodeTargets(cmLocalGenerator* gen,
172 std::vector<cmXCodeObject*>&);
173 bool IsHeaderFile(cmSourceFile*);
174 void AddDependTarget(cmXCodeObject* target,
175 cmXCodeObject* dependTarget);
176 void CreateXCodeDependHackTarget(std::vector<cmXCodeObject*>& targets);
177 bool SpecialTargetEmitted(std::string const& tname);
178 void SetGenerationRoot(cmLocalGenerator* root);
179 void AddExtraTargets(cmLocalGenerator* root,
180 std::vector<cmLocalGenerator*>& gens);
181 cmXCodeObject* CreateBuildPhase(const char* name,
184 const std::vector<cmCustomCommand>&);
185 void CreateReRunCMakeFile(cmLocalGenerator* root,
186 std::vector<cmLocalGenerator*> const& gens);
188 std::string LookupFlags(const char* varNamePrefix,
189 const char* varNameLang,
190 const char* varNameSuffix,
191 const char* default_flags);
194 class BuildObjectListOrString;
195 friend class BuildObjectListOrString;
197 void AppendDefines(BuildObjectListOrString& defs, const char* defines_list,
199 void AppendDefines(BuildObjectListOrString& defs,
200 std::vector<std::string> const& defines,
204 virtual const char* GetInstallTargetName() const { return "install"; }
205 virtual const char* GetPackageTargetName() const { return "package"; }
207 unsigned int XcodeVersion;
208 std::string VersionString;
209 std::set<cmStdString> XCodeObjectIDs;
210 std::vector<cmXCodeObject*> XCodeObjects;
211 cmXCodeObject* RootObject;
213 void ComputeTargetObjects(cmGeneratorTarget* gt) const;
215 std::string GetObjectsNormalDirectory(
216 const std::string &projName,
217 const std::string &configName,
218 const cmTarget *t) const;
220 void addObject(cmXCodeObject *obj);
221 std::string PostBuildMakeTarget(std::string const& tName,
222 std::string const& configName);
223 cmXCodeObject* MainGroupChildren;
224 cmXCodeObject* SourcesGroupChildren;
225 cmXCodeObject* ResourcesGroupChildren;
226 cmMakefile* CurrentMakefile;
227 cmLocalGenerator* CurrentLocalGenerator;
228 std::vector<std::string> CurrentConfigurationTypes;
229 std::string CurrentReRunCMakeMakefile;
230 std::string CurrentXCodeHackMakefile;
231 std::string CurrentProject;
232 std::set<cmStdString> TargetDoneSet;
233 std::vector<std::string> CurrentOutputDirectoryComponents;
234 std::vector<std::string> ProjectSourceDirectoryComponents;
235 std::vector<std::string> ProjectOutputDirectoryComponents;
236 std::map<cmStdString, cmXCodeObject* > GroupMap;
237 std::map<cmStdString, cmXCodeObject* > GroupNameMap;
238 std::map<cmStdString, cmXCodeObject* > TargetGroup;
239 std::map<cmStdString, cmXCodeObject* > FileRefs;
240 std::vector<std::string> Architectures;
241 std::string PlatformToolset;