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 cmTarget;
  19 class cmSourceFile;
  20 class cmSourceGroup;
  21
  22
  23 /** \class cmGlobalXCodeGenerator
  24  * \brief Write a Unix makefiles.
  25  *
  26  * cmGlobalXCodeGenerator manages UNIX build process for a tree
  27  */
  28 class cmGlobalXCodeGenerator : public cmGlobalGenerator
  29 {
  30 public:
  31   cmGlobalXCodeGenerator(std::string const& version);
  32   static cmGlobalGenerator* New();
  33
  34   ///! Get the name for the generator.
  35   virtual const char* GetName() const {
  36     return cmGlobalXCodeGenerator::GetActualName();}
  37   static const char* GetActualName() {return "Xcode";}
  38
  39   /** Get the documentation entry for this generator.  */
  40   virtual void GetDocumentation(cmDocumentationEntry& entry) const;
  41
  42   ///! Create a local generator appropriate to this Global Generator
  43   virtual cmLocalGenerator *CreateLocalGenerator();
  44
  45   /**
  46    * Try to determine system infomation such as shared library
  47    * extension, pthreads, byte order etc.
  48    */
  49   virtual void EnableLanguage(std::vector<std::string>const& languages,
  50                               cmMakefile *, bool optional);
  51   /**
  52    * Try running cmake and building a file. This is used for dynalically
  53    * loaded commands, not as part of the usual build process.
  54    */
  55   virtual std::string GenerateBuildCommand(const char* makeProgram,
  56                                            const char *projectName,
  57                                            const char* additionalOptions,
  58                                            const char *targetName,
  59                                            const char* config,
  60                                            bool ignoreErrors,
  61                                            bool fast);
  62
  63   /**
  64    * Generate the all required files for building this project/tree. This
  65    * basically creates a series of LocalGenerators for each directory and
  66    * requests that they Generate.
  67    */
  68   virtual void Generate();
  69
  70   /** Append the subdirectory for the given configuration.  */
  71   virtual void AppendDirectoryForConfig(const char* prefix,
  72                                         const char* config,
  73                                         const char* suffix,
  74                                         std::string& dir);
  75
  76   ///! What is the configurations directory variable called?
  77   virtual const char* GetCMakeCFGIntDir() const;
  78
  79   void SetCurrentLocalGenerator(cmLocalGenerator*);
  80
  81   /** Return true if the generated build tree may contain multiple builds.
  82       i.e. "Can I build Debug and Release in the same tree?" */
  83   virtual bool IsMultiConfig();
  84
  85 private:
  86   cmXCodeObject* CreateOrGetPBXGroup(cmTarget& cmtarget,
  87                                      cmSourceGroup* sg);
  88   cmXCodeObject* CreatePBXGroup(cmXCodeObject *parent,
  89                                 cmStdString name);
  90   void CreateGroups(cmLocalGenerator* root,
  91                     std::vector<cmLocalGenerator*>&
  92                     generators);
  93   std::string XCodeEscapePath(const char* p);
  94   std::string RelativeToSource(const char* p);
  95   std::string RelativeToBinary(const char* p);
  96   std::string ConvertToRelativeForXCode(const char* p);
  97   std::string ConvertToRelativeForMake(const char* p);
  98   void CreateCustomCommands(cmXCodeObject* buildPhases,
  99                             cmXCodeObject* sourceBuildPhase,
 100                             cmXCodeObject* headerBuildPhase,
 101                             cmXCodeObject* resourceBuildPhase,
 102                             std::vector<cmXCodeObject*> contentBuildPhases,
 103                             cmXCodeObject* frameworkBuildPhase,
 104                             cmTarget& cmtarget);
 105
 106   std::string ComputeInfoPListLocation(cmTarget& target);
 107
 108   void AddCommandsToBuildPhase(cmXCodeObject* buildphase,
 109                                cmTarget& target,
 110                                std::vector<cmCustomCommand>
 111                                const & commands,
 112                                const char* commandFileName);
 113
 114   void CreateCustomRulesMakefile(const char* makefileBasename,
 115                                  cmTarget& target,
 116                                  std::vector<cmCustomCommand> const & commands,
 117                                  const char* configName,
 118                                  const std::map<cmStdString, cmStdString>&
 119                                      multipleOutputPairs
 120                                 );
 121
 122   cmXCodeObject* FindXCodeTarget(cmTarget*);
 123   std::string GetOrCreateId(const char* name, const char* id);
 124
 125   // create cmXCodeObject from these functions so that memory can be managed
 126   // correctly.  All objects created are stored in this->XCodeObjects.
 127   cmXCodeObject* CreateObject(cmXCodeObject::PBXType ptype);
 128   cmXCodeObject* CreateObject(cmXCodeObject::Type type);
 129   cmXCodeObject* CreateString(const char* s);
 130   cmXCodeObject* CreateObjectReference(cmXCodeObject*);
 131   cmXCodeObject* CreateXCodeTarget(cmTarget& target,
 132                                    cmXCodeObject* buildPhases);
 133   void ForceLinkerLanguages();
 134   void ForceLinkerLanguage(cmTarget& cmtarget);
 135   const char* GetTargetFileType(cmTarget& cmtarget);
 136   const char* GetTargetProductType(cmTarget& cmtarget);
 137   std::string AddConfigurations(cmXCodeObject* target, cmTarget& cmtarget);
 138   void AppendOrAddBuildSetting(cmXCodeObject* settings, const char* attr,
 139                                const char* value);
 140   void AppendBuildSettingAttribute(cmXCodeObject* target, const char* attr,
 141                                    const char* value, const char* configName);
 142   cmXCodeObject* CreateUtilityTarget(cmTarget& target);
 143   void AddDependAndLinkInformation(cmXCodeObject* target);
 144   void CreateBuildSettings(cmTarget& target,
 145                            cmXCodeObject* buildSettings,
 146                            const char* buildType);
 147   std::string ExtractFlag(const char* flag, std::string& flags);
 148   // delete all objects in the this->XCodeObjects vector.
 149   void ClearXCodeObjects();
 150   void CreateXCodeObjects(cmLocalGenerator* root,
 151                           std::vector<cmLocalGenerator*>& generators);
 152   void OutputXCodeProject(cmLocalGenerator* root,
 153                           std::vector<cmLocalGenerator*>& generators);
 154   void WriteXCodePBXProj(std::ostream& fout, cmLocalGenerator* root,
 155                          std::vector<cmLocalGenerator*>& generators);
 156   cmXCodeObject* CreateXCodeFileReferenceFromPath(const std::string &fullpath,
 157                                                   cmTarget& cmtarget,
 158                                                   const std::string &lang);
 159   cmXCodeObject* CreateXCodeSourceFileFromPath(const std::string &fullpath,
 160                                                cmTarget& cmtarget,
 161                                                const std::string &lang);
 162   cmXCodeObject* CreateXCodeFileReference(cmSourceFile* sf,
 163                                           cmTarget& cmtarget);
 164   cmXCodeObject* CreateXCodeSourceFile(cmLocalGenerator* gen,
 165                                        cmSourceFile* sf,
 166                                        cmTarget& cmtarget);
 167   void CreateXCodeTargets(cmLocalGenerator* gen,
 168                           std::vector<cmXCodeObject*>&);
 169   bool IsHeaderFile(cmSourceFile*);
 170   void AddDependTarget(cmXCodeObject* target,
 171                        cmXCodeObject* dependTarget);
 172   void CreateXCodeDependHackTarget(std::vector<cmXCodeObject*>& targets);
 173   bool SpecialTargetEmitted(std::string const& tname);
 174   void SetGenerationRoot(cmLocalGenerator* root);
 175   void AddExtraTargets(cmLocalGenerator* root,
 176                        std::vector<cmLocalGenerator*>& gens);
 177   cmXCodeObject* CreateBuildPhase(const char* name,
 178                                   const char* name2,
 179                                   cmTarget& cmtarget,
 180                                   const std::vector<cmCustomCommand>&);
 181   void CreateReRunCMakeFile(cmLocalGenerator* root,
 182                             std::vector<cmLocalGenerator*> const& gens);
 183
 184   std::string LookupFlags(const char* varNamePrefix,
 185                           const char* varNameLang,
 186                           const char* varNameSuffix,
 187                           const char* default_flags);
 188
 189   class BuildObjectListOrString;
 190   friend class BuildObjectListOrString;
 191
 192   void AppendDefines(BuildObjectListOrString& defs, const char* defines_list,
 193                      bool dflag = false);
 194   void AppendDefines(BuildObjectListOrString& defs,
 195                      std::vector<std::string> const& defines,
 196                      bool dflag = false);
 197   void AppendFlag(std::string& flags, std::string const& flag);
 198
 199 protected:
 200   virtual const char* GetInstallTargetName() const { return "install"; }
 201   virtual const char* GetPackageTargetName() const { return "package"; }
 202
 203   unsigned int XcodeVersion;
 204   std::string VersionString;
 205   std::set<cmStdString> XCodeObjectIDs;
 206   std::vector<cmXCodeObject*> XCodeObjects;
 207   cmXCodeObject* RootObject;
 208 private:
 209   void ComputeTargetObjects(cmGeneratorTarget* gt) const;
 210
 211   std::string GetObjectsNormalDirectory(
 212     const std::string &projName,
 213     const std::string &configName,
 214     const cmTarget *t) const;
 215
 216   void addObject(cmXCodeObject *obj);
 217   std::string PostBuildMakeTarget(std::string const& tName,
 218                                   std::string const& configName);
 219   cmXCodeObject* MainGroupChildren;
 220   cmXCodeObject* SourcesGroupChildren;
 221   cmXCodeObject* ResourcesGroupChildren;
 222   cmMakefile* CurrentMakefile;
 223   cmLocalGenerator* CurrentLocalGenerator;
 224   std::vector<std::string> CurrentConfigurationTypes;
 225   std::string CurrentReRunCMakeMakefile;
 226   std::string CurrentXCodeHackMakefile;
 227   std::string CurrentProject;
 228   std::set<cmStdString> TargetDoneSet;
 229   std::vector<std::string> CurrentOutputDirectoryComponents;
 230   std::vector<std::string> ProjectSourceDirectoryComponents;
 231   std::vector<std::string> ProjectOutputDirectoryComponents;
 232   std::map<cmStdString, cmXCodeObject* > GroupMap;
 233   std::map<cmStdString, cmXCodeObject* > GroupNameMap;
 234   std::map<cmStdString, cmXCodeObject* > TargetGroup;
 235   std::map<cmStdString, cmXCodeObject* > FileRefs;
 236   std::vector<std::string> Architectures;
 237 };
 238
 239 #endif