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
23namespace llvm {
24  class MemoryBuffer;
25}
26
27namespace clang {
28
29class Preprocessor;
30class LangOptions;
31
32/// \brief Enumerate the kinds of standard library that
33enum 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().
43class PreprocessorOptions {
44public:
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  /// \brief True indicates that a preamble is being generated.
85  ///
86  /// When the lexer is done, one of the things that need to be preserved is the
87  /// conditional #if stack, so the ASTWriter/ASTReader can save/restore it when
88  /// processing the rest of the file.
89  bool GeneratePreamble;
90
91  /// The implicit PTH input included at the start of the translation unit, or
92  /// empty.
93  std::string ImplicitPTHInclude;
94
95  /// If given, a PTH cache file to use for speeding up header parsing.
96  std::string TokenCache;
97
98  /// When enabled, preprocessor is in a mode for parsing a single file only.
99  ///
100  /// Disables #includes of other files and if there are unresolved identifiers
101  /// in preprocessor directive conditions it causes all blocks to be parsed so
102  /// that the client can get the maximum amount of information from the parser.
103  bool SingleFileParseMode = false;
104
105  /// When enabled, the preprocessor will construct editor placeholder tokens.
106  bool LexEditorPlaceholders = true;
107
108  /// \brief True if the SourceManager should report the original file name for
109  /// contents of files that were remapped to other files. Defaults to true.
110  bool RemappedFilesKeepOriginalName;
111
112  /// \brief The set of file remappings, which take existing files on
113  /// the system (the first part of each pair) and gives them the
114  /// contents of other files on the system (the second part of each
115  /// pair).
116  std::vector<std::pair<std::string, std::string>> RemappedFiles;
117
118  /// \brief The set of file-to-buffer remappings, which take existing files
119  /// on the system (the first part of each pair) and gives them the contents
120  /// of the specified memory buffer (the second part of each pair).
121  std::vector<std::pair<std::string, llvm::MemoryBuffer *>> RemappedFileBuffers;
122
123  /// \brief Whether the compiler instance should retain (i.e., not free)
124  /// the buffers associated with remapped files.
125  ///
126  /// This flag defaults to false; it can be set true only through direct
127  /// manipulation of the compiler invocation object, in cases where the
128  /// compiler invocation and its buffers will be reused.
129  bool RetainRemappedFileBuffers;
130
131  /// \brief The Objective-C++ ARC standard library that we should support,
132  /// by providing appropriate definitions to retrofit the standard library
133  /// with support for lifetime-qualified pointers.
134  ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary;
135
136  /// \brief Records the set of modules
137  class FailedModulesSet {
138    llvm::StringSet<> Failed;
139
140  public:
141    bool hasAlreadyFailed(StringRef module) {
142      return Failed.count(module) > 0;
143    }
144
145    void addFailed(StringRef module) {
146      Failed.insert(module);
147    }
148  };
149
150  /// \brief The set of modules that failed to build.
151  ///
152  /// This pointer will be shared among all of the compiler instances created
153  /// to (re)build modules, so that once a module fails to build anywhere,
154  /// other instances will see that the module has failed and won't try to
155  /// build it again.
156  std::shared_ptr<FailedModulesSet> FailedModules;
157
158public:
159  PreprocessorOptions() : UsePredefines(true), DetailedRecord(false),
160                          DisablePCHValidation(false),
161                          AllowPCHWithCompilerErrors(false),
162                          DumpDeserializedPCHDecls(false),
163                          PrecompiledPreambleBytes(0, false),
164                          GeneratePreamble(false),
165                          RemappedFilesKeepOriginalName(true),
166                          RetainRemappedFileBuffers(false),
167                          ObjCXXARCStandardLibrary(ARCXX_nolib) { }
168
169  void addMacroDef(StringRef Name) { Macros.emplace_back(Name, false); }
170  void addMacroUndef(StringRef Name) { Macros.emplace_back(Name, true); }
171  void addRemappedFile(StringRef From, StringRef To) {
172    RemappedFiles.emplace_back(From, To);
173  }
174
175  void addRemappedFile(StringRef From, llvm::MemoryBuffer *To) {
176    RemappedFileBuffers.emplace_back(From, To);
177  }
178
179  void clearRemappedFiles() {
180    RemappedFiles.clear();
181    RemappedFileBuffers.clear();
182  }
183
184  /// \brief Reset any options that are not considered when building a
185  /// module.
186  void resetNonModularOptions() {
187    Includes.clear();
188    MacroIncludes.clear();
189    ChainedIncludes.clear();
190    DumpDeserializedPCHDecls = false;
191    ImplicitPCHInclude.clear();
192    ImplicitPTHInclude.clear();
193    TokenCache.clear();
194    SingleFileParseMode = false;
195    LexEditorPlaceholders = true;
196    RetainRemappedFileBuffers = true;
197    PrecompiledPreambleBytes.first = 0;
198    PrecompiledPreambleBytes.second = false;
199  }
200};
201
202} // end namespace clang
203
204#endif
205