1 //===- PreprocessorOptions.h ------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #ifndef LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H_
11 #define LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H_
13 #include "clang/Basic/LLVM.h"
14 #include "llvm/ADT/StringRef.h"
15 #include "llvm/ADT/StringSet.h"
30 /// \brief Enumerate the kinds of standard library that
31 enum ObjCXXARCStandardLibraryKind {
41 /// PreprocessorOptions - This class is used for passing the various options
42 /// used in preprocessor initialization to InitializePreprocessor().
43 class PreprocessorOptions {
45 std::vector<std::pair<std::string, bool/*isUndef*/>> Macros;
46 std::vector<std::string> Includes;
47 std::vector<std::string> MacroIncludes;
49 /// \brief Initialize the preprocessor with the compiler and target specific
51 bool UsePredefines = true;
53 /// \brief Whether we should maintain a detailed record of all macro
54 /// definitions and expansions.
55 bool DetailedRecord = false;
57 /// The implicit PCH included at the start of the translation unit, or empty.
58 std::string ImplicitPCHInclude;
60 /// \brief Headers that will be converted to chained PCHs in memory.
61 std::vector<std::string> ChainedIncludes;
63 /// \brief When true, disables most of the normal validation performed on
64 /// precompiled headers.
65 bool DisablePCHValidation = false;
67 /// \brief When true, a PCH with compiler errors will not be rejected.
68 bool AllowPCHWithCompilerErrors = false;
70 /// \brief Dump declarations that are deserialized from PCH, for testing.
71 bool DumpDeserializedPCHDecls = false;
73 /// \brief This is a set of names for decls that we do not want to be
74 /// deserialized, and we emit an error if they are; for testing purposes.
75 std::set<std::string> DeserializedPCHDeclsToErrorOn;
77 /// \brief If non-zero, the implicit PCH include is actually a precompiled
78 /// preamble that covers this number of bytes in the main source file.
80 /// The boolean indicates whether the preamble ends at the start of a new
82 std::pair<unsigned, bool> PrecompiledPreambleBytes;
84 /// \brief True indicates that a preamble is being generated.
86 /// When the lexer is done, one of the things that need to be preserved is the
87 /// conditional #if stack, so the ASTWriter/ASTReader can save/restore it when
88 /// processing the rest of the file.
89 bool GeneratePreamble = false;
91 /// The implicit PTH input included at the start of the translation unit, or
93 std::string ImplicitPTHInclude;
95 /// If given, a PTH cache file to use for speeding up header parsing.
96 std::string TokenCache;
98 /// When enabled, preprocessor is in a mode for parsing a single file only.
100 /// Disables #includes of other files and if there are unresolved identifiers
101 /// in preprocessor directive conditions it causes all blocks to be parsed so
102 /// that the client can get the maximum amount of information from the parser.
103 bool SingleFileParseMode = false;
105 /// When enabled, the preprocessor will construct editor placeholder tokens.
106 bool LexEditorPlaceholders = true;
108 /// \brief True if the SourceManager should report the original file name for
109 /// contents of files that were remapped to other files. Defaults to true.
110 bool RemappedFilesKeepOriginalName = true;
112 /// \brief The set of file remappings, which take existing files on
113 /// the system (the first part of each pair) and gives them the
114 /// contents of other files on the system (the second part of each
116 std::vector<std::pair<std::string, std::string>> RemappedFiles;
118 /// \brief The set of file-to-buffer remappings, which take existing files
119 /// on the system (the first part of each pair) and gives them the contents
120 /// of the specified memory buffer (the second part of each pair).
121 std::vector<std::pair<std::string, llvm::MemoryBuffer *>> RemappedFileBuffers;
123 /// \brief Whether the compiler instance should retain (i.e., not free)
124 /// the buffers associated with remapped files.
126 /// This flag defaults to false; it can be set true only through direct
127 /// manipulation of the compiler invocation object, in cases where the
128 /// compiler invocation and its buffers will be reused.
129 bool RetainRemappedFileBuffers = false;
131 /// \brief The Objective-C++ ARC standard library that we should support,
132 /// by providing appropriate definitions to retrofit the standard library
133 /// with support for lifetime-qualified pointers.
134 ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary = ARCXX_nolib;
136 /// \brief Records the set of modules
137 class FailedModulesSet {
138 llvm::StringSet<> Failed;
141 bool hasAlreadyFailed(StringRef module) {
142 return Failed.count(module) > 0;
145 void addFailed(StringRef module) {
146 Failed.insert(module);
150 /// \brief The set of modules that failed to build.
152 /// This pointer will be shared among all of the compiler instances created
153 /// to (re)build modules, so that once a module fails to build anywhere,
154 /// other instances will see that the module has failed and won't try to
156 std::shared_ptr<FailedModulesSet> FailedModules;
159 PreprocessorOptions() : PrecompiledPreambleBytes(0, false) {}
161 void addMacroDef(StringRef Name) { Macros.emplace_back(Name, false); }
162 void addMacroUndef(StringRef Name) { Macros.emplace_back(Name, true); }
164 void addRemappedFile(StringRef From, StringRef To) {
165 RemappedFiles.emplace_back(From, To);
168 void addRemappedFile(StringRef From, llvm::MemoryBuffer *To) {
169 RemappedFileBuffers.emplace_back(From, To);
172 void clearRemappedFiles() {
173 RemappedFiles.clear();
174 RemappedFileBuffers.clear();
177 /// \brief Reset any options that are not considered when building a
179 void resetNonModularOptions() {
181 MacroIncludes.clear();
182 ChainedIncludes.clear();
183 DumpDeserializedPCHDecls = false;
184 ImplicitPCHInclude.clear();
185 ImplicitPTHInclude.clear();
187 SingleFileParseMode = false;
188 LexEditorPlaceholders = true;
189 RetainRemappedFileBuffers = true;
190 PrecompiledPreambleBytes.first = 0;
191 PrecompiledPreambleBytes.second = false;
197 #endif // LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H_