contrib/llvm-project/clang/include/clang/Lex/PreprocessorOptions.h

   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"
  13 #include "llvm/ADT/StringRef.h"
  14 #include "llvm/ADT/StringSet.h"
  15 #include <memory>
  16 #include <set>
  17 #include <string>
  18 #include <utility>
  19 #include <vector>
  20
  21 namespace llvm {
  22
  23 class MemoryBuffer;
  24
  25 } // namespace llvm
  26
  27 namespace clang {
  28
  29 /// Enumerate the kinds of standard library that
  30 enum ObjCXXARCStandardLibraryKind {
  31   ARCXX_nolib,
  32
  33   /// libc++
  34   ARCXX_libcxx,
  35
  36   /// libstdc++
  37   ARCXX_libstdcxx
  38 };
  39
  40 /// PreprocessorOptions - This class is used for passing the various options
  41 /// used in preprocessor initialization to InitializePreprocessor().
  42 class PreprocessorOptions {
  43 public:
  44   std::vector<std::pair<std::string, bool/*isUndef*/>> Macros;
  45   std::vector<std::string> Includes;
  46   std::vector<std::string> MacroIncludes;
  47
  48   /// Initialize the preprocessor with the compiler and target specific
  49   /// predefines.
  50   bool UsePredefines = true;
  51
  52   /// Whether we should maintain a detailed record of all macro
  53   /// definitions and expansions.
  54   bool DetailedRecord = false;
  55
  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;
  59
  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;
  65
  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;
  72
  73   /// The implicit PCH included at the start of the translation unit, or empty.
  74   std::string ImplicitPCHInclude;
  75
  76   /// Headers that will be converted to chained PCHs in memory.
  77   std::vector<std::string> ChainedIncludes;
  78
  79   /// When true, disables most of the normal validation performed on
  80   /// precompiled headers.
  81   bool DisablePCHValidation = false;
  82
  83   /// When true, a PCH with compiler errors will not be rejected.
  84   bool AllowPCHWithCompilerErrors = false;
  85
  86   /// Dump declarations that are deserialized from PCH, for testing.
  87   bool DumpDeserializedPCHDecls = false;
  88
  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;
  92
  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.
  95   ///
  96   /// The boolean indicates whether the preamble ends at the start of a new
  97   /// line.
  98   std::pair<unsigned, bool> PrecompiledPreambleBytes;
  99
 100   /// True indicates that a preamble is being generated.
 101   ///
 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;
 106
 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;
 111
 112   /// When enabled, preprocessor is in a mode for parsing a single file only.
 113   ///
 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;
 118
 119   /// When enabled, the preprocessor will construct editor placeholder tokens.
 120   bool LexEditorPlaceholders = true;
 121
 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;
 125
 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
 129   /// pair).
 130   std::vector<std::pair<std::string, std::string>> RemappedFiles;
 131
 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;
 136
 137   /// Whether the compiler instance should retain (i.e., not free)
 138   /// the buffers associated with remapped files.
 139   ///
 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;
 144
 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;
 149
 150   /// Records the set of modules
 151   class FailedModulesSet {
 152     llvm::StringSet<> Failed;
 153
 154   public:
 155     bool hasAlreadyFailed(StringRef module) {
 156       return Failed.count(module) > 0;
 157     }
 158
 159     void addFailed(StringRef module) {
 160       Failed.insert(module);
 161     }
 162   };
 163
 164   /// The set of modules that failed to build.
 165   ///
 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
 169   /// build it again.
 170   std::shared_ptr<FailedModulesSet> FailedModules;
 171
 172 public:
 173   PreprocessorOptions() : PrecompiledPreambleBytes(0, false) {}
 174
 175   void addMacroDef(StringRef Name) { Macros.emplace_back(Name, false); }
 176   void addMacroUndef(StringRef Name) { Macros.emplace_back(Name, true); }
 177
 178   void addRemappedFile(StringRef From, StringRef To) {
 179     RemappedFiles.emplace_back(From, To);
 180   }
 181
 182   void addRemappedFile(StringRef From, llvm::MemoryBuffer *To) {
 183     RemappedFileBuffers.emplace_back(From, To);
 184   }
 185
 186   void clearRemappedFiles() {
 187     RemappedFiles.clear();
 188     RemappedFileBuffers.clear();
 189   }
 190
 191   /// Reset any options that are not considered when building a
 192   /// module.
 193   void resetNonModularOptions() {
 194     Includes.clear();
 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;
 204   }
 205 };
 206
 207 } // namespace clang
 208
 209 #endif // LLVM_CLANG_LEX_PREPROCESSOROPTIONS_H_