Source/cmGlobalVisualStudioGenerator.h

   1 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   2    file Copyright.txt or https://cmake.org/licensing for details.  */
   3 #pragma once
   4
   5 #include "cmConfigure.h" // IWYU pragma: keep
   6
   7 #include <iosfwd>
   8 #include <map>
   9 #include <set>
  10 #include <string>
  11 #include <vector>
  12
  13 #include "cm_codecvt_Encoding.hxx"
  14
  15 #include "cmGlobalGenerator.h"
  16 #include "cmTargetDepend.h"
  17 #include "cmValue.h"
  18
  19 class cmCustomCommand;
  20 class cmGeneratorTarget;
  21 class cmLocalGenerator;
  22 class cmMakefile;
  23 class cmake;
  24
  25 /** \class cmGlobalVisualStudioGenerator
  26  * \brief Base class for global Visual Studio generators.
  27  *
  28  * cmGlobalVisualStudioGenerator provides functionality common to all
  29  * global Visual Studio generators.
  30  */
  31 class cmGlobalVisualStudioGenerator : public cmGlobalGenerator
  32 {
  33 public:
  34   /** Known versions of Visual Studio.  */
  35   enum class VSVersion : uint16_t
  36   {
  37     VS12 = 120,
  38     /* VS13 = 130 was skipped */
  39     VS14 = 140,
  40     VS15 = 150,
  41     VS16 = 160,
  42     VS17 = 170
  43   };
  44
  45   ~cmGlobalVisualStudioGenerator() override;
  46
  47   VSVersion GetVersion() const;
  48   void SetVersion(VSVersion v);
  49
  50   /** Is the installed VS an Express edition?  */
  51   bool IsExpressEdition() const { return this->ExpressEdition; }
  52
  53   void EnableLanguage(std::vector<std::string> const& languages, cmMakefile*,
  54                       bool optional) override;
  55
  56   bool SetGeneratorPlatform(std::string const& p, cmMakefile* mf) override;
  57
  58   /**
  59    * Get the name of the target platform (architecture) for which we generate.
  60    * The names are as defined by VS, e.g. "Win32", "x64", "Itanium", "ARM".
  61    */
  62   std::string const& GetPlatformName() const;
  63
  64   /**
  65    * Configure CMake's Visual Studio macros file into the user's Visual
  66    * Studio macros directory.
  67    */
  68   virtual void ConfigureCMakeVisualStudioMacros();
  69
  70   /**
  71    * Where does this version of Visual Studio look for macros for the
  72    * current user? Returns the empty string if this version of Visual
  73    * Studio does not implement support for VB macros.
  74    */
  75   virtual std::string GetUserMacrosDirectory();
  76
  77   /**
  78    * What is the reg key path to "vsmacros" for this version of Visual
  79    * Studio?
  80    */
  81   virtual std::string GetUserMacrosRegKeyBase();
  82
  83   enum MacroName
  84   {
  85     MacroReload,
  86     MacroStop
  87   };
  88
  89   /**
  90    * Call the ReloadProjects macro if necessary based on
  91    * GetFilesReplacedDuringGenerate results.
  92    */
  93   void CallVisualStudioMacro(MacroName m, const std::string& vsSolutionFile);
  94
  95   // return true if target is fortran only
  96   bool TargetIsFortranOnly(const cmGeneratorTarget* gt);
  97
  98   // return true if target should be included in solution.
  99   virtual bool IsInSolution(const cmGeneratorTarget* gt) const;
 100
 101   // return true if project dependency should be included in solution.
 102   virtual bool IsDepInSolution(const std::string& targetName) const;
 103
 104   /** Get the top-level registry key for this VS version.  */
 105   std::string GetRegistryBase();
 106
 107   /** Get the top-level registry key for the given VS version.  */
 108   static std::string GetRegistryBase(const char* version);
 109
 110   /** Return true if the generated build tree may contain multiple builds.
 111       i.e. "Can I build Debug and Release in the same tree?" */
 112   bool IsMultiConfig() const override { return true; }
 113
 114   /** Return true if building for Windows CE */
 115   virtual bool TargetsWindowsCE() const { return false; }
 116
 117   bool IsIncludeExternalMSProjectSupported() const override { return true; }
 118
 119   /** Get encoding used by generator for generated source files
 120    */
 121   codecvt_Encoding GetMakefileEncoding() const override
 122   {
 123     return codecvt_Encoding::ANSI;
 124   }
 125
 126   class TargetSet : public std::set<cmGeneratorTarget const*>
 127   {
 128   };
 129   class TargetCompare
 130   {
 131     std::string First;
 132
 133   public:
 134     TargetCompare(std::string first)
 135       : First(std::move(first))
 136     {
 137     }
 138     bool operator()(cmGeneratorTarget const* l,
 139                     cmGeneratorTarget const* r) const;
 140   };
 141   class OrderedTargetDependSet;
 142
 143   bool FindMakeProgram(cmMakefile*) override;
 144
 145   std::string ExpandCFGIntDir(const std::string& str,
 146                               const std::string& config) const override;
 147
 148   void ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const override;
 149
 150   std::string GetStartupProjectName(cmLocalGenerator const* root) const;
 151
 152   void AddSymbolExportCommand(cmGeneratorTarget*,
 153                               std::vector<cmCustomCommand>& commands,
 154                               std::string const& configName);
 155
 156   bool Open(const std::string& bindir, const std::string& projectName,
 157             bool dryRun) override;
 158
 159   bool IsVisualStudio() const override { return true; }
 160
 161 protected:
 162   cmGlobalVisualStudioGenerator(cmake* cm,
 163                                 std::string const& platformInGeneratorName);
 164
 165   virtual bool InitializePlatform(cmMakefile* mf);
 166
 167   void AddExtraIDETargets() override;
 168
 169   // Does this VS version link targets to each other if there are
 170   // dependencies in the SLN file?  This was done for VS versions
 171   // below 8.
 172   virtual bool VSLinksDependencies() const { return true; }
 173
 174   const char* GetIDEVersion() const;
 175
 176   void WriteSLNHeader(std::ostream& fout);
 177
 178   bool ComputeTargetDepends() override;
 179   class VSDependSet : public std::set<std::string>
 180   {
 181   };
 182   class VSDependMap : public std::map<cmGeneratorTarget const*, VSDependSet>
 183   {
 184   };
 185   VSDependMap VSTargetDepends;
 186   void ComputeVSTargetDepends(cmGeneratorTarget*);
 187
 188   bool CheckTargetLinks(cmGeneratorTarget& target, const std::string& name);
 189   std::string GetUtilityForTarget(cmGeneratorTarget& target,
 190                                   const std::string&);
 191   virtual std::string WriteUtilityDepend(cmGeneratorTarget const*) = 0;
 192   std::string GetUtilityDepend(const cmGeneratorTarget* target);
 193   using UtilityDependsMap = std::map<cmGeneratorTarget const*, std::string>;
 194   UtilityDependsMap UtilityDepends;
 195
 196   VSVersion Version;
 197   bool ExpressEdition;
 198
 199   std::string GeneratorPlatform;
 200   std::string DefaultPlatformName;
 201   bool PlatformInGeneratorName = false;
 202
 203 private:
 204   virtual std::string GetVSMakeProgram() = 0;
 205   void PrintCompilerAdvice(std::ostream&, std::string const&,
 206                            cmValue) const override
 207   {
 208   }
 209
 210   void FollowLinkDepends(cmGeneratorTarget const* target,
 211                          std::set<cmGeneratorTarget const*>& linked);
 212
 213   class TargetSetMap : public std::map<cmGeneratorTarget*, TargetSet>
 214   {
 215   };
 216   TargetSetMap TargetLinkClosure;
 217   void FillLinkClosure(const cmGeneratorTarget* target, TargetSet& linked);
 218   TargetSet const& GetTargetLinkClosure(cmGeneratorTarget* target);
 219 };
 220
 221 class cmGlobalVisualStudioGenerator::OrderedTargetDependSet
 222   : public std::multiset<cmTargetDepend,
 223                          cmGlobalVisualStudioGenerator::TargetCompare>
 224 {
 225   using derived = std::multiset<cmTargetDepend,
 226                                 cmGlobalVisualStudioGenerator::TargetCompare>;
 227
 228 public:
 229   using TargetDependSet = cmGlobalGenerator::TargetDependSet;
 230   using TargetSet = cmGlobalVisualStudioGenerator::TargetSet;
 231   OrderedTargetDependSet(TargetDependSet const&, std::string const& first);
 232   OrderedTargetDependSet(TargetSet const&, std::string const& first);
 233 };