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