Source/cmGlobalXCodeGenerator.h

   1 /*============================================================================
   2   CMake - Cross Platform Makefile Generator
   3   Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
   4
   5   Distributed under the OSI-approved BSD License (the "License");
   6   see accompanying file Copyright.txt for details.
   7
   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
  14
  15 #include "cmGlobalGenerator.h"
  16 #include "cmXCodeObject.h"
  17 #include "cmCustomCommand.h"
  18 class cmGlobalGeneratorFactory;
  19 class cmTarget;
  20 class cmSourceFile;
  21 class cmSourceGroup;
  22
  23
  24 /** \class cmGlobalXCodeGenerator
  25  * \brief Write a Unix makefiles.
  26  *
  27  * cmGlobalXCodeGenerator manages UNIX build process for a tree
  28  */
  29 class cmGlobalXCodeGenerator : public cmGlobalGenerator
  30 {
  31 public:
  32   cmGlobalXCodeGenerator(std::string const& version);
  33   static cmGlobalGeneratorFactory* NewFactory();
  34
  35   ///! Get the name for the generator.
  36   virtual const char* GetName() const {
  37     return cmGlobalXCodeGenerator::GetActualName();}
  38   static const char* GetActualName() {return "Xcode";}
  39
  40   /** Get the documentation entry for this generator.  */
  41   static void GetDocumentation(cmDocumentationEntry& entry);
  42
  43   ///! Create a local generator appropriate to this Global Generator
  44   virtual cmLocalGenerator *CreateLocalGenerator();
  45
  46   /**
  47    * Try to determine system infomation such as shared library
  48    * extension, pthreads, byte order etc.
  49    */
  50   virtual void EnableLanguage(std::vector<std::string>const& languages,
  51                               cmMakefile *, bool optional);
  52   /**
  53    * Try running cmake and building a file. This is used for dynalically
  54    * loaded commands, not as part of the usual build process.
  55    */
  56   virtual std::string GenerateBuildCommand(const char* makeProgram,
  57                                            const char *projectName,
  58                                            const char *projectDir,
  59                                            const char* additionalOptions,
  60                                            const char *targetName,
  61                                            const char* config,
  62                                            bool ignoreErrors,
  63                                            bool fast);
  64
  65   /**
  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.
  69    */
  70   virtual void Generate();
  71
  72   /** Append the subdirectory for the given configuration.  */
  73   virtual void AppendDirectoryForConfig(const char* prefix,
  74                                         const char* config,
  75                                         const char* suffix,
  76                                         std::string& dir);
  77
  78   ///! What is the configurations directory variable called?
  79   virtual const char* GetCMakeCFGIntDir() const;
  80
  81   void SetCurrentLocalGenerator(cmLocalGenerator*);
  82
  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();
  86
  87   virtual bool SetGeneratorToolset(std::string const& ts);
  88   void AppendFlag(std::string& flags, std::string const& flag);
  89 private:
  90   cmXCodeObject* CreateOrGetPBXGroup(cmTarget& cmtarget,
  91                                      cmSourceGroup* sg);
  92   cmXCodeObject* CreatePBXGroup(cmXCodeObject *parent,
  93                                 cmStdString name);
  94   void CreateGroups(cmLocalGenerator* root,
  95                     std::vector<cmLocalGenerator*>&
  96                     generators);
  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,
 108                             cmTarget& cmtarget);
 109
 110   std::string ComputeInfoPListLocation(cmTarget& target);
 111
 112   void AddCommandsToBuildPhase(cmXCodeObject* buildphase,
 113                                cmTarget& target,
 114                                std::vector<cmCustomCommand>
 115                                const & commands,
 116                                const char* commandFileName);
 117
 118   void CreateCustomRulesMakefile(const char* makefileBasename,
 119                                  cmTarget& target,
 120                                  std::vector<cmCustomCommand> const & commands,
 121                                  const char* configName,
 122                                  const std::map<cmStdString, cmStdString>&
 123                                      multipleOutputPairs
 124                                 );
 125
 126   cmXCodeObject* FindXCodeTarget(cmTarget*);
 127   std::string GetOrCreateId(const char* name, const char* id);
 128
 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,
 143                                const char* value);
 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,
 161                                                   cmTarget& cmtarget,
 162                                                   const std::string &lang);
 163   cmXCodeObject* CreateXCodeSourceFileFromPath(const std::string &fullpath,
 164                                                cmTarget& cmtarget,
 165                                                const std::string &lang);
 166   cmXCodeObject* CreateXCodeFileReference(cmSourceFile* sf,
 167                                           cmTarget& cmtarget);
 168   cmXCodeObject* CreateXCodeSourceFile(cmLocalGenerator* gen,
 169                                        cmSourceFile* sf,
 170                                        cmTarget& cmtarget);
 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,
 182                                   const char* name2,
 183                                   cmTarget& cmtarget,
 184                                   const std::vector<cmCustomCommand>&);
 185   void CreateReRunCMakeFile(cmLocalGenerator* root,
 186                             std::vector<cmLocalGenerator*> const& gens);
 187
 188   std::string LookupFlags(const char* varNamePrefix,
 189                           const char* varNameLang,
 190                           const char* varNameSuffix,
 191                           const char* default_flags);
 192
 193   class Factory;
 194   class BuildObjectListOrString;
 195   friend class BuildObjectListOrString;
 196
 197   void AppendDefines(BuildObjectListOrString& defs, const char* defines_list,
 198                      bool dflag = false);
 199   void AppendDefines(BuildObjectListOrString& defs,
 200                      std::vector<std::string> const& defines,
 201                      bool dflag = false);
 202
 203 protected:
 204   virtual const char* GetInstallTargetName() const { return "install"; }
 205   virtual const char* GetPackageTargetName() const { return "package"; }
 206
 207   unsigned int XcodeVersion;
 208   std::string VersionString;
 209   std::set<cmStdString> XCodeObjectIDs;
 210   std::vector<cmXCodeObject*> XCodeObjects;
 211   cmXCodeObject* RootObject;
 212 private:
 213   void ComputeTargetObjects(cmGeneratorTarget* gt) const;
 214
 215   std::string GetObjectsNormalDirectory(
 216     const std::string &projName,
 217     const std::string &configName,
 218     const cmTarget *t) const;
 219
 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;
 242 };
 243
 244 #endif