CMakeLua/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/01/14 14:20:57 $
   7   Version:   $Revision: 1.52 $
   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   void AddCommandsToBuildPhase(cmXCodeObject* buildphase,
 107                                cmTarget& target,
 108                                std::vector<cmCustomCommand>
 109                                const & commands,
 110                                const char* commandFileName);
 111
 112   void CreateCustomRulesMakefile(const char* makefileBasename,
 113                                  cmTarget& target,
 114                                  std::vector<cmCustomCommand> const & commands,
 115                                  const char* configName,
 116                                  const std::map<cmStdString, cmStdString>&
 117                                      multipleOutputPairs
 118                                 );
 119
 120   cmXCodeObject* FindXCodeTarget(cmTarget*);
 121   // create cmXCodeObject from these functions so that memory can be managed
 122   // correctly.  All objects created are stored in this->XCodeObjects.
 123   cmXCodeObject* CreateObject(cmXCodeObject::PBXType ptype);
 124   cmXCodeObject* CreateObject(cmXCodeObject::Type type);
 125   cmXCodeObject* CreateString(const char* s);
 126   cmXCodeObject* CreateObjectReference(cmXCodeObject*);
 127   cmXCodeObject* CreateXCodeTarget(cmTarget& target,
 128                                    cmXCodeObject* buildPhases);
 129   void AddConfigurations(cmXCodeObject* target,
 130                          cmTarget& cmtarget);
 131   void AppendOrAddBuildSetting(cmXCodeObject* settings, const char* attr,
 132                                const char* value);
 133   void AppendBuildSettingAttribute(cmXCodeObject* target, const char* attr,
 134                                    const char* value, const char* configName);
 135   cmXCodeObject* CreateUtilityTarget(cmTarget& target);
 136   void AddDependAndLinkInformation(cmXCodeObject* target);
 137   void CreateBuildSettings(cmTarget& target,
 138                            cmXCodeObject* buildSettings,
 139                            std::string& fileType,
 140                            std::string& productType,
 141                            std::string& projectName,
 142                            const char* buildType);
 143   std::string ExtractFlag(const char* flag, std::string& flags);
 144   // delete all objects in the this->XCodeObjects vector.
 145   void ClearXCodeObjects();
 146   void CreateXCodeObjects(cmLocalGenerator* root,
 147                           std::vector<cmLocalGenerator*>& generators);
 148   void OutputXCodeProject(cmLocalGenerator* root,
 149                           std::vector<cmLocalGenerator*>& generators);
 150   virtual void  WriteXCodePBXProj(std::ostream& fout,
 151                                   cmLocalGenerator* root,
 152                                   std::vector<cmLocalGenerator*>& generators);
 153   cmXCodeObject* CreateXCodeSourceFile(cmLocalGenerator* gen,
 154                                        cmSourceFile* sf,
 155                                        cmTarget& cmtarget);
 156   void CreateXCodeTargets(cmLocalGenerator* gen,
 157                           std::vector<cmXCodeObject*>&);
 158   void AddDependTarget(cmXCodeObject* target,
 159                        cmXCodeObject* dependTarget);
 160   void CreateXCodeDependHackTarget(std::vector<cmXCodeObject*>& targets);
 161   bool SpecialTargetEmitted(std::string const& tname);
 162   void SetGenerationRoot(cmLocalGenerator* root);
 163   void AddExtraTargets(cmLocalGenerator* root,
 164                        std::vector<cmLocalGenerator*>& gens);
 165   cmXCodeObject* CreateBuildPhase(const char* name,
 166                                   const char* name2,
 167                                   cmTarget& cmtarget,
 168                                   const std::vector<cmCustomCommand>&);
 169   void CreateReRunCMakeFile(cmLocalGenerator* root);
 170
 171   std::string LookupFlags(const char* varNamePrefix,
 172                           const char* varNameLang,
 173                           const char* varNameSuffix,
 174                           const char* default_flags);
 175
 176   void AppendDefines(std::string& defs, const char* defines_list,
 177                      bool dflag = false);
 178
 179 protected:
 180   virtual const char* GetInstallTargetName()      { return "install"; }
 181   virtual const char* GetPackageTargetName()      { return "package"; }
 182
 183   int XcodeVersion;
 184   std::vector<cmXCodeObject*> XCodeObjects;
 185   cmXCodeObject* RootObject;
 186 private:
 187   cmXCodeObject* MainGroupChildren;
 188   cmXCodeObject* SourcesGroupChildren;
 189   cmXCodeObject* ResourcesGroupChildren;
 190   cmMakefile* CurrentMakefile;
 191   cmLocalGenerator* CurrentLocalGenerator;
 192   std::vector<std::string> CurrentConfigurationTypes;
 193   std::string CurrentReRunCMakeMakefile;
 194   std::string CurrentXCodeHackMakefile;
 195   std::string CurrentProject;
 196   std::set<cmStdString> TargetDoneSet;
 197   std::vector<std::string> CurrentOutputDirectoryComponents;
 198   std::vector<std::string> ProjectOutputDirectoryComponents;
 199   std::map<cmStdString, cmXCodeObject* > GroupMap;
 200   std::map<cmStdString, cmXCodeObject* > GroupNameMap;
 201   std::map<cmStdString, cmXCodeObject* > TargetGroup;
 202   std::map<cmStdString, cmXCodeObject* > FileRefs;
 203   std::vector<std::string> Architectures;
 204 };
 205
 206 #endif