contrib/llvm/tools/clang/include/clang/Frontend/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_FRONTEND_PREPROCESSOROPTIONS_H_
  11 #define LLVM_CLANG_FRONTEND_PREPROCESSOROPTIONS_H_
  12
  13 #include "llvm/ADT/StringRef.h"
  14 #include <cassert>
  15 #include <string>
  16 #include <utility>
  17 #include <vector>
  18 #include <set>
  19
  20 namespace llvm {
  21   class MemoryBuffer;
  22 }
  23
  24 namespace clang {
  25
  26 class Preprocessor;
  27 class LangOptions;
  28
  29 /// \brief Enumerate the kinds of standard library that
  30 enum ObjCXXARCStandardLibraryKind {
  31   ARCXX_nolib,
  32   /// \brief libc++
  33   ARCXX_libcxx,
  34   /// \brief libstdc++
  35   ARCXX_libstdcxx
  36 };
  37
  38 /// PreprocessorOptions - This class is used for passing the various options
  39 /// used in preprocessor initialization to InitializePreprocessor().
  40 class PreprocessorOptions {
  41 public:
  42   std::vector<std::pair<std::string, bool/*isUndef*/> > Macros;
  43   std::vector<std::string> Includes;
  44   std::vector<std::string> MacroIncludes;
  45
  46   unsigned UsePredefines : 1; /// Initialize the preprocessor with the compiler
  47                               /// and target specific predefines.
  48
  49   unsigned DetailedRecord : 1; /// Whether we should maintain a detailed
  50                                /// record of all macro definitions and
  51                                /// expansions.
  52
  53   /// \brief Whether we should automatically translate #include or #import
  54   /// operations into module imports when possible.
  55   unsigned AutoModuleImport : 1;
  56
  57   /// \brief Whether the detailed preprocessing record includes nested macro
  58   /// expansions.
  59   unsigned DetailedRecordIncludesNestedMacroExpansions : 1;
  60
  61   /// The implicit PCH included at the start of the translation unit, or empty.
  62   std::string ImplicitPCHInclude;
  63
  64   /// \brief Headers that will be converted to chained PCHs in memory.
  65   std::vector<std::string> ChainedIncludes;
  66
  67   /// \brief When true, disables most of the normal validation performed on
  68   /// precompiled headers.
  69   bool DisablePCHValidation;
  70
  71   /// \brief When true, disables the use of the stat cache within a
  72   /// precompiled header or AST file.
  73   bool DisableStatCache;
  74
  75   /// \brief Dump declarations that are deserialized from PCH, for testing.
  76   bool DumpDeserializedPCHDecls;
  77
  78   /// \brief This is a set of names for decls that we do not want to be
  79   /// deserialized, and we emit an error if they are; for testing purposes.
  80   std::set<std::string> DeserializedPCHDeclsToErrorOn;
  81
  82   /// \brief If non-zero, the implicit PCH include is actually a precompiled
  83   /// preamble that covers this number of bytes in the main source file.
  84   ///
  85   /// The boolean indicates whether the preamble ends at the start of a new
  86   /// line.
  87   std::pair<unsigned, bool> PrecompiledPreambleBytes;
  88
  89   /// The implicit PTH input included at the start of the translation unit, or
  90   /// empty.
  91   std::string ImplicitPTHInclude;
  92
  93   /// If given, a PTH cache file to use for speeding up header parsing.
  94   std::string TokenCache;
  95
  96   /// \brief True if the SourceManager should report the original file name for
  97   /// contents of files that were remapped to other files. Defaults to true.
  98   bool RemappedFilesKeepOriginalName;
  99
 100   /// \brief The set of file remappings, which take existing files on
 101   /// the system (the first part of each pair) and gives them the
 102   /// contents of other files on the system (the second part of each
 103   /// pair).
 104   std::vector<std::pair<std::string, std::string> >  RemappedFiles;
 105
 106   /// \brief The set of file-to-buffer remappings, which take existing files
 107   /// on the system (the first part of each pair) and gives them the contents
 108   /// of the specified memory buffer (the second part of each pair).
 109   std::vector<std::pair<std::string, const llvm::MemoryBuffer *> >
 110     RemappedFileBuffers;
 111
 112   /// \brief Whether the compiler instance should retain (i.e., not free)
 113   /// the buffers associated with remapped files.
 114   ///
 115   /// This flag defaults to false; it can be set true only through direct
 116   /// manipulation of the compiler invocation object, in cases where the
 117   /// compiler invocation and its buffers will be reused.
 118   bool RetainRemappedFileBuffers;
 119
 120   /// \brief The Objective-C++ ARC standard library that we should support,
 121   /// by providing appropriate definitions to retrofit the standard library
 122   /// with support for lifetime-qualified pointers.
 123   ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary;
 124
 125   /// \brief The path of modules being build, which is used to detect
 126   /// cycles in the module dependency graph as modules are being built.
 127   ///
 128   /// There is no way to set this value from the command line. If we ever need
 129   /// to do so (e.g., if on-demand module construction moves out-of-process),
 130   /// we can add a cc1-level option to do so.
 131   SmallVector<std::string, 2> ModuleBuildPath;
 132
 133   typedef std::vector<std::pair<std::string, std::string> >::iterator
 134     remapped_file_iterator;
 135   typedef std::vector<std::pair<std::string, std::string> >::const_iterator
 136     const_remapped_file_iterator;
 137   remapped_file_iterator remapped_file_begin() {
 138     return RemappedFiles.begin();
 139   }
 140   const_remapped_file_iterator remapped_file_begin() const {
 141     return RemappedFiles.begin();
 142   }
 143   remapped_file_iterator remapped_file_end() {
 144     return RemappedFiles.end();
 145   }
 146   const_remapped_file_iterator remapped_file_end() const {
 147     return RemappedFiles.end();
 148   }
 149
 150   typedef std::vector<std::pair<std::string, const llvm::MemoryBuffer *> >::
 151                                   iterator remapped_file_buffer_iterator;
 152   typedef std::vector<std::pair<std::string, const llvm::MemoryBuffer *> >::
 153                             const_iterator const_remapped_file_buffer_iterator;
 154   remapped_file_buffer_iterator remapped_file_buffer_begin() {
 155     return RemappedFileBuffers.begin();
 156   }
 157   const_remapped_file_buffer_iterator remapped_file_buffer_begin() const {
 158     return RemappedFileBuffers.begin();
 159   }
 160   remapped_file_buffer_iterator remapped_file_buffer_end() {
 161     return RemappedFileBuffers.end();
 162   }
 163   const_remapped_file_buffer_iterator remapped_file_buffer_end() const {
 164     return RemappedFileBuffers.end();
 165   }
 166
 167 public:
 168   PreprocessorOptions() : UsePredefines(true), DetailedRecord(false),
 169                           AutoModuleImport(false),
 170                           DetailedRecordIncludesNestedMacroExpansions(true),
 171                           DisablePCHValidation(false), DisableStatCache(false),
 172                           DumpDeserializedPCHDecls(false),
 173                           PrecompiledPreambleBytes(0, true),
 174                           RemappedFilesKeepOriginalName(true),
 175                           RetainRemappedFileBuffers(false),
 176                           ObjCXXARCStandardLibrary(ARCXX_nolib) { }
 177
 178   void addMacroDef(StringRef Name) {
 179     Macros.push_back(std::make_pair(Name, false));
 180   }
 181   void addMacroUndef(StringRef Name) {
 182     Macros.push_back(std::make_pair(Name, true));
 183   }
 184   void addRemappedFile(StringRef From, StringRef To) {
 185     RemappedFiles.push_back(std::make_pair(From, To));
 186   }
 187
 188   remapped_file_iterator eraseRemappedFile(remapped_file_iterator Remapped) {
 189     return RemappedFiles.erase(Remapped);
 190   }
 191
 192   void addRemappedFile(StringRef From, const llvm::MemoryBuffer * To) {
 193     RemappedFileBuffers.push_back(std::make_pair(From, To));
 194   }
 195
 196   remapped_file_buffer_iterator
 197   eraseRemappedFile(remapped_file_buffer_iterator Remapped) {
 198     return RemappedFileBuffers.erase(Remapped);
 199   }
 200
 201   void clearRemappedFiles() {
 202     RemappedFiles.clear();
 203     RemappedFileBuffers.clear();
 204   }
 205
 206   /// \brief Reset any options that are not considered when building a
 207   /// module.
 208   void resetNonModularOptions() {
 209     Includes.clear();
 210     MacroIncludes.clear();
 211     ChainedIncludes.clear();
 212     DumpDeserializedPCHDecls = false;
 213     ImplicitPCHInclude.clear();
 214     ImplicitPTHInclude.clear();
 215     TokenCache.clear();
 216     RetainRemappedFileBuffers = true;
 217     PrecompiledPreambleBytes.first = 0;
 218     PrecompiledPreambleBytes.second = 0;
 219   }
 220 };
 221
 222 } // end namespace clang
 223
 224 #endif