clang  10.0.0git
PreprocessorOptions.h
Go to the documentation of this file.
1 //===- PreprocessorOptions.h ------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #ifndef LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H_
10 #define LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H_
11 
12 #include "clang/Basic/LLVM.h"
14 #include "llvm/ADT/StringRef.h"
15 #include "llvm/ADT/StringSet.h"
16 #include <functional>
17 #include <map>
18 #include <memory>
19 #include <set>
20 #include <string>
21 #include <utility>
22 #include <vector>
23 
24 namespace llvm {
25 
26 class MemoryBuffer;
27 
28 } // namespace llvm
29 
30 namespace clang {
31 
32 /// Enumerate the kinds of standard library that
35 
36  /// libc++
38 
39  /// libstdc++
41 };
42 
43 /// PreprocessorOptions - This class is used for passing the various options
44 /// used in preprocessor initialization to InitializePreprocessor().
46 public:
47  std::vector<std::pair<std::string, bool/*isUndef*/>> Macros;
48  std::vector<std::string> Includes;
49  std::vector<std::string> MacroIncludes;
50 
51  /// Initialize the preprocessor with the compiler and target specific
52  /// predefines.
53  bool UsePredefines = true;
54 
55  /// Whether we should maintain a detailed record of all macro
56  /// definitions and expansions.
57  bool DetailedRecord = false;
58 
59  /// When true, we are creating or using a PCH where a #pragma hdrstop is
60  /// expected to indicate the beginning or end of the PCH.
61  bool PCHWithHdrStop = false;
62 
63  /// When true, we are creating a PCH or creating the PCH object while
64  /// expecting a #pragma hdrstop to separate the two. Allow for a
65  /// missing #pragma hdrstop, which generates a PCH for the whole file,
66  /// and creates an empty PCH object.
67  bool PCHWithHdrStopCreate = false;
68 
69  /// If non-empty, the filename used in an #include directive in the primary
70  /// source file (or command-line preinclude) that is used to implement
71  /// MSVC-style precompiled headers. When creating a PCH, after the #include
72  /// of this header, the PCH generation stops. When using a PCH, tokens are
73  /// skipped until after an #include of this header is seen.
74  std::string PCHThroughHeader;
75 
76  /// The implicit PCH included at the start of the translation unit, or empty.
77  std::string ImplicitPCHInclude;
78 
79  /// Headers that will be converted to chained PCHs in memory.
80  std::vector<std::string> ChainedIncludes;
81 
82  /// When true, disables most of the normal validation performed on
83  /// precompiled headers.
84  bool DisablePCHValidation = false;
85 
86  /// When true, a PCH with compiler errors will not be rejected.
87  bool AllowPCHWithCompilerErrors = false;
88 
89  /// Dump declarations that are deserialized from PCH, for testing.
90  bool DumpDeserializedPCHDecls = false;
91 
92  /// This is a set of names for decls that we do not want to be
93  /// deserialized, and we emit an error if they are; for testing purposes.
94  std::set<std::string> DeserializedPCHDeclsToErrorOn;
95 
96  /// If non-zero, the implicit PCH include is actually a precompiled
97  /// preamble that covers this number of bytes in the main source file.
98  ///
99  /// The boolean indicates whether the preamble ends at the start of a new
100  /// line.
101  std::pair<unsigned, bool> PrecompiledPreambleBytes;
102 
103  /// True indicates that a preamble is being generated.
104  ///
105  /// When the lexer is done, one of the things that need to be preserved is the
106  /// conditional #if stack, so the ASTWriter/ASTReader can save/restore it when
107  /// processing the rest of the file.
108  bool GeneratePreamble = false;
109 
110  /// Whether to write comment locations into the PCH when building it.
111  /// Reading the comments from the PCH can be a performance hit even if the
112  /// clients don't use them.
113  bool WriteCommentListToPCH = true;
114 
115  /// When enabled, preprocessor is in a mode for parsing a single file only.
116  ///
117  /// Disables #includes of other files and if there are unresolved identifiers
118  /// in preprocessor directive conditions it causes all blocks to be parsed so
119  /// that the client can get the maximum amount of information from the parser.
120  bool SingleFileParseMode = false;
121 
122  /// When enabled, the preprocessor will construct editor placeholder tokens.
123  bool LexEditorPlaceholders = true;
124 
125  /// True if the SourceManager should report the original file name for
126  /// contents of files that were remapped to other files. Defaults to true.
127  bool RemappedFilesKeepOriginalName = true;
128 
129  /// The set of file remappings, which take existing files on
130  /// the system (the first part of each pair) and gives them the
131  /// contents of other files on the system (the second part of each
132  /// pair).
133  std::vector<std::pair<std::string, std::string>> RemappedFiles;
134 
135  /// The set of file-to-buffer remappings, which take existing files
136  /// on the system (the first part of each pair) and gives them the contents
137  /// of the specified memory buffer (the second part of each pair).
138  std::vector<std::pair<std::string, llvm::MemoryBuffer *>> RemappedFileBuffers;
139 
140  /// Whether the compiler instance should retain (i.e., not free)
141  /// the buffers associated with remapped files.
142  ///
143  /// This flag defaults to false; it can be set true only through direct
144  /// manipulation of the compiler invocation object, in cases where the
145  /// compiler invocation and its buffers will be reused.
146  bool RetainRemappedFileBuffers = false;
147 
148  /// When enabled, excluded conditional blocks retain in the main file.
149  bool RetainExcludedConditionalBlocks = false;
150 
151  /// The Objective-C++ ARC standard library that we should support,
152  /// by providing appropriate definitions to retrofit the standard library
153  /// with support for lifetime-qualified pointers.
154  ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary = ARCXX_nolib;
155 
156  /// Records the set of modules
158  llvm::StringSet<> Failed;
159 
160  public:
161  bool hasAlreadyFailed(StringRef module) {
162  return Failed.count(module) > 0;
163  }
164 
165  void addFailed(StringRef module) {
166  Failed.insert(module);
167  }
168  };
169 
170  /// The set of modules that failed to build.
171  ///
172  /// This pointer will be shared among all of the compiler instances created
173  /// to (re)build modules, so that once a module fails to build anywhere,
174  /// other instances will see that the module has failed and won't try to
175  /// build it again.
176  std::shared_ptr<FailedModulesSet> FailedModules;
177 
178  /// A prefix map for __FILE__ and __BASE_FILE__.
179  std::map<std::string, std::string, std::greater<std::string>> MacroPrefixMap;
180 
181  /// Contains the currently active skipped range mappings for skipping excluded
182  /// conditional directives.
183  ///
184  /// The pointer is passed to the Preprocessor when it's constructed. The
185  /// pointer is unowned, the client is responsible for its lifetime.
187  *ExcludedConditionalDirectiveSkipMappings = nullptr;
188 
189  /// Set up preprocessor for RunAnalysis action.
190  bool SetUpStaticAnalyzer = false;
191 
192  /// Prevents intended crashes when using #pragma clang __debug. For testing.
193  bool DisablePragmaDebugCrash = false;
194 
195 public:
196  PreprocessorOptions() : PrecompiledPreambleBytes(0, false) {}
197 
198  void addMacroDef(StringRef Name) { Macros.emplace_back(Name, false); }
199  void addMacroUndef(StringRef Name) { Macros.emplace_back(Name, true); }
200 
201  void addRemappedFile(StringRef From, StringRef To) {
202  RemappedFiles.emplace_back(From, To);
203  }
204 
205  void addRemappedFile(StringRef From, llvm::MemoryBuffer *To) {
206  RemappedFileBuffers.emplace_back(From, To);
207  }
208 
210  RemappedFiles.clear();
211  RemappedFileBuffers.clear();
212  }
213 
214  /// Reset any options that are not considered when building a
215  /// module.
217  Includes.clear();
218  MacroIncludes.clear();
219  ChainedIncludes.clear();
220  DumpDeserializedPCHDecls = false;
221  ImplicitPCHInclude.clear();
222  SingleFileParseMode = false;
223  LexEditorPlaceholders = true;
224  RetainRemappedFileBuffers = true;
225  PrecompiledPreambleBytes.first = 0;
226  PrecompiledPreambleBytes.second = false;
227  RetainExcludedConditionalBlocks = false;
228  }
229 };
230 
231 } // namespace clang
232 
233 #endif // LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H_
std::vector< std::pair< std::string, bool > > Macros
void addMacroUndef(StringRef Name)
ObjCXXARCStandardLibraryKind
Enumerate the kinds of standard library that.
Specialize PointerLikeTypeTraits to allow LazyGenerationalUpdatePtr to be placed into a PointerUnion...
Definition: Dominators.h:30
std::vector< std::string > Includes
PreprocessorOptions - This class is used for passing the various options used in preprocessor initial...
std::shared_ptr< FailedModulesSet > FailedModules
The set of modules that failed to build.
void addRemappedFile(StringRef From, StringRef To)
void addRemappedFile(StringRef From, llvm::MemoryBuffer *To)
std::map< std::string, std::string, std::greater< std::string > > MacroPrefixMap
A prefix map for FILE and BASE_FILE.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
std::vector< std::pair< std::string, llvm::MemoryBuffer * > > RemappedFileBuffers
The set of file-to-buffer remappings, which take existing files on the system (the first part of each...
std::vector< std::string > ChainedIncludes
Headers that will be converted to chained PCHs in memory.
std::set< std::string > DeserializedPCHDeclsToErrorOn
This is a set of names for decls that we do not want to be deserialized, and we emit an error if they...
#define false
Definition: stdbool.h:17
std::string ImplicitPCHInclude
The implicit PCH included at the start of the translation unit, or empty.
void resetNonModularOptions()
Reset any options that are not considered when building a module.
std::string PCHThroughHeader
If non-empty, the filename used in an #include directive in the primary source file (or command-line ...
void addMacroDef(StringRef Name)
std::vector< std::string > MacroIncludes
Dataflow Directional Tag Classes.
std::vector< std::pair< std::string, std::string > > RemappedFiles
The set of file remappings, which take existing files on the system (the first part of each pair) and...
std::pair< unsigned, bool > PrecompiledPreambleBytes
If non-zero, the implicit PCH include is actually a precompiled preamble that covers this number of b...
llvm::DenseMap< const llvm::MemoryBuffer *, const PreprocessorSkippedRangeMapping * > ExcludedPreprocessorDirectiveSkipMapping
The datastructure that holds the mapping between the active memory buffers and the individual skip ma...