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