CMake/Source/cmGlobalXCodeGenerator.h

170 lines
7.1 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.
=========================================================================*/
#ifndef cmGlobalXCodeGenerator_h
#define cmGlobalXCodeGenerator_h
#include "cmGlobalGenerator.h"
#include "cmXCodeObject.h"
#include "cmCustomCommand.h"
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:
cmGlobalXCodeGenerator();
static cmGlobalGenerator* New();
2005-11-18 22:12:09 +03:00
void SetVersion(int v) { m_XcodeVersion = v;}
2005-01-25 01:35:54 +03:00
///! Get the name for the generator.
virtual const char* GetName() const {
return cmGlobalXCodeGenerator::GetActualName();}
static const char* GetActualName() {return "Xcode";}
2005-01-25 01:35:54 +03:00
/** Get the documentation entry for this generator. */
virtual void GetDocumentation(cmDocumentationEntry& entry) const;
///! Create a local generator appropriate to this Global Generator
virtual cmLocalGenerator *CreateLocalGenerator();
/**
* Try to determine system infomation such as shared library
* extension, pthreads, byte order etc.
*/
2005-02-03 01:16:07 +03:00
virtual void EnableLanguage(std::vector<std::string>const& languages,
cmMakefile *);
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 std::string GenerateBuildCommand(const char* makeProgram,
const char *projectName, const char* additionalOptions, const char *targetName,
const char* config, bool ignoreErrors);
2005-01-25 01:35:54 +03:00
/**
* Generate the all required files for building this project/tree. This
* basically creates a series of LocalGenerators for each directory and
* requests that they Generate.
*/
virtual void Generate();
2005-02-18 21:32:51 +03:00
private:
2005-03-17 23:35:44 +03:00
cmXCodeObject* CreateOrGetPBXGroup(cmTarget& cmtarget,
cmSourceGroup* sg);
void CreateGroups(cmLocalGenerator* root,
std::vector<cmLocalGenerator*>&
generators);
2005-02-25 01:46:49 +03:00
void SetCurrentLocalGenerator(cmLocalGenerator*);
2005-02-24 23:34:14 +03:00
std::string XCodeEscapePath(const char* p);
2005-02-25 01:46:49 +03:00
std::string ConvertToRelativeForXCode(const char* p);
std::string ConvertToRelativeForMake(const char* p);
void CreateCustomCommands(cmXCodeObject* buildPhases,
cmXCodeObject* sourceBuildPhase,
cmXCodeObject* headerBuildPhase,
cmXCodeObject* frameworkBuildPhase,
cmTarget& cmtarget);
void AddCommandsToBuildPhase(cmXCodeObject* buildphase,
cmTarget& target,
std::vector<cmCustomCommand>
const & commands,
const char* commandFileName);
2005-02-04 01:42:55 +03:00
cmXCodeObject* FindXCodeTarget(cmTarget*);
// create cmXCodeObject from these functions so that memory can be managed
// correctly. All objects created are stored in m_XCodeObjects.
2005-01-28 00:11:44 +03:00
cmXCodeObject* CreateObject(cmXCodeObject::PBXType ptype);
cmXCodeObject* CreateObject(cmXCodeObject::Type type);
cmXCodeObject* CreateString(const char* 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);
2005-09-03 00:29:32 +04:00
void AddConfigurations(cmXCodeObject* target,
cmTarget& cmtarget);
void AppendOrAddBuildSetting(cmXCodeObject* settings, const char* attr,
const char* value);
2005-09-03 00:29:32 +04:00
void AppendBuildSettingAttribute(cmXCodeObject* target, const char* attr,
const char* value);
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,
std::string& fileType,
std::string& productType,
2005-09-03 00:29:32 +04:00
std::string& projectName,
const char* buildType);
std::string ExtractFlag(const char* flag, std::string& flags);
// delete all objects in the m_XCodeObjects vector.
2005-01-25 01:35:54 +03:00
void ClearXCodeObjects();
void CreateXCodeObjects(cmLocalGenerator* root,
std::vector<cmLocalGenerator*>& generators);
void OutputXCodeProject(cmLocalGenerator* root,
std::vector<cmLocalGenerator*>& generators);
2005-09-03 00:29:32 +04:00
virtual void WriteXCodePBXProj(std::ostream& fout,
cmLocalGenerator* root,
std::vector<cmLocalGenerator*>& generators);
2005-02-09 01:12:38 +03:00
cmXCodeObject* CreateXCodeSourceFile(cmLocalGenerator* gen,
cmSourceFile* sf);
void CreateXCodeTargets(cmLocalGenerator* gen, std::vector<cmXCodeObject*>&);
2005-02-04 01:42:55 +03:00
void AddDependTarget(cmXCodeObject* target,
cmXCodeObject* dependTarget);
2005-02-11 22:25:05 +03:00
void AddLinkLibrary(cmXCodeObject* target,
const char* lib, cmTarget* dtarget = 0);
2005-02-15 00:46:32 +03:00
void ConfigureOutputPaths();
void CreateXCodeDependHackTarget(std::vector<cmXCodeObject*>& targets);
std::string GetTargetFullPath(cmTarget*);
2005-02-18 21:32:51 +03:00
bool SpecialTargetEmitted(std::string const& tname);
void AddExtraTargets(cmLocalGenerator* root,
std::vector<cmLocalGenerator*>& gens);
2005-02-28 23:07:13 +03:00
cmXCodeObject* CreateBuildPhase(const char* name,
const char* name2,
cmTarget& cmtarget,
const std::vector<cmCustomCommand>&);
void CreateReRunCMakeFile(cmLocalGenerator* root);
protected:
std::string AddConfigDir(const char* d);
int m_XcodeVersion;
2005-01-25 01:35:54 +03:00
std::vector<cmXCodeObject*> m_XCodeObjects;
cmXCodeObject* m_RootObject;
2005-09-03 00:29:32 +04:00
private:
2005-02-09 01:12:38 +03:00
cmXCodeObject* m_MainGroupChildren;
2005-02-15 00:46:32 +03:00
cmXCodeObject* m_SourcesGroupChildren;
2005-02-02 01:17:12 +03:00
cmMakefile* m_CurrentMakefile;
2005-02-03 01:16:07 +03:00
cmLocalGenerator* m_CurrentLocalGenerator;
2005-02-28 23:07:13 +03:00
std::string m_CurrentReRunCMakeMakefile;
std::string m_CurrentXCodeHackMakefile;
std::string m_CurrentProject;
2005-02-25 01:46:49 +03:00
std::string m_OutputDir;
2005-03-17 23:35:44 +03:00
std::string m_LibraryOutputPath;
std::string m_ExecutableOutputPath;
std::set<cmStdString> m_TargetDoneSet;
2005-02-25 01:46:49 +03:00
std::vector<std::string> m_CurrentOutputDirectoryComponents;
std::vector<std::string> m_ProjectOutputDirectoryComponents;
2005-03-17 23:35:44 +03:00
std::map<cmSourceFile*, cmXCodeObject* > m_GroupMap;
std::map<cmStdString, cmXCodeObject* > m_GroupNameMap;
std::map<cmStdString, cmXCodeObject* > m_TargetGroup;
2005-01-25 01:35:54 +03:00
};
#endif