cmState.h 13.3 KB
Newer Older
Stephen Kelly's avatar
Stephen Kelly committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
/*============================================================================
  CMake - Cross Platform Makefile Generator
  Copyright 2015 Stephen Kelly <steveire@gmail.com>

  Distributed under the OSI-approved BSD License (the "License");
  see accompanying file Copyright.txt for details.

  This software is distributed WITHOUT ANY WARRANTY; without even the
  implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  See the License for more information.
============================================================================*/
#ifndef cmState_h
#define cmState_h

15
#include "cmStandardIncludes.h"
16
#include "cmPropertyDefinitionMap.h"
17
#include "cmPropertyMap.h"
18
#include "cmLinkedTree.h"
19
#include "cmAlgorithms.h"
20
#include "cmPolicies.h"
Stephen Kelly's avatar
Stephen Kelly committed
21
22

class cmake;
23
class cmCommand;
24
25
class cmDefinitions;
class cmListFileBacktrace;
26
class cmCacheManager;
Stephen Kelly's avatar
Stephen Kelly committed
27
28
29

class cmState
{
30
  struct SnapshotDataType;
31
  struct PolicyStackEntry;
32
  struct BuildsystemDirectoryStateType;
33
  typedef cmLinkedTree<SnapshotDataType>::iterator PositionType;
Stephen Kelly's avatar
Stephen Kelly committed
34
  friend class Snapshot;
Stephen Kelly's avatar
Stephen Kelly committed
35
public:
36
  cmState();
37
  ~cmState();
Stephen Kelly's avatar
Stephen Kelly committed
38

39
40
  enum SnapshotType
  {
41
    BaseType,
42
43
44
45
    BuildsystemDirectoryType,
    FunctionCallType,
    MacroCallType,
    CallStackType,
46
    InlineListFileType,
47
48
    PolicyScopeType,
    VariableScopeType
49
50
  };

51
52
  class Directory;

Stephen Kelly's avatar
Stephen Kelly committed
53
54
  class Snapshot {
  public:
55
56
    Snapshot(cmState* state = 0);
    Snapshot(cmState* state, PositionType position);
Stephen Kelly's avatar
Stephen Kelly committed
57

58
59
60
61
62
63
64
65
    const char* GetDefinition(std::string const& name) const;
    bool IsInitialized(std::string const& name) const;
    void SetDefinition(std::string const& name, std::string const& value);
    void RemoveDefinition(std::string const& name);
    std::vector<std::string> UnusedKeys() const;
    std::vector<std::string> ClosureKeys() const;
    bool RaiseScope(std::string const& var, const char* varDef);

66
67
68
    void SetListFile(std::string const& listfile);

    std::string GetExecutionListFile() const;
69
70

    std::vector<Snapshot> GetChildren();
71
72
73
    std::string GetEntryPointCommand() const;
    long GetEntryPointLine() const;

74
    bool IsValid() const;
75
    Snapshot GetBuildsystemDirectoryParent() const;
76
    Snapshot GetCallStackParent() const;
77
    SnapshotType GetType() const;
78

79
80
81
82
83
84
85
    void SetPolicy(cmPolicies::PolicyID id, cmPolicies::PolicyStatus status);
    cmPolicies::PolicyStatus GetPolicy(cmPolicies::PolicyID id) const;
    bool HasDefinedPolicyCMP0011();
    void PushPolicy(cmPolicies::PolicyMap entry, bool weak);
    bool PopPolicy();
    bool CanPopPolicyScope();

86
    cmState* GetState() const;
87

88
    Directory GetDirectory() const;
89

90
91
92
    void SetProjectName(std::string const& name);
    std::string GetProjectName() const;

93
94
    void InitializeFromParent_ForSubdirsCommand();

95
96
97
98
99
100
    struct StrictWeakOrder
    {
      bool operator()(const cmState::Snapshot& lhs,
                      const cmState::Snapshot& rhs) const;
    };

101
    void SetDirectoryDefinitions();
102
    void SetDefaultDefinitions();
103

Stephen Kelly's avatar
Stephen Kelly committed
104
  private:
105
106
107
108
    friend bool operator==(const cmState::Snapshot& lhs,
                           const cmState::Snapshot& rhs);
    friend bool operator!=(const cmState::Snapshot& lhs,
                           const cmState::Snapshot& rhs);
Stephen Kelly's avatar
Stephen Kelly committed
109
    friend class cmState;
110
    friend class Directory;
111
    friend struct StrictWeakOrder;
112
113
114

    void InitializeFromParent();

Stephen Kelly's avatar
Stephen Kelly committed
115
116
117
118
    cmState* State;
    cmState::PositionType Position;
  };

119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
  class Directory
  {
    Directory(cmLinkedTree<BuildsystemDirectoryStateType>::iterator iter,
              Snapshot const& snapshot);
  public:
    const char* GetCurrentSource() const;
    void SetCurrentSource(std::string const& dir);
    const char* GetCurrentBinary() const;
    void SetCurrentBinary(std::string const& dir);

    std::vector<std::string> const&
    GetCurrentSourceComponents() const;
    std::vector<std::string> const&
    GetCurrentBinaryComponents() const;

    const char* GetRelativePathTopSource() const;
    const char* GetRelativePathTopBinary() const;
    void SetRelativePathTopSource(const char* dir);
    void SetRelativePathTopBinary(const char* dir);

139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
    cmStringRange GetIncludeDirectoriesEntries() const;
    cmBacktraceRange GetIncludeDirectoriesEntryBacktraces() const;
    void AppendIncludeDirectoriesEntry(std::string const& vec,
                                       cmListFileBacktrace const& lfbt);
    void PrependIncludeDirectoriesEntry(std::string const& vec,
                                        cmListFileBacktrace const& lfbt);
    void SetIncludeDirectories(std::string const& vec,
                               cmListFileBacktrace const& lfbt);
    void ClearIncludeDirectories();

    cmStringRange GetCompileDefinitionsEntries() const;
    cmBacktraceRange GetCompileDefinitionsEntryBacktraces() const;
    void AppendCompileDefinitionsEntry(std::string const& vec,
                                       cmListFileBacktrace const& lfbt);
    void SetCompileDefinitions(std::string const& vec,
                               cmListFileBacktrace const& lfbt);
    void ClearCompileDefinitions();

    cmStringRange GetCompileOptionsEntries() const;
    cmBacktraceRange GetCompileOptionsEntryBacktraces() const;
    void AppendCompileOptionsEntry(std::string const& vec,
                                       cmListFileBacktrace const& lfbt);
    void SetCompileOptions(std::string const& vec,
                               cmListFileBacktrace const& lfbt);
    void ClearCompileOptions();

165
166
167
168
169
170
171
172
173
    void SetProperty(const std::string& prop, const char *value,
                     cmListFileBacktrace lfbt);
    void AppendProperty(const std::string& prop, const char *value,
                        bool asString, cmListFileBacktrace lfbt);
    const char *GetProperty(const std::string& prop) const;
    const char *GetProperty(const std::string& prop, bool chain) const;
    bool GetPropertyAsBool(const std::string& prop) const;
    std::vector<std::string> GetPropertyKeys() const;

174
175
176
177
178
179
180
181
182
183
  private:
    void ComputeRelativePathTopSource();
    void ComputeRelativePathTopBinary();

  private:
    cmLinkedTree<BuildsystemDirectoryStateType>::iterator DirectoryState;
    Snapshot Snapshot_;
    friend class Snapshot;
  };

184
  Snapshot CreateBaseSnapshot();
185
  Snapshot
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
  CreateBuildsystemDirectorySnapshot(Snapshot originSnapshot,
                                     std::string const& entryPointCommand,
                                     long entryPointLine);
  Snapshot CreateFunctionCallSnapshot(Snapshot originSnapshot,
                                      std::string const& entryPointCommand,
                                      long entryPointLine,
                                      std::string const& fileName);
  Snapshot CreateMacroCallSnapshot(Snapshot originSnapshot,
                                   std::string const& entryPointCommand,
                                   long entryPointLine,
                                   std::string const& fileName);
  Snapshot CreateCallStackSnapshot(Snapshot originSnapshot,
                                   std::string const& entryPointCommand,
                                   long entryPointLine,
                                   std::string const& fileName);
201
202
203
  Snapshot CreateVariableScopeSnapshot(Snapshot originSnapshot,
                                       std::string const& entryPointCommand,
                                       long entryPointLine);
204
205
206
207
  Snapshot CreateInlineListFileSnapshot(Snapshot originSnapshot,
                                        const std::string& entryPointCommand,
                                        long entryPointLine,
                                        std::string const& fileName);
208
  Snapshot CreatePolicyScopeSnapshot(Snapshot originSnapshot);
209
  Snapshot Pop(Snapshot originSnapshot);
Stephen Kelly's avatar
Stephen Kelly committed
210

211
212
213
214
  enum CacheEntryType{ BOOL=0, PATH, FILEPATH, STRING, INTERNAL,STATIC,
                       UNINITIALIZED };
  static CacheEntryType StringToCacheEntryType(const char*);
  static const char* CacheEntryTypeToString(CacheEntryType);
Stephen Kelly's avatar
Stephen Kelly committed
215
216
  static bool IsCacheEntryType(std::string const& key);

217
218
219
220
221
222
223
224
  bool LoadCache(const std::string& path, bool internal,
                 std::set<std::string>& excludes,
                 std::set<std::string>& includes);

  bool SaveCache(const std::string& path) ;

  bool DeleteCache(const std::string& path);

Stephen Kelly's avatar
Stephen Kelly committed
225
226
227
  std::vector<std::string> GetCacheEntryKeys() const;
  const char* GetCacheEntryValue(std::string const& key) const;
  const char* GetInitializedCacheValue(std::string const& key) const;
228
  CacheEntryType GetCacheEntryType(std::string const& key) const;
Stephen Kelly's avatar
Stephen Kelly committed
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
  void SetCacheEntryValue(std::string const& key, std::string const& value);
  void SetCacheValue(std::string const& key, std::string const& value);

  void RemoveCacheEntry(std::string const& key);

  void SetCacheEntryProperty(std::string const& key,
                             std::string const& propertyName,
                             std::string const& value);
  void SetCacheEntryBoolProperty(std::string const& key,
                                 std::string const& propertyName,
                                 bool value);
  const char* GetCacheEntryProperty(std::string const& key,
                                    std::string const& propertyName);
  bool GetCacheEntryPropertyAsBool(std::string const& key,
                                   std::string const& propertyName);
  void AppendCacheEntryProperty(std::string const& key,
                                const std::string& property,
                                const std::string& value,
                                bool asString = false);
  void RemoveCacheEntryProperty(std::string const& key,
                                std::string const& propertyName);

251
252
253
254
255
256
  ///! Break up a line like VAR:type="value" into var, type and value
  static bool ParseCacheEntry(const std::string& entry,
                              std::string& var,
                              std::string& value,
                              CacheEntryType& type);

257
  Snapshot Reset();
258
259
260
261
262
263
264
  // Define a property
  void DefineProperty(const std::string& name, cmProperty::ScopeType scope,
                      const char *ShortDescription,
                      const char *FullDescription,
                      bool chain = false);

  // get property definition
265
266
  cmPropertyDefinition const* GetPropertyDefinition
  (const std::string& name, cmProperty::ScopeType scope) const;
267
268

  // Is a property defined?
269
270
271
272
  bool IsPropertyDefined(const std::string& name,
                         cmProperty::ScopeType scope) const;
  bool IsPropertyChained(const std::string& name,
                         cmProperty::ScopeType scope) const;
273

274
275
276
  void SetLanguageEnabled(std::string const& l);
  bool GetLanguageEnabled(std::string const& l) const;
  std::vector<std::string> GetEnabledLanguages() const;
277
  void SetEnabledLanguages(std::vector<std::string> const& langs);
278
  void ClearEnabledLanguages();
279

280
281
282
  bool GetIsInTryCompile() const;
  void SetIsInTryCompile(bool b);

283
284
285
286
287
288
289
  cmCommand* GetCommand(std::string const& name) const;
  void AddCommand(cmCommand* command);
  void RemoveUnscriptableCommands();
  void RenameCommand(std::string const& oldName, std::string const& newName);
  void RemoveUserDefinedCommands();
  std::vector<std::string> GetCommandNames() const;

290
291
292
293
294
295
  void SetGlobalProperty(const std::string& prop, const char *value);
  void AppendGlobalProperty(const std::string& prop,
                      const char *value,bool asString=false);
  const char *GetGlobalProperty(const std::string& prop);
  bool GetGlobalPropertyAsBool(const std::string& prop);

296
297
298
299
300
  const char* GetSourceDirectory() const;
  void SetSourceDirectory(std::string const& sourceDirectory);
  const char* GetBinaryDirectory() const;
  void SetBinaryDirectory(std::string const& binaryDirectory);

301
302
303
  std::vector<std::string> const& GetSourceDirectoryComponents() const;
  std::vector<std::string> const& GetBinaryDirectoryComponents() const;

304
305
306
307
308
309
310
311
312
313
314
315
316
  void SetWindowsShell(bool windowsShell);
  bool UseWindowsShell() const;
  void SetWindowsVSIDE(bool windowsVSIDE);
  bool UseWindowsVSIDE() const;
  void SetWatcomWMake(bool watcomWMake);
  bool UseWatcomWMake() const;
  void SetMinGWMake(bool minGWMake);
  bool UseMinGWMake() const;
  void SetNMake(bool nMake);
  bool UseNMake() const;
  void SetMSYSShell(bool mSYSShell);
  bool UseMSYSShell() const;

317
318
319
  unsigned int GetCacheMajorVersion() const;
  unsigned int GetCacheMinorVersion() const;

Stephen Kelly's avatar
Stephen Kelly committed
320
private:
321
322
323
324
  friend class cmake;
  void AddCacheEntry(const std::string& key, const char* value,
                     const char* helpString, CacheEntryType type);

325
  std::map<cmProperty::ScopeType, cmPropertyDefinitionMap> PropertyDefinitions;
326
  std::vector<std::string> EnabledLanguages;
327
  std::map<std::string, cmCommand*> Commands;
328
  cmPropertyMap GlobalProperties;
329
  cmCacheManager* CacheManager;
330

331
  cmLinkedTree<BuildsystemDirectoryStateType> BuildsystemDirectory;
332

333
334
  cmLinkedTree<std::string> ExecutionListFiles;

335
  cmLinkedTree<PolicyStackEntry> PolicyStack;
336
  cmLinkedTree<SnapshotDataType> SnapshotData;
337
  cmLinkedTree<cmDefinitions> VarTree;
338

339
340
  std::vector<std::string> SourceDirectoryComponents;
  std::vector<std::string> BinaryDirectoryComponents;
341
342
  std::string SourceDirectory;
  std::string BinaryDirectory;
343
  bool IsInTryCompile;
344
345
346
347
348
349
  bool WindowsShell;
  bool WindowsVSIDE;
  bool WatcomWMake;
  bool MinGWMake;
  bool NMake;
  bool MSYSShell;
Stephen Kelly's avatar
Stephen Kelly committed
350
351
};

352
353
354
bool operator==(const cmState::Snapshot& lhs, const cmState::Snapshot& rhs);
bool operator!=(const cmState::Snapshot& lhs, const cmState::Snapshot& rhs);

Stephen Kelly's avatar
Stephen Kelly committed
355
#endif