Warning: This file is not a C or C++ file. It does not have highlighting.

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/BitmaskEnum.h"
13#include "clang/Basic/FileEntry.h"
14#include "clang/Basic/LLVM.h"
15#include "clang/Lex/DependencyDirectivesScanner.h"
16#include "llvm/ADT/StringRef.h"
17#include "llvm/ADT/StringSet.h"
18#include <functional>
19#include <map>
20#include <memory>
21#include <set>
22#include <string>
23#include <utility>
24#include <vector>
25
26namespace llvm {
27
28class MemoryBuffer;
29
30} // namespace llvm
31
32namespace clang {
33
34/// Enumerate the kinds of standard library that
35enum ObjCXXARCStandardLibraryKind {
36 ARCXX_nolib,
37
38 /// libc++
39 ARCXX_libcxx,
40
41 /// libstdc++
42 ARCXX_libstdcxx
43};
44
45/// Whether to disable the normal validation performed on precompiled
46/// headers and module files when they are loaded.
47enum class DisableValidationForModuleKind {
48 /// Perform validation, don't disable it.
49 None = 0,
50
51 /// Disable validation for a precompiled header and the modules it depends on.
52 PCH = 0x1,
53
54 /// Disable validation for module files.
55 Module = 0x2,
56
57 /// Disable validation for all kinds.
58 All = PCH | Module,
59
60 LLVM_MARK_AS_BITMASK_ENUM(Module)
61};
62
63/// PreprocessorOptions - This class is used for passing the various options
64/// used in preprocessor initialization to InitializePreprocessor().
65class PreprocessorOptions {
66public:
67 std::vector<std::pair<std::string, bool/*isUndef*/>> Macros;
68 std::vector<std::string> Includes;
69 std::vector<std::string> MacroIncludes;
70
71 /// Initialize the preprocessor with the compiler and target specific
72 /// predefines.
73 bool UsePredefines = true;
74
75 /// Whether we should maintain a detailed record of all macro
76 /// definitions and expansions.
77 bool DetailedRecord = false;
78
79 /// When true, we are creating or using a PCH where a #pragma hdrstop is
80 /// expected to indicate the beginning or end of the PCH.
81 bool PCHWithHdrStop = false;
82
83 /// When true, we are creating a PCH or creating the PCH object while
84 /// expecting a #pragma hdrstop to separate the two. Allow for a
85 /// missing #pragma hdrstop, which generates a PCH for the whole file,
86 /// and creates an empty PCH object.
87 bool PCHWithHdrStopCreate = false;
88
89 /// If non-empty, the filename used in an #include directive in the primary
90 /// source file (or command-line preinclude) that is used to implement
91 /// MSVC-style precompiled headers. When creating a PCH, after the #include
92 /// of this header, the PCH generation stops. When using a PCH, tokens are
93 /// skipped until after an #include of this header is seen.
94 std::string PCHThroughHeader;
95
96 /// The implicit PCH included at the start of the translation unit, or empty.
97 std::string ImplicitPCHInclude;
98
99 /// Headers that will be converted to chained PCHs in memory.
100 std::vector<std::string> ChainedIncludes;
101
102 /// Whether to disable most of the normal validation performed on
103 /// precompiled headers and module files.
104 DisableValidationForModuleKind DisablePCHOrModuleValidation =
105 DisableValidationForModuleKind::None;
106
107 /// When true, a PCH with compiler errors will not be rejected.
108 bool AllowPCHWithCompilerErrors = false;
109
110 /// When true, a PCH with modules cache path different to the current
111 /// compilation will not be rejected.
112 bool AllowPCHWithDifferentModulesCachePath = false;
113
114 /// Dump declarations that are deserialized from PCH, for testing.
115 bool DumpDeserializedPCHDecls = false;
116
117 /// This is a set of names for decls that we do not want to be
118 /// deserialized, and we emit an error if they are; for testing purposes.
119 std::set<std::string> DeserializedPCHDeclsToErrorOn;
120
121 /// If non-zero, the implicit PCH include is actually a precompiled
122 /// preamble that covers this number of bytes in the main source file.
123 ///
124 /// The boolean indicates whether the preamble ends at the start of a new
125 /// line.
126 std::pair<unsigned, bool> PrecompiledPreambleBytes;
127
128 /// True indicates that a preamble is being generated.
129 ///
130 /// When the lexer is done, one of the things that need to be preserved is the
131 /// conditional #if stack, so the ASTWriter/ASTReader can save/restore it when
132 /// processing the rest of the file. Similarly, we track an unterminated
133 /// #pragma assume_nonnull.
134 bool GeneratePreamble = false;
135
136 /// Whether to write comment locations into the PCH when building it.
137 /// Reading the comments from the PCH can be a performance hit even if the
138 /// clients don't use them.
139 bool WriteCommentListToPCH = true;
140
141 /// When enabled, preprocessor is in a mode for parsing a single file only.
142 ///
143 /// Disables #includes of other files and if there are unresolved identifiers
144 /// in preprocessor directive conditions it causes all blocks to be parsed so
145 /// that the client can get the maximum amount of information from the parser.
146 bool SingleFileParseMode = false;
147
148 /// When enabled, the preprocessor will construct editor placeholder tokens.
149 bool LexEditorPlaceholders = true;
150
151 /// True if the SourceManager should report the original file name for
152 /// contents of files that were remapped to other files. Defaults to true.
153 bool RemappedFilesKeepOriginalName = true;
154
155 /// The set of file remappings, which take existing files on
156 /// the system (the first part of each pair) and gives them the
157 /// contents of other files on the system (the second part of each
158 /// pair).
159 std::vector<std::pair<std::string, std::string>> RemappedFiles;
160
161 /// The set of file-to-buffer remappings, which take existing files
162 /// on the system (the first part of each pair) and gives them the contents
163 /// of the specified memory buffer (the second part of each pair).
164 std::vector<std::pair<std::string, llvm::MemoryBuffer *>> RemappedFileBuffers;
165
166 /// Whether the compiler instance should retain (i.e., not free)
167 /// the buffers associated with remapped files.
168 ///
169 /// This flag defaults to false; it can be set true only through direct
170 /// manipulation of the compiler invocation object, in cases where the
171 /// compiler invocation and its buffers will be reused.
172 bool RetainRemappedFileBuffers = false;
173
174 /// When enabled, excluded conditional blocks retain in the main file.
175 bool RetainExcludedConditionalBlocks = false;
176
177 /// The Objective-C++ ARC standard library that we should support,
178 /// by providing appropriate definitions to retrofit the standard library
179 /// with support for lifetime-qualified pointers.
180 ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary = ARCXX_nolib;
181
182 /// Records the set of modules
183 class FailedModulesSet {
184 llvm::StringSet<> Failed;
185
186 public:
187 bool hasAlreadyFailed(StringRef module) {
188 return Failed.count(module) > 0;
189 }
190
191 void addFailed(StringRef module) {
192 Failed.insert(module);
193 }
194 };
195
196 /// The set of modules that failed to build.
197 ///
198 /// This pointer will be shared among all of the compiler instances created
199 /// to (re)build modules, so that once a module fails to build anywhere,
200 /// other instances will see that the module has failed and won't try to
201 /// build it again.
202 std::shared_ptr<FailedModulesSet> FailedModules;
203
204 /// Function for getting the dependency preprocessor directives of a file.
205 ///
206 /// These are directives derived from a special form of lexing where the
207 /// source input is scanned for the preprocessor directives that might have an
208 /// effect on the dependencies for a compilation unit.
209 ///
210 /// Enables a client to cache the directives for a file and provide them
211 /// across multiple compiler invocations.
212 /// FIXME: Allow returning an error.
213 std::function<Optional<ArrayRef<dependency_directives_scan::Directive>>(
214 FileEntryRef)>
215 DependencyDirectivesForFile;
216
217 /// Set up preprocessor for RunAnalysis action.
218 bool SetUpStaticAnalyzer = false;
219
220 /// Prevents intended crashes when using #pragma clang __debug. For testing.
221 bool DisablePragmaDebugCrash = false;
222
223public:
224 PreprocessorOptions() : PrecompiledPreambleBytes(0, false) {}
225
226 void addMacroDef(StringRef Name) {
227 Macros.emplace_back(std::string(Name), false);
228 }
229 void addMacroUndef(StringRef Name) {
230 Macros.emplace_back(std::string(Name), true);
231 }
232
233 void addRemappedFile(StringRef From, StringRef To) {
234 RemappedFiles.emplace_back(std::string(From), std::string(To));
235 }
236
237 void addRemappedFile(StringRef From, llvm::MemoryBuffer *To) {
238 RemappedFileBuffers.emplace_back(std::string(From), To);
239 }
240
241 void clearRemappedFiles() {
242 RemappedFiles.clear();
243 RemappedFileBuffers.clear();
244 }
245
246 /// Reset any options that are not considered when building a
247 /// module.
248 void resetNonModularOptions() {
249 Includes.clear();
250 MacroIncludes.clear();
251 ChainedIncludes.clear();
252 DumpDeserializedPCHDecls = false;
253 ImplicitPCHInclude.clear();
254 SingleFileParseMode = false;
255 LexEditorPlaceholders = true;
256 RetainRemappedFileBuffers = true;
257 PrecompiledPreambleBytes.first = 0;
258 PrecompiledPreambleBytes.second = false;
259 RetainExcludedConditionalBlocks = false;
260 }
261};
262
263} // namespace clang
264
265#endif // LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H_
266

Warning: This file is not a C or C++ file. It does not have highlighting.

source code of clang/include/clang/Lex/PreprocessorOptions.h