Source/cmGlobalXCodeGenerator.h

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: cmGlobalXCodeGenerator.h,v $
   5   Language:  C++
   6   Date:      $Date: 2008-10-10 12:11:08 $
   7   Version:   $Revision: 1.55 $
   8
   9   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  10   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  11
  12      This software is distributed WITHOUT ANY WARRANTY; without even
  13      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14      PURPOSE.  See the above copyright notices for more information.
  15
  16 =========================================================================*/
  17 #ifndef cmGlobalXCodeGenerator_h
  18 #define cmGlobalXCodeGenerator_h
  19
  20 #include "cmGlobalGenerator.h"
  21 #include "cmXCodeObject.h"
  22 #include "cmCustomCommand.h"
  23 class cmTarget;
  24 class cmSourceFile;
  25 class cmSourceGroup;
  26
  27
  28 /** \class cmGlobalXCodeGenerator
  29  * \brief Write a Unix makefiles.
  30  *
  31  * cmGlobalXCodeGenerator manages UNIX build process for a tree
  32  */
  33 class cmGlobalXCodeGenerator : public cmGlobalGenerator
  34 {
  35 public:
  36   cmGlobalXCodeGenerator();
  37   static cmGlobalGenerator* New();
  38
  39   void SetVersion(int v) { this->XcodeVersion = v;}
  40   ///! Get the name for the generator.
  41   virtual const char* GetName() const {
  42     return cmGlobalXCodeGenerator::GetActualName();}
  43   static const char* GetActualName() {return "Xcode";}
  44
  45   /** Get the documentation entry for this generator.  */
  46   virtual void GetDocumentation(cmDocumentationEntry& entry) const;
  47
  48   ///! Create a local generator appropriate to this Global Generator
  49   virtual cmLocalGenerator *CreateLocalGenerator();
  50
  51   /**
  52    * Try to determine system infomation such as shared library
  53    * extension, pthreads, byte order etc.
  54    */
  55   virtual void EnableLanguage(std::vector<std::string>const& languages,
  56                               cmMakefile *, bool optional);
  57   /**
  58    * Try running cmake and building a file. This is used for dynalically
  59    * loaded commands, not as part of the usual build process.
  60    */
  61   virtual std::string GenerateBuildCommand(const char* makeProgram,
  62                                            const char *projectName,
  63                                            const char* additionalOptions,
  64                                            const char *targetName,
  65                                            const char* config,
  66                                            bool ignoreErrors,
  67                                            bool fast);
  68
  69   /**
  70    * Generate the all required files for building this project/tree. This
  71    * basically creates a series of LocalGenerators for each directory and
  72    * requests that they Generate.
  73    */
  74   virtual void Generate();
  75
  76   /** Append the subdirectory for the given configuration.  */
  77   virtual void AppendDirectoryForConfig(const char* prefix,
  78                                         const char* config,
  79                                         const char* suffix,
  80                                         std::string& dir);
  81
  82   ///! What is the configurations directory variable called?
  83   virtual const char* GetCMakeCFGInitDirectory()  { return "."; }
  84
  85   void GetTargetObjectFileDirectories(cmTarget* target,
  86                                       std::vector<std::string>&
  87                                       dirs);
  88   void SetCurrentLocalGenerator(cmLocalGenerator*);
  89 private:
  90   cmXCodeObject* CreateOrGetPBXGroup(cmTarget& cmtarget,
  91                                      cmSourceGroup* sg);
  92   void CreateGroups(cmLocalGenerator* root,
  93                     std::vector<cmLocalGenerator*>&
  94                     generators);
  95   std::string XCodeEscapePath(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   // create cmXCodeObject from these functions so that memory can be managed
 124   // correctly.  All objects created are stored in this->XCodeObjects.
 125   cmXCodeObject* CreateObject(cmXCodeObject::PBXType ptype);
 126   cmXCodeObject* CreateObject(cmXCodeObject::Type type);
 127   cmXCodeObject* CreateString(const char* s);
 128   cmXCodeObject* CreateObjectReference(cmXCodeObject*);
 129   cmXCodeObject* CreateXCodeTarget(cmTarget& target,
 130                                    cmXCodeObject* buildPhases);
 131   void AddConfigurations(cmXCodeObject* target,
 132                          cmTarget& cmtarget);
 133   void AppendOrAddBuildSetting(cmXCodeObject* settings, const char* attr,
 134                                const char* value);
 135   void AppendBuildSettingAttribute(cmXCodeObject* target, const char* attr,
 136                                    const char* value, const char* configName);
 137   cmXCodeObject* CreateUtilityTarget(cmTarget& target);
 138   void AddDependAndLinkInformation(cmXCodeObject* target);
 139   void CreateBuildSettings(cmTarget& target,
 140                            cmXCodeObject* buildSettings,
 141                            std::string& fileType,
 142                            std::string& productType,
 143                            std::string& projectName,
 144                            const char* buildType);
 145   std::string ExtractFlag(const char* flag, std::string& flags);
 146   // delete all objects in the this->XCodeObjects vector.
 147   void ClearXCodeObjects();
 148   void CreateXCodeObjects(cmLocalGenerator* root,
 149                           std::vector<cmLocalGenerator*>& generators);
 150   void OutputXCodeProject(cmLocalGenerator* root,
 151                           std::vector<cmLocalGenerator*>& generators);
 152   virtual void  WriteXCodePBXProj(std::ostream& fout,
 153                                   cmLocalGenerator* root,
 154                                   std::vector<cmLocalGenerator*>& generators);
 155   cmXCodeObject* CreateXCodeFileReference(cmSourceFile* sf,
 156                                           cmTarget& cmtarget);
 157   cmXCodeObject* CreateXCodeSourceFile(cmLocalGenerator* gen,
 158                                        cmSourceFile* sf,
 159                                        cmTarget& cmtarget);
 160   void CreateXCodeTargets(cmLocalGenerator* gen,
 161                           std::vector<cmXCodeObject*>&);
 162   void AddDependTarget(cmXCodeObject* target,
 163                        cmXCodeObject* dependTarget);
 164   void CreateXCodeDependHackTarget(std::vector<cmXCodeObject*>& targets);
 165   bool SpecialTargetEmitted(std::string const& tname);
 166   void SetGenerationRoot(cmLocalGenerator* root);
 167   void AddExtraTargets(cmLocalGenerator* root,
 168                        std::vector<cmLocalGenerator*>& gens);
 169   cmXCodeObject* CreateBuildPhase(const char* name,
 170                                   const char* name2,
 171                                   cmTarget& cmtarget,
 172                                   const std::vector<cmCustomCommand>&);
 173   void CreateReRunCMakeFile(cmLocalGenerator* root);
 174
 175   std::string LookupFlags(const char* varNamePrefix,
 176                           const char* varNameLang,
 177                           const char* varNameSuffix,
 178                           const char* default_flags);
 179
 180   void AppendDefines(std::string& defs, const char* defines_list,
 181                      bool dflag = false);
 182
 183 protected:
 184   virtual const char* GetInstallTargetName()      { return "install"; }
 185   virtual const char* GetPackageTargetName()      { return "package"; }
 186
 187   int XcodeVersion;
 188   std::vector<cmXCodeObject*> XCodeObjects;
 189   cmXCodeObject* RootObject;
 190 private:
 191   cmXCodeObject* MainGroupChildren;
 192   cmXCodeObject* SourcesGroupChildren;
 193   cmXCodeObject* ResourcesGroupChildren;
 194   cmMakefile* CurrentMakefile;
 195   cmLocalGenerator* CurrentLocalGenerator;
 196   std::vector<std::string> CurrentConfigurationTypes;
 197   std::string CurrentReRunCMakeMakefile;
 198   std::string CurrentXCodeHackMakefile;
 199   std::string CurrentProject;
 200   std::set<cmStdString> TargetDoneSet;
 201   std::vector<std::string> CurrentOutputDirectoryComponents;
 202   std::vector<std::string> ProjectOutputDirectoryComponents;
 203   std::map<cmStdString, cmXCodeObject* > GroupMap;
 204   std::map<cmStdString, cmXCodeObject* > GroupNameMap;
 205   std::map<cmStdString, cmXCodeObject* > TargetGroup;
 206   std::map<cmStdString, cmXCodeObject* > FileRefs;
 207   std::vector<std::string> Architectures;
 208 };
 209
 210 #endif