contrib/llvm/tools/clang/include/clang/Lex/PreprocessorOptions.h

   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:
 156     bool hasAlreadyFailed(StringRef module) {
 157       return Failed.count(module) > 0;
 158     }
 159
 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:
 174   PreprocessorOptions() : PrecompiledPreambleBytes(0, false) {}
 175
 176   void addMacroDef(StringRef Name) { Macros.emplace_back(Name, false); }
 177   void addMacroUndef(StringRef Name) { Macros.emplace_back(Name, true); }
 178
 179   void addRemappedFile(StringRef From, StringRef To) {
 180     RemappedFiles.emplace_back(From, To);
 181   }
 182
 183   void addRemappedFile(StringRef From, llvm::MemoryBuffer *To) {
 184     RemappedFileBuffers.emplace_back(From, To);
 185   }
 186
 187   void clearRemappedFiles() {
 188     RemappedFiles.clear();
 189     RemappedFileBuffers.clear();
 190   }
 191
 192   /// Reset any options that are not considered when building a
 193   /// module.
 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_