1 //===- PreprocessorOptions.h ------------------------------------*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
9 #ifndef LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H_
10 #define LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H_
12 #include "clang/Basic/LLVM.h"
13 #include "llvm/ADT/StringRef.h"
14 #include "llvm/ADT/StringSet.h"
29 /// Enumerate the kinds of standard library that
30 enum ObjCXXARCStandardLibraryKind {
40 /// PreprocessorOptions - This class is used for passing the various options
41 /// used in preprocessor initialization to InitializePreprocessor().
42 class PreprocessorOptions {
44 std::vector<std::pair<std::string, bool/*isUndef*/>> Macros;
45 std::vector<std::string> Includes;
46 std::vector<std::string> MacroIncludes;
48 /// Initialize the preprocessor with the compiler and target specific
50 bool UsePredefines = true;
52 /// Whether we should maintain a detailed record of all macro
53 /// definitions and expansions.
54 bool DetailedRecord = false;
56 /// When true, we are creating or using a PCH where a #pragma hdrstop is
57 /// expected to indicate the beginning or end of the PCH.
58 bool PCHWithHdrStop = false;
60 /// When true, we are creating a PCH or creating the PCH object while
61 /// expecting a #pragma hdrstop to separate the two. Allow for a
62 /// missing #pragma hdrstop, which generates a PCH for the whole file,
63 /// and creates an empty PCH object.
64 bool PCHWithHdrStopCreate = false;
66 /// If non-empty, the filename used in an #include directive in the primary
67 /// source file (or command-line preinclude) that is used to implement
68 /// MSVC-style precompiled headers. When creating a PCH, after the #include
69 /// of this header, the PCH generation stops. When using a PCH, tokens are
70 /// skipped until after an #include of this header is seen.
71 std::string PCHThroughHeader;
73 /// The implicit PCH included at the start of the translation unit, or empty.
74 std::string ImplicitPCHInclude;
76 /// Headers that will be converted to chained PCHs in memory.
77 std::vector<std::string> ChainedIncludes;
79 /// When true, disables most of the normal validation performed on
80 /// precompiled headers.
81 bool DisablePCHValidation = false;
83 /// When true, a PCH with compiler errors will not be rejected.
84 bool AllowPCHWithCompilerErrors = false;
86 /// Dump declarations that are deserialized from PCH, for testing.
87 bool DumpDeserializedPCHDecls = false;
89 /// This is a set of names for decls that we do not want to be
90 /// deserialized, and we emit an error if they are; for testing purposes.
91 std::set<std::string> DeserializedPCHDeclsToErrorOn;
93 /// If non-zero, the implicit PCH include is actually a precompiled
94 /// preamble that covers this number of bytes in the main source file.
96 /// The boolean indicates whether the preamble ends at the start of a new
98 std::pair<unsigned, bool> PrecompiledPreambleBytes;
100 /// True indicates that a preamble is being generated.
102 /// When the lexer is done, one of the things that need to be preserved is the
103 /// conditional #if stack, so the ASTWriter/ASTReader can save/restore it when
104 /// processing the rest of the file.
105 bool GeneratePreamble = false;
107 /// Whether to write comment locations into the PCH when building it.
108 /// Reading the comments from the PCH can be a performance hit even if the
109 /// clients don't use them.
110 bool WriteCommentListToPCH = true;
112 /// When enabled, preprocessor is in a mode for parsing a single file only.
114 /// Disables #includes of other files and if there are unresolved identifiers
115 /// in preprocessor directive conditions it causes all blocks to be parsed so
116 /// that the client can get the maximum amount of information from the parser.
117 bool SingleFileParseMode = false;
119 /// When enabled, the preprocessor will construct editor placeholder tokens.
120 bool LexEditorPlaceholders = true;
122 /// True if the SourceManager should report the original file name for
123 /// contents of files that were remapped to other files. Defaults to true.
124 bool RemappedFilesKeepOriginalName = true;
126 /// The set of file remappings, which take existing files on
127 /// the system (the first part of each pair) and gives them the
128 /// contents of other files on the system (the second part of each
130 std::vector<std::pair<std::string, std::string>> RemappedFiles;
132 /// The set of file-to-buffer remappings, which take existing files
133 /// on the system (the first part of each pair) and gives them the contents
134 /// of the specified memory buffer (the second part of each pair).
135 std::vector<std::pair<std::string, llvm::MemoryBuffer *>> RemappedFileBuffers;
137 /// Whether the compiler instance should retain (i.e., not free)
138 /// the buffers associated with remapped files.
140 /// This flag defaults to false; it can be set true only through direct
141 /// manipulation of the compiler invocation object, in cases where the
142 /// compiler invocation and its buffers will be reused.
143 bool RetainRemappedFileBuffers = false;
145 /// The Objective-C++ ARC standard library that we should support,
146 /// by providing appropriate definitions to retrofit the standard library
147 /// with support for lifetime-qualified pointers.
148 ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary = ARCXX_nolib;
150 /// Records the set of modules
151 class FailedModulesSet {
152 llvm::StringSet<> Failed;
155 bool hasAlreadyFailed(StringRef module) {
156 return Failed.count(module) > 0;
159 void addFailed(StringRef module) {
160 Failed.insert(module);
164 /// The set of modules that failed to build.
166 /// This pointer will be shared among all of the compiler instances created
167 /// to (re)build modules, so that once a module fails to build anywhere,
168 /// other instances will see that the module has failed and won't try to
170 std::shared_ptr<FailedModulesSet> FailedModules;
173 PreprocessorOptions() : PrecompiledPreambleBytes(0, false) {}
175 void addMacroDef(StringRef Name) { Macros.emplace_back(Name, false); }
176 void addMacroUndef(StringRef Name) { Macros.emplace_back(Name, true); }
178 void addRemappedFile(StringRef From, StringRef To) {
179 RemappedFiles.emplace_back(From, To);
182 void addRemappedFile(StringRef From, llvm::MemoryBuffer *To) {
183 RemappedFileBuffers.emplace_back(From, To);
186 void clearRemappedFiles() {
187 RemappedFiles.clear();
188 RemappedFileBuffers.clear();
191 /// Reset any options that are not considered when building a
193 void resetNonModularOptions() {
195 MacroIncludes.clear();
196 ChainedIncludes.clear();
197 DumpDeserializedPCHDecls = false;
198 ImplicitPCHInclude.clear();
199 SingleFileParseMode = false;
200 LexEditorPlaceholders = true;
201 RetainRemappedFileBuffers = true;
202 PrecompiledPreambleBytes.first = 0;
203 PrecompiledPreambleBytes.second = false;
209 #endif // LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H_