Source/cmGeneratorExpression.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 <map>
   8 #include <memory>
   9 #include <set>
  10 #include <string>
  11 #include <utility>
  12 #include <vector>
  13
  14 #include "cmListFileCache.h"
  15 #include "cmLocalGenerator.h"
  16
  17 class cmake;
  18 class cmCompiledGeneratorExpression;
  19 class cmGeneratorTarget;
  20 struct cmGeneratorExpressionDAGChecker;
  21 struct cmGeneratorExpressionEvaluator;
  22
  23 /** \class cmGeneratorExpression
  24  * \brief Evaluate generate-time query expression syntax.
  25  *
  26  * cmGeneratorExpression instances are used by build system generator
  27  * implementations to evaluate the $<> generator expression syntax.
  28  * Generator expressions are evaluated just before the generate step
  29  * writes strings into the build system.  They have knowledge of the
  30  * build configuration which is not available at configure time.
  31  */
  32 class cmGeneratorExpression
  33 {
  34 public:
  35   /** Construct. */
  36   cmGeneratorExpression(cmake& cmakeInstance,
  37                         cmListFileBacktrace backtrace = cmListFileBacktrace());
  38   ~cmGeneratorExpression();
  39
  40   cmGeneratorExpression(cmGeneratorExpression const&) = delete;
  41   cmGeneratorExpression& operator=(cmGeneratorExpression const&) = delete;
  42
  43   std::unique_ptr<cmCompiledGeneratorExpression> Parse(
  44     std::string input) const;
  45
  46   static std::string Evaluate(
  47     std::string input, cmLocalGenerator* lg, const std::string& config,
  48     cmGeneratorTarget const* headTarget = nullptr,
  49     cmGeneratorExpressionDAGChecker* dagChecker = nullptr,
  50     cmGeneratorTarget const* currentTarget = nullptr,
  51     std::string const& language = std::string());
  52
  53   enum PreprocessContext
  54   {
  55     StripAllGeneratorExpressions,
  56     BuildInterface,
  57     InstallInterface
  58   };
  59
  60   static std::string Preprocess(const std::string& input,
  61                                 PreprocessContext context,
  62                                 bool resolveRelative = false);
  63
  64   static void Split(const std::string& input,
  65                     std::vector<std::string>& output);
  66
  67   static std::string::size_type Find(const std::string& input);
  68
  69   static bool IsValidTargetName(const std::string& input);
  70
  71   static std::string StripEmptyListElements(const std::string& input);
  72
  73   static inline bool StartsWithGeneratorExpression(const std::string& input)
  74   {
  75     return input.length() >= 2 && input[0] == '$' && input[1] == '<';
  76   }
  77   static inline bool StartsWithGeneratorExpression(const char* input)
  78   {
  79     return input != nullptr && input[0] == '$' && input[1] == '<';
  80   }
  81
  82   static void ReplaceInstallPrefix(std::string& input,
  83                                    const std::string& replacement);
  84
  85 private:
  86   cmake& CMakeInstance;
  87   cmListFileBacktrace Backtrace;
  88 };
  89
  90 class cmCompiledGeneratorExpression
  91 {
  92 public:
  93   ~cmCompiledGeneratorExpression();
  94
  95   cmCompiledGeneratorExpression(cmCompiledGeneratorExpression const&) = delete;
  96   cmCompiledGeneratorExpression& operator=(
  97     cmCompiledGeneratorExpression const&) = delete;
  98
  99   const std::string& Evaluate(
 100     cmLocalGenerator* lg, const std::string& config,
 101     cmGeneratorTarget const* headTarget = nullptr,
 102     cmGeneratorExpressionDAGChecker* dagChecker = nullptr,
 103     cmGeneratorTarget const* currentTarget = nullptr,
 104     std::string const& language = std::string()) const;
 105
 106   /** Get set of targets found during evaluations.  */
 107   std::set<cmGeneratorTarget*> const& GetTargets() const
 108   {
 109     return this->DependTargets;
 110   }
 111
 112   std::set<std::string> const& GetSeenTargetProperties() const
 113   {
 114     return this->SeenTargetProperties;
 115   }
 116
 117   std::set<cmGeneratorTarget const*> const& GetAllTargetsSeen() const
 118   {
 119     return this->AllTargetsSeen;
 120   }
 121
 122   std::string const& GetInput() const { return this->Input; }
 123
 124   cmListFileBacktrace GetBacktrace() const { return this->Backtrace; }
 125   bool GetHadContextSensitiveCondition() const
 126   {
 127     return this->HadContextSensitiveCondition;
 128   }
 129   bool GetHadHeadSensitiveCondition() const
 130   {
 131     return this->HadHeadSensitiveCondition;
 132   }
 133   bool GetHadLinkLanguageSensitiveCondition() const
 134   {
 135     return this->HadLinkLanguageSensitiveCondition;
 136   }
 137   std::set<cmGeneratorTarget const*> GetSourceSensitiveTargets() const
 138   {
 139     return this->SourceSensitiveTargets;
 140   }
 141
 142   void SetEvaluateForBuildsystem(bool eval)
 143   {
 144     this->EvaluateForBuildsystem = eval;
 145   }
 146
 147   void SetQuiet(bool quiet) { this->Quiet = quiet; }
 148
 149   void GetMaxLanguageStandard(cmGeneratorTarget const* tgt,
 150                               std::map<std::string, std::string>& mapping);
 151
 152 private:
 153   cmCompiledGeneratorExpression(cmake& cmakeInstance,
 154                                 cmListFileBacktrace backtrace,
 155                                 std::string input);
 156
 157   friend class cmGeneratorExpression;
 158
 159   cmListFileBacktrace Backtrace;
 160   std::vector<std::unique_ptr<cmGeneratorExpressionEvaluator>> Evaluators;
 161   const std::string Input;
 162   bool NeedsEvaluation;
 163   bool EvaluateForBuildsystem = false;
 164   bool Quiet = false;
 165
 166   mutable std::set<cmGeneratorTarget*> DependTargets;
 167   mutable std::set<cmGeneratorTarget const*> AllTargetsSeen;
 168   mutable std::set<std::string> SeenTargetProperties;
 169   mutable std::map<cmGeneratorTarget const*,
 170                    std::map<std::string, std::string>>
 171     MaxLanguageStandard;
 172   mutable std::string Output;
 173   mutable bool HadContextSensitiveCondition = false;
 174   mutable bool HadHeadSensitiveCondition = false;
 175   mutable bool HadLinkLanguageSensitiveCondition = false;
 176   mutable std::set<cmGeneratorTarget const*> SourceSensitiveTargets;
 177 };
 178
 179 class cmGeneratorExpressionInterpreter
 180 {
 181 public:
 182   cmGeneratorExpressionInterpreter(cmLocalGenerator* localGenerator,
 183                                    std::string config,
 184                                    cmGeneratorTarget const* headTarget,
 185                                    std::string language = std::string())
 186     : GeneratorExpression(*localGenerator->GetCMakeInstance())
 187     , LocalGenerator(localGenerator)
 188     , Config(std::move(config))
 189     , HeadTarget(headTarget)
 190     , Language(std::move(language))
 191   {
 192   }
 193
 194   cmGeneratorExpressionInterpreter(cmGeneratorExpressionInterpreter const&) =
 195     delete;
 196   cmGeneratorExpressionInterpreter& operator=(
 197     cmGeneratorExpressionInterpreter const&) = delete;
 198
 199   const std::string& Evaluate(std::string expression,
 200                               const std::string& property);
 201
 202 protected:
 203   cmGeneratorExpression GeneratorExpression;
 204   std::unique_ptr<cmCompiledGeneratorExpression> CompiledGeneratorExpression;
 205   cmLocalGenerator* LocalGenerator = nullptr;
 206   std::string Config;
 207   cmGeneratorTarget const* HeadTarget = nullptr;
 208   std::string Language;
 209 };