blob: d86a923d43074d5c8b4fa3fa1630f920a103f8b7 [file] [log] [blame]
//===--- PreprocessorOptions.h ----------------------------------*- C++ -*-===//
// The LLVM Compiler Infrastructure
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringRef.h"
#include <cassert>
#include <string>
#include <utility>
#include <vector>
#include <set>
namespace llvm {
class MemoryBuffer;
namespace clang {
class Preprocessor;
class LangOptions;
/// \brief Enumerate the kinds of standard library that
enum ObjCXXARCStandardLibraryKind {
/// \brief libc++
/// \brief libstdc++
/// PreprocessorOptions - This class is used for passing the various options
/// used in preprocessor initialization to InitializePreprocessor().
class PreprocessorOptions {
std::vector<std::pair<std::string, bool/*isUndef*/> > Macros;
std::vector<std::string> Includes;
std::vector<std::string> MacroIncludes;
unsigned UsePredefines : 1; /// Initialize the preprocessor with the compiler
/// and target specific predefines.
unsigned DetailedRecord : 1; /// Whether we should maintain a detailed
/// record of all macro definitions and
/// expansions.
unsigned DetailedRecordConditionalDirectives : 1; /// Whether in the
/// preprocessing record we should also keep
/// track of locations of conditional directives
/// in non-system files.
/// The implicit PCH included at the start of the translation unit, or empty.
std::string ImplicitPCHInclude;
/// \brief Headers that will be converted to chained PCHs in memory.
std::vector<std::string> ChainedIncludes;
/// \brief When true, disables most of the normal validation performed on
/// precompiled headers.
bool DisablePCHValidation;
/// \brief When true, disables the use of the stat cache within a
/// precompiled header or AST file.
bool DisableStatCache;
/// \brief When true, a PCH with compiler errors will not be rejected.
bool AllowPCHWithCompilerErrors;
/// \brief Dump declarations that are deserialized from PCH, for testing.
bool DumpDeserializedPCHDecls;
/// \brief This is a set of names for decls that we do not want to be
/// deserialized, and we emit an error if they are; for testing purposes.
std::set<std::string> DeserializedPCHDeclsToErrorOn;
/// \brief If non-zero, the implicit PCH include is actually a precompiled
/// preamble that covers this number of bytes in the main source file.
/// The boolean indicates whether the preamble ends at the start of a new
/// line.
std::pair<unsigned, bool> PrecompiledPreambleBytes;
/// The implicit PTH input included at the start of the translation unit, or
/// empty.
std::string ImplicitPTHInclude;
/// If given, a PTH cache file to use for speeding up header parsing.
std::string TokenCache;
/// \brief True if the SourceManager should report the original file name for
/// contents of files that were remapped to other files. Defaults to true.
bool RemappedFilesKeepOriginalName;
/// \brief The set of file remappings, which take existing files on
/// the system (the first part of each pair) and gives them the
/// contents of other files on the system (the second part of each
/// pair).
std::vector<std::pair<std::string, std::string> > RemappedFiles;
/// \brief The set of file-to-buffer remappings, which take existing files
/// on the system (the first part of each pair) and gives them the contents
/// of the specified memory buffer (the second part of each pair).
std::vector<std::pair<std::string, const llvm::MemoryBuffer *> >
/// \brief Whether the compiler instance should retain (i.e., not free)
/// the buffers associated with remapped files.
/// This flag defaults to false; it can be set true only through direct
/// manipulation of the compiler invocation object, in cases where the
/// compiler invocation and its buffers will be reused.
bool RetainRemappedFileBuffers;
/// \brief The Objective-C++ ARC standard library that we should support,
/// by providing appropriate definitions to retrofit the standard library
/// with support for lifetime-qualified pointers.
ObjCXXARCStandardLibraryKind ObjCXXARCStandardLibrary;
/// \brief The path of modules being build, which is used to detect
/// cycles in the module dependency graph as modules are being built.
/// There is no way to set this value from the command line. If we ever need
/// to do so (e.g., if on-demand module construction moves out-of-process),
/// we can add a cc1-level option to do so.
SmallVector<std::string, 2> ModuleBuildPath;
typedef std::vector<std::pair<std::string, std::string> >::iterator
typedef std::vector<std::pair<std::string, std::string> >::const_iterator
remapped_file_iterator remapped_file_begin() {
return RemappedFiles.begin();
const_remapped_file_iterator remapped_file_begin() const {
return RemappedFiles.begin();
remapped_file_iterator remapped_file_end() {
return RemappedFiles.end();
const_remapped_file_iterator remapped_file_end() const {
return RemappedFiles.end();
typedef std::vector<std::pair<std::string, const llvm::MemoryBuffer *> >::
iterator remapped_file_buffer_iterator;
typedef std::vector<std::pair<std::string, const llvm::MemoryBuffer *> >::
const_iterator const_remapped_file_buffer_iterator;
remapped_file_buffer_iterator remapped_file_buffer_begin() {
return RemappedFileBuffers.begin();
const_remapped_file_buffer_iterator remapped_file_buffer_begin() const {
return RemappedFileBuffers.begin();
remapped_file_buffer_iterator remapped_file_buffer_end() {
return RemappedFileBuffers.end();
const_remapped_file_buffer_iterator remapped_file_buffer_end() const {
return RemappedFileBuffers.end();
PreprocessorOptions() : UsePredefines(true), DetailedRecord(false),
DisablePCHValidation(false), DisableStatCache(false),
PrecompiledPreambleBytes(0, true),
ObjCXXARCStandardLibrary(ARCXX_nolib) { }
void addMacroDef(StringRef Name) {
Macros.push_back(std::make_pair(Name, false));
void addMacroUndef(StringRef Name) {
Macros.push_back(std::make_pair(Name, true));
void addRemappedFile(StringRef From, StringRef To) {
RemappedFiles.push_back(std::make_pair(From, To));
remapped_file_iterator eraseRemappedFile(remapped_file_iterator Remapped) {
return RemappedFiles.erase(Remapped);
void addRemappedFile(StringRef From, const llvm::MemoryBuffer * To) {
RemappedFileBuffers.push_back(std::make_pair(From, To));
eraseRemappedFile(remapped_file_buffer_iterator Remapped) {
return RemappedFileBuffers.erase(Remapped);
void clearRemappedFiles() {
/// \brief Reset any options that are not considered when building a
/// module.
void resetNonModularOptions() {
DumpDeserializedPCHDecls = false;
RetainRemappedFileBuffers = true;
PrecompiledPreambleBytes.first = 0;
PrecompiledPreambleBytes.second = 0;
} // end namespace clang