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/SourceLocation.h"
  14 #include "llvm/ADT/IntrusiveRefCntPtr.h"
  15 #include "llvm/ADT/StringRef.h"
  16 #include "llvm/ADT/StringSet.h"
  17 #include <cassert>
  18 #include <set>
  19 #include <string>
  20 #include <utility>
  21 #include <vector>
  22
  23 namespace llvm {
  24   class MemoryBuffer;
  25 }
  26
  27 namespace clang {
  28
  29 class Preprocessor;
  30 class LangOptions;
  31
  32 /// \brief Enumerate the kinds of standard library that
  33 enum ObjCXXARCStandardLibraryKind {
  34   ARCXX_nolib,
  35   /// \brief libc++
  36   ARCXX_libcxx,
  37   /// \brief 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 : public RefCountedBase<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   /// \brief Initialize the preprocessor with the compiler and target specific
  50   /// predefines.
  51   unsigned UsePredefines : 1;
  52
  53   /// \brief Whether we should maintain a detailed record of all macro
  54   /// definitions and expansions.
  55   unsigned DetailedRecord : 1;
  56
  57   /// The implicit PCH included at the start of the translation unit, or empty.
  58   std::string ImplicitPCHInclude;
  59
  60   /// \brief Headers that will be converted to chained PCHs in memory.
  61   std::vector<std::string> ChainedIncludes;
  62
  63   /// \brief When true, disables most of the normal validation performed on
  64   /// precompiled headers.
  65   bool DisablePCHValidation;
  66
  67   /// \brief When true, a PCH with compiler errors will not be rejected.
  68   bool AllowPCHWithCompilerErrors;
  69
  70   /// \brief Dump declarations that are deserialized from PCH, for testing.
  71   bool DumpDeserializedPCHDecls;
  72
  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;
  76
  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.
  79   ///
  80   /// The boolean indicates whether the preamble ends at the start of a new
  81   /// line.
  82   std::pair<unsigned, bool> PrecompiledPreambleBytes;
  83
  84   /// The implicit PTH input included at the start of the translation unit, or
  85   /// empty.
  86   std::string ImplicitPTHInclude;
  87
  88   /// If given, a PTH cache file to use for speeding up header parsing.
  89   std::string TokenCache;
  90
  91   /// \brief True if the SourceManager should report the original file name for
  92   /// contents of files that were remapped to other files. Defaults to true.
  93   bool RemappedFilesKeepOriginalName;
  94
  95   /// \brief The set of file remappings, which take existing files on
  96   /// the system (the first part of each pair) and gives them the
  97   /// contents of other files on the system (the second part of each
  98   /// pair).
  99   std::vector<std::pair<std::string, std::string>> RemappedFiles;
 100
 101   /// \brief The set of file-to-buffer remappings, which take existing files
 102   /// on the system (the first part of each pair) and gives them the contents
 103   /// of the specified memory buffer (the second part of each pair).
 104   std::vector<std::pair<std::string, llvm::MemoryBuffer *>> RemappedFileBuffers;
 105
 106   /// \brief Whether the compiler instance should retain (i.e., not free)
 107   /// the buffers associated with remapped files.
 108   ///
 109   /// This flag defaults to false; it can be set true only through direct
 110   /// manipulation of the compiler invocation object, in cases where the
 111   /// compiler invocation and its buffers will be reused.
 112   bool RetainRemappedFileBuffers;
 113
 114   /// \brief The Objective-C++ ARC standard library that we should support,
 115   /// by providing appropriate definitions to retrofit the standard library
 116   /// with support for lifetime-qualified pointers.
 117   ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary;
 118
 119   /// \brief Records the set of modules
 120   class FailedModulesSet : public RefCountedBase<FailedModulesSet> {
 121     llvm::StringSet<> Failed;
 122
 123   public:
 124     bool hasAlreadyFailed(StringRef module) {
 125       return Failed.count(module) > 0;
 126     }
 127
 128     void addFailed(StringRef module) {
 129       Failed.insert(module);
 130     }
 131   };
 132
 133   /// \brief The set of modules that failed to build.
 134   ///
 135   /// This pointer will be shared among all of the compiler instances created
 136   /// to (re)build modules, so that once a module fails to build anywhere,
 137   /// other instances will see that the module has failed and won't try to
 138   /// build it again.
 139   IntrusiveRefCntPtr<FailedModulesSet> FailedModules;
 140
 141 public:
 142   PreprocessorOptions() : UsePredefines(true), DetailedRecord(false),
 143                           DisablePCHValidation(false),
 144                           AllowPCHWithCompilerErrors(false),
 145                           DumpDeserializedPCHDecls(false),
 146                           PrecompiledPreambleBytes(0, true),
 147                           RemappedFilesKeepOriginalName(true),
 148                           RetainRemappedFileBuffers(false),
 149                           ObjCXXARCStandardLibrary(ARCXX_nolib) { }
 150
 151   void addMacroDef(StringRef Name) { Macros.emplace_back(Name, false); }
 152   void addMacroUndef(StringRef Name) { Macros.emplace_back(Name, true); }
 153   void addRemappedFile(StringRef From, StringRef To) {
 154     RemappedFiles.emplace_back(From, To);
 155   }
 156
 157   void addRemappedFile(StringRef From, llvm::MemoryBuffer *To) {
 158     RemappedFileBuffers.emplace_back(From, To);
 159   }
 160
 161   void clearRemappedFiles() {
 162     RemappedFiles.clear();
 163     RemappedFileBuffers.clear();
 164   }
 165
 166   /// \brief Reset any options that are not considered when building a
 167   /// module.
 168   void resetNonModularOptions() {
 169     Includes.clear();
 170     MacroIncludes.clear();
 171     ChainedIncludes.clear();
 172     DumpDeserializedPCHDecls = false;
 173     ImplicitPCHInclude.clear();
 174     ImplicitPTHInclude.clear();
 175     TokenCache.clear();
 176     RetainRemappedFileBuffers = true;
 177     PrecompiledPreambleBytes.first = 0;
 178     PrecompiledPreambleBytes.second = 0;
 179   }
 180 };
 181
 182 } // end namespace clang
 183
 184 #endif