diff options
Diffstat (limited to 'include/clang/Lex/Preprocessor.h')
| -rw-r--r-- | include/clang/Lex/Preprocessor.h | 662 |
1 files changed, 363 insertions, 299 deletions
diff --git a/include/clang/Lex/Preprocessor.h b/include/clang/Lex/Preprocessor.h index 223fd470eca1..d4b4ba246961 100644 --- a/include/clang/Lex/Preprocessor.h +++ b/include/clang/Lex/Preprocessor.h @@ -6,9 +6,10 @@ // License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// -// -// This file defines the Preprocessor interface. -// +/// +/// \file +/// \brief Defines the clang::Preprocessor interface. +/// //===----------------------------------------------------------------------===// #ifndef LLVM_CLANG_LEX_PREPROCESSOR_H @@ -28,10 +29,10 @@ #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/DenseMap.h" #include "llvm/ADT/IntrusiveRefCntPtr.h" -#include "llvm/ADT/OwningPtr.h" #include "llvm/ADT/SmallPtrSet.h" #include "llvm/ADT/SmallVector.h" #include "llvm/Support/Allocator.h" +#include <memory> #include <vector> namespace llvm { @@ -64,7 +65,7 @@ class TokenValue { IdentifierInfo *II; public: - TokenValue(tok::TokenKind Kind) : Kind(Kind), II(0) { + TokenValue(tok::TokenKind Kind) : Kind(Kind), II(nullptr) { assert(Kind != tok::raw_identifier && "Raw identifiers are not supported."); assert(Kind != tok::identifier && "Identifiers should be created by TokenValue(IdentifierInfo *)"); @@ -78,11 +79,12 @@ public: } }; -/// Preprocessor - This object engages in a tight little dance with the lexer to -/// efficiently preprocess tokens. Lexers know only about tokens within a -/// single source file, and don't know anything about preprocessor-level issues -/// like the \#include stack, token expansion, etc. +/// \brief Engages in a tight little dance with the lexer to efficiently +/// preprocess tokens. /// +/// Lexers know only about tokens within a single source file, and don't +/// know anything about preprocessor-level issues like the \#include stack, +/// token expansion, etc. class Preprocessor : public RefCountedBase<Preprocessor> { IntrusiveRefCntPtr<PreprocessorOptions> PPOpts; DiagnosticsEngine *Diags; @@ -98,12 +100,12 @@ class Preprocessor : public RefCountedBase<Preprocessor> { ExternalPreprocessorSource *ExternalSource; - /// PTH - An optional PTHManager object used for getting tokens from - /// a token cache rather than lexing the original source file. - OwningPtr<PTHManager> PTH; + /// An optional PTHManager object used for getting tokens from + /// a token cache rather than lexing the original source file. + std::unique_ptr<PTHManager> PTH; - /// BP - A BumpPtrAllocator object used to quickly allocate and release - /// objects internal to the Preprocessor. + /// A BumpPtrAllocator object used to quickly allocate and release + /// objects internal to the Preprocessor. llvm::BumpPtrAllocator BP; /// Identifiers for builtin macros and other builtins. @@ -114,6 +116,7 @@ class Preprocessor : public RefCountedBase<Preprocessor> { IdentifierInfo *Ident__TIMESTAMP__; // __TIMESTAMP__ IdentifierInfo *Ident__COUNTER__; // __COUNTER__ IdentifierInfo *Ident_Pragma, *Ident__pragma; // _Pragma, __pragma + IdentifierInfo *Ident__identifier; // __identifier IdentifierInfo *Ident__VA_ARGS__; // __VA_ARGS__ IdentifierInfo *Ident__has_feature; // __has_feature IdentifierInfo *Ident__has_extension; // __has_extension @@ -122,6 +125,7 @@ class Preprocessor : public RefCountedBase<Preprocessor> { IdentifierInfo *Ident__has_include; // __has_include IdentifierInfo *Ident__has_include_next; // __has_include_next IdentifierInfo *Ident__has_warning; // __has_warning + IdentifierInfo *Ident__is_identifier; // __is_identifier IdentifierInfo *Ident__building_module; // __building_module IdentifierInfo *Ident__MODULE__; // __MODULE__ @@ -129,7 +133,7 @@ class Preprocessor : public RefCountedBase<Preprocessor> { unsigned CounterValue; // Next __COUNTER__ value. enum { - /// MaxIncludeStackDepth - Maximum depth of \#includes. + /// \brief Maximum depth of \#includes. MaxAllowedIncludeStackDepth = 200 }; @@ -144,12 +148,11 @@ class Preprocessor : public RefCountedBase<Preprocessor> { /// Whether the preprocessor owns the header search object. bool OwnsHeaderSearch : 1; - /// DisableMacroExpansion - True if macro expansion is disabled. + /// True if macro expansion is disabled. bool DisableMacroExpansion : 1; - /// MacroExpansionInDirectivesOverride - Temporarily disables - /// DisableMacroExpansion (i.e. enables expansion) when parsing preprocessor - /// directives. + /// Temporarily disables DisableMacroExpansion (i.e. enables expansion) + /// when parsing preprocessor directives. bool MacroExpansionInDirectivesOverride : 1; class ResetMacroExpansionHelper; @@ -169,23 +172,25 @@ class Preprocessor : public RefCountedBase<Preprocessor> { /// \brief True if we are pre-expanding macro arguments. bool InMacroArgPreExpansion; - /// Identifiers - This is mapping/lookup information for all identifiers in + /// \brief Mapping/lookup information for all identifiers in /// the program, including program keywords. mutable IdentifierTable Identifiers; - /// Selectors - This table contains all the selectors in the program. Unlike - /// IdentifierTable above, this table *isn't* populated by the preprocessor. - /// It is declared/expanded here because it's role/lifetime is - /// conceptually similar the IdentifierTable. In addition, the current control - /// flow (in clang::ParseAST()), make it convenient to put here. + /// \brief This table contains all the selectors in the program. + /// + /// Unlike IdentifierTable above, this table *isn't* populated by the + /// preprocessor. It is declared/expanded here because its role/lifetime is + /// conceptually similar to the IdentifierTable. In addition, the current + /// control flow (in clang::ParseAST()), make it convenient to put here. + /// /// FIXME: Make sure the lifetime of Identifiers/Selectors *isn't* tied to /// the lifetime of the preprocessor. SelectorTable Selectors; - /// BuiltinInfo - Information about builtins. + /// \brief Information about builtins. Builtin::Context BuiltinInfo; - /// PragmaHandlers - This tracks all of the pragmas that the client registered + /// \brief Tracks all of the pragmas that the client registered /// with this preprocessor. PragmaNamespace *PragmaHandlers; @@ -197,6 +202,9 @@ class Preprocessor : public RefCountedBase<Preprocessor> { /// avoid tearing the Lexer and etc. down). bool IncrementalProcessing; + /// The kind of translation unit we are processing. + TranslationUnitKind TUKind; + /// \brief The code-completion handler. CodeCompletionHandler *CodeComplete; @@ -216,7 +224,7 @@ class Preprocessor : public RefCountedBase<Preprocessor> { /// for preprocessing. SourceLocation CodeCompletionFileLoc; - /// \brief The source location of the 'import' contextual keyword we just + /// \brief The source location of the \c import contextual keyword we just /// lexed, if any. SourceLocation ModuleImportLoc; @@ -226,46 +234,53 @@ class Preprocessor : public RefCountedBase<Preprocessor> { /// \brief Whether the last token we lexed was an '@'. bool LastTokenWasAt; - /// \brief Whether the module import expectes an identifier next. Otherwise, + /// \brief Whether the module import expects an identifier next. Otherwise, /// it expects a '.' or ';'. bool ModuleImportExpectsIdentifier; /// \brief The source location of the currently-active - /// #pragma clang arc_cf_code_audited begin. + /// \#pragma clang arc_cf_code_audited begin. SourceLocation PragmaARCCFCodeAuditedLoc; /// \brief True if we hit the code-completion point. bool CodeCompletionReached; /// \brief The number of bytes that we will initially skip when entering the - /// main file, which is used when loading a precompiled preamble, along - /// with a flag that indicates whether skipping this number of bytes will - /// place the lexer at the start of a line. + /// main file, along with a flag that indicates whether skipping this number + /// of bytes will place the lexer at the start of a line. + /// + /// This is used when loading a precompiled preamble. std::pair<unsigned, bool> SkipMainFilePreamble; - /// CurLexer - This is the current top of the stack that we're lexing from if + /// \brief The current top of the stack that we're lexing from if /// not expanding a macro and we are lexing directly from source code. - /// Only one of CurLexer, CurPTHLexer, or CurTokenLexer will be non-null. - OwningPtr<Lexer> CurLexer; + /// + /// Only one of CurLexer, CurPTHLexer, or CurTokenLexer will be non-null. + std::unique_ptr<Lexer> CurLexer; - /// CurPTHLexer - This is the current top of stack that we're lexing from if - /// not expanding from a macro and we are lexing from a PTH cache. - /// Only one of CurLexer, CurPTHLexer, or CurTokenLexer will be non-null. - OwningPtr<PTHLexer> CurPTHLexer; + /// \brief The current top of stack that we're lexing from if + /// not expanding from a macro and we are lexing from a PTH cache. + /// + /// Only one of CurLexer, CurPTHLexer, or CurTokenLexer will be non-null. + std::unique_ptr<PTHLexer> CurPTHLexer; - /// CurPPLexer - This is the current top of the stack what we're lexing from - /// if not expanding a macro. This is an alias for either CurLexer or - /// CurPTHLexer. + /// \brief The current top of the stack what we're lexing from + /// if not expanding a macro. + /// + /// This is an alias for either CurLexer or CurPTHLexer. PreprocessorLexer *CurPPLexer; - /// CurLookup - The DirectoryLookup structure used to find the current - /// FileEntry, if CurLexer is non-null and if applicable. This allows us to - /// implement \#include_next and find directory-specific properties. + /// \brief Used to find the current FileEntry, if CurLexer is non-null + /// and if applicable. + /// + /// This allows us to implement \#include_next and find directory-specific + /// properties. const DirectoryLookup *CurDirLookup; - /// CurTokenLexer - This is the current macro we are expanding, if we are - /// expanding a macro. One of CurLexer and CurTokenLexer must be null. - OwningPtr<TokenLexer> CurTokenLexer; + /// \brief The current macro we are expanding, if we are expanding a macro. + /// + /// One of CurLexer and CurTokenLexer must be null. + std::unique_ptr<TokenLexer> CurTokenLexer; /// \brief The kind of lexer we're currently working with. enum CurLexerKind { @@ -276,26 +291,48 @@ class Preprocessor : public RefCountedBase<Preprocessor> { CLK_LexAfterModuleImport } CurLexerKind; - /// IncludeMacroStack - This keeps track of the stack of files currently + /// \brief If the current lexer is for a submodule that is being built, this + /// is that submodule. + Module *CurSubmodule; + + /// \brief Keeps track of the stack of files currently /// \#included, and macros currently being expanded from, not counting /// CurLexer/CurTokenLexer. struct IncludeStackInfo { - enum CurLexerKind CurLexerKind; - Lexer *TheLexer; - PTHLexer *ThePTHLexer; - PreprocessorLexer *ThePPLexer; - TokenLexer *TheTokenLexer; - const DirectoryLookup *TheDirLookup; - - IncludeStackInfo(enum CurLexerKind K, Lexer *L, PTHLexer* P, - PreprocessorLexer* PPL, - TokenLexer* TL, const DirectoryLookup *D) - : CurLexerKind(K), TheLexer(L), ThePTHLexer(P), ThePPLexer(PPL), - TheTokenLexer(TL), TheDirLookup(D) {} + enum CurLexerKind CurLexerKind; + Module *TheSubmodule; + std::unique_ptr<Lexer> TheLexer; + std::unique_ptr<PTHLexer> ThePTHLexer; + PreprocessorLexer *ThePPLexer; + std::unique_ptr<TokenLexer> TheTokenLexer; + const DirectoryLookup *TheDirLookup; + + // The following constructors are completely useless copies of the default + // versions, only needed to pacify MSVC. + IncludeStackInfo(enum CurLexerKind CurLexerKind, Module *TheSubmodule, + std::unique_ptr<Lexer> &&TheLexer, + std::unique_ptr<PTHLexer> &&ThePTHLexer, + PreprocessorLexer *ThePPLexer, + std::unique_ptr<TokenLexer> &&TheTokenLexer, + const DirectoryLookup *TheDirLookup) + : CurLexerKind(std::move(CurLexerKind)), + TheSubmodule(std::move(TheSubmodule)), TheLexer(std::move(TheLexer)), + ThePTHLexer(std::move(ThePTHLexer)), + ThePPLexer(std::move(ThePPLexer)), + TheTokenLexer(std::move(TheTokenLexer)), + TheDirLookup(std::move(TheDirLookup)) {} + IncludeStackInfo(IncludeStackInfo &&RHS) + : CurLexerKind(std::move(RHS.CurLexerKind)), + TheSubmodule(std::move(RHS.TheSubmodule)), + TheLexer(std::move(RHS.TheLexer)), + ThePTHLexer(std::move(RHS.ThePTHLexer)), + ThePPLexer(std::move(RHS.ThePPLexer)), + TheTokenLexer(std::move(RHS.TheTokenLexer)), + TheDirLookup(std::move(RHS.TheDirLookup)) {} }; std::vector<IncludeStackInfo> IncludeMacroStack; - /// Callbacks - These are actions invoked when some preprocessor activity is + /// \brief Actions invoked when some preprocessor activity is /// encountered (e.g. a file is \#included, etc). PPCallbacks *Callbacks; @@ -308,14 +345,16 @@ class Preprocessor : public RefCountedBase<Preprocessor> { }; SmallVector<MacroExpandsInfo, 2> DelayedMacroExpandsCallbacks; - /// Macros - For each IdentifierInfo that was associated with a macro, we + /// For each IdentifierInfo that was associated with a macro, we /// keep a mapping to the history of all macro definitions and #undefs in /// the reverse order (the latest one is in the head of the list). llvm::DenseMap<const IdentifierInfo*, MacroDirective*> Macros; friend class ASTReader; /// \brief Macros that we want to warn because they are not used at the end - /// of the translation unit; we store just their SourceLocations instead + /// of the translation unit. + /// + /// We store just their SourceLocations instead of /// something like MacroInfo*. The benefit of this is that when we are /// deserializing from PCH, we don't need to deserialize identifier & macros /// just so that we can report that they are unused, we just warn using @@ -324,35 +363,36 @@ class Preprocessor : public RefCountedBase<Preprocessor> { typedef llvm::SmallPtrSet<SourceLocation, 32> WarnUnusedMacroLocsTy; WarnUnusedMacroLocsTy WarnUnusedMacroLocs; - /// MacroArgCache - This is a "freelist" of MacroArg objects that can be + /// \brief A "freelist" of MacroArg objects that can be /// reused for quick allocation. MacroArgs *MacroArgCache; friend class MacroArgs; - /// PragmaPushMacroInfo - For each IdentifierInfo used in a #pragma - /// push_macro directive, we keep a MacroInfo stack used to restore - /// previous macro value. + /// For each IdentifierInfo used in a \#pragma push_macro directive, + /// we keep a MacroInfo stack used to restore the previous macro value. llvm::DenseMap<IdentifierInfo*, std::vector<MacroInfo*> > PragmaPushMacroInfo; // Various statistics we track for performance analysis. - unsigned NumDirectives, NumIncluded, NumDefined, NumUndefined, NumPragma; + unsigned NumDirectives, NumDefined, NumUndefined, NumPragma; unsigned NumIf, NumElse, NumEndif; unsigned NumEnteredSourceFiles, MaxIncludeStackDepth; unsigned NumMacroExpanded, NumFnMacroExpanded, NumBuiltinMacroExpanded; unsigned NumFastMacroExpanded, NumTokenPaste, NumFastTokenPaste; unsigned NumSkipped; - /// Predefines - This string is the predefined macros that preprocessor - /// should use from the command line etc. + /// \brief The predefined macros that preprocessor should use from the + /// command line etc. std::string Predefines; /// \brief The file ID for the preprocessor predefines. FileID PredefinesFileID; - /// TokenLexerCache - Cache macro expanders to reduce malloc traffic. + /// \{ + /// \brief Cache of macro expanders to reduce malloc traffic. enum { TokenLexerCacheSize = 8 }; unsigned NumCachedTokenLexers; TokenLexer *TokenLexerCache[TokenLexerCacheSize]; + /// \} /// \brief Keeps macro expanded tokens for TokenLexers. // @@ -372,17 +412,20 @@ class Preprocessor : public RefCountedBase<Preprocessor> { private: // Cached tokens state. typedef SmallVector<Token, 1> CachedTokensTy; - /// CachedTokens - Cached tokens are stored here when we do backtracking or + /// \brief Cached tokens are stored here when we do backtracking or /// lookahead. They are "lexed" by the CachingLex() method. CachedTokensTy CachedTokens; - /// CachedLexPos - The position of the cached token that CachingLex() should - /// "lex" next. If it points beyond the CachedTokens vector, it means that - /// a normal Lex() should be invoked. + /// \brief The position of the cached token that CachingLex() should + /// "lex" next. + /// + /// If it points beyond the CachedTokens vector, it means that a normal + /// Lex() should be invoked. CachedTokensTy::size_type CachedLexPos; - /// BacktrackPositions - Stack of backtrack positions, allowing nested - /// backtracks. The EnableBacktrackAtThisPos() method pushes a position to + /// \brief Stack of backtrack positions, allowing nested backtracks. + /// + /// The EnableBacktrackAtThisPos() method pushes a position to /// indicate where CachedLexPos should be set when the BackTrack() method is /// invoked (at which point the last position is popped). std::vector<CachedTokensTy::size_type> BacktrackPositions; @@ -397,7 +440,7 @@ private: // Cached tokens state. /// of that list. MacroInfoChain *MIChainHead; - /// MICache - A "freelist" of MacroInfo objects that can be reused for quick + /// A "freelist" of MacroInfo objects that can be reused for quick /// allocation. MacroInfoChain *MICache; @@ -412,20 +455,18 @@ private: // Cached tokens state. public: Preprocessor(IntrusiveRefCntPtr<PreprocessorOptions> PPOpts, DiagnosticsEngine &diags, LangOptions &opts, - const TargetInfo *target, SourceManager &SM, HeaderSearch &Headers, ModuleLoader &TheModuleLoader, - IdentifierInfoLookup *IILookup = 0, + IdentifierInfoLookup *IILookup = nullptr, bool OwnsHeaderSearch = false, - bool DelayInitialization = false, - bool IncrProcessing = false); + TranslationUnitKind TUKind = TU_Complete); ~Preprocessor(); - /// \brief Initialize the preprocessor, if the constructor did not already - /// perform the initialization. + /// \brief Initialize the preprocessor using information about the target. /// - /// \param Target Information about the target. + /// \param Target is owned by the caller and must remain valid for the + /// lifetime of the preprocessor. void Initialize(const TargetInfo &Target); /// \brief Retrieve the preprocessor options used to initialize this @@ -470,8 +511,7 @@ public: return ParsingIfOrElifDirective; } - /// SetCommentRetentionState - Control whether or not the preprocessor retains - /// comments in output. + /// \brief Control whether the preprocessor retains comments in output. void SetCommentRetentionState(bool KeepComments, bool KeepMacroComments) { this->KeepComments = KeepComments | KeepMacroComments; this->KeepMacroComments = KeepMacroComments; @@ -500,26 +540,29 @@ public: /// false if it is producing tokens to be consumed by Parse and Sema. bool isPreprocessedOutput() const { return PreprocessedOutput; } - /// isCurrentLexer - Return true if we are lexing directly from the specified - /// lexer. + /// \brief Return true if we are lexing directly from the specified lexer. bool isCurrentLexer(const PreprocessorLexer *L) const { return CurPPLexer == L; } - /// getCurrentLexer - Return the current lexer being lexed from. Note - /// that this ignores any potentially active macro expansions and _Pragma + /// \brief Return the current lexer being lexed from. + /// + /// Note that this ignores any potentially active macro expansions and _Pragma /// expansions going on at the time. PreprocessorLexer *getCurrentLexer() const { return CurPPLexer; } - /// getCurrentFileLexer - Return the current file lexer being lexed from. + /// \brief Return the current file lexer being lexed from. + /// /// Note that this ignores any potentially active macro expansions and _Pragma /// expansions going on at the time. PreprocessorLexer *getCurrentFileLexer() const; - /// \brief Returns the file ID for the preprocessor predefines. + /// \brief Returns the FileID for the preprocessor predefines. FileID getPredefinesFileID() const { return PredefinesFileID; } - /// getPPCallbacks/addPPCallbacks - Accessors for preprocessor callbacks. + /// \{ + /// \brief Accessors for preprocessor callbacks. + /// /// Note that this class takes ownership of any PPCallbacks object given to /// it. PPCallbacks *getPPCallbacks() const { return Callbacks; } @@ -528,12 +571,13 @@ public: C = new PPChainedCallbacks(C, Callbacks); Callbacks = C; } + /// \} /// \brief Given an identifier, return its latest MacroDirective if it is - // \#defined or null if it isn't \#define'd. + /// \#defined or null if it isn't \#define'd. MacroDirective *getMacroDirective(IdentifierInfo *II) const { if (!II->hasMacroDefinition()) - return 0; + return nullptr; MacroDirective *MD = getMacroDirectiveHistory(II); assert(MD->isDefined() && "Macro is undefined!"); @@ -547,13 +591,14 @@ public: MacroInfo *getMacroInfo(IdentifierInfo *II) { if (MacroDirective *MD = getMacroDirective(II)) return MD->getMacroInfo(); - return 0; + return nullptr; } /// \brief Given an identifier, return the (probably #undef'd) MacroInfo - /// representing the most recent macro definition. One can iterate over all - /// previous macro definitions from it. This method should only be called for - /// identifiers that hadMacroDefinition(). + /// representing the most recent macro definition. + /// + /// One can iterate over all previous macro definitions from the most recent + /// one. This should only be called for identifiers that hadMacroDefinition(). MacroDirective *getMacroDirectiveHistory(const IdentifierInfo *II) const; /// \brief Add a directive to the macro directive history for this identifier. @@ -571,14 +616,15 @@ public: /// \brief Set a MacroDirective that was loaded from a PCH file. void setLoadedMacroDirective(IdentifierInfo *II, MacroDirective *MD); - /// macro_iterator/macro_begin/macro_end - This allows you to walk the macro - /// history table. Currently defined macros have + /// \{ + /// Iterators for the macro history table. Currently defined macros have /// IdentifierInfo::hasMacroDefinition() set and an empty /// MacroInfo::getUndefLoc() at the head of the list. typedef llvm::DenseMap<const IdentifierInfo *, MacroDirective*>::const_iterator macro_iterator; macro_iterator macro_begin(bool IncludeExternalMacros = true) const; macro_iterator macro_end(bool IncludeExternalMacros = true) const; + /// \} /// \brief Return the name of the macro defined before \p Loc that has /// spelling \p Tokens. If there are multiple macros with same spelling, @@ -587,8 +633,9 @@ public: ArrayRef<TokenValue> Tokens) const; const std::string &getPredefines() const { return Predefines; } - /// setPredefines - Set the predefines for this Preprocessor. These - /// predefines are automatically injected when parsing the main file. + /// \brief Set the predefines for this Preprocessor. + /// + /// These predefines are automatically injected when parsing the main file. void setPredefines(const char *P) { Predefines = P; } void setPredefines(const std::string &P) { Predefines = P; } @@ -598,23 +645,28 @@ public: return &Identifiers.get(Name); } - /// AddPragmaHandler - Add the specified pragma handler to the preprocessor. - /// If 'Namespace' is non-null, then it is a token required to exist on the + /// \brief Add the specified pragma handler to this preprocessor. + /// + /// If \p Namespace is non-null, then it is a token required to exist on the /// pragma line before the pragma string starts, e.g. "STDC" or "GCC". void AddPragmaHandler(StringRef Namespace, PragmaHandler *Handler); void AddPragmaHandler(PragmaHandler *Handler) { AddPragmaHandler(StringRef(), Handler); } - /// RemovePragmaHandler - Remove the specific pragma handler from - /// the preprocessor. If \p Namespace is non-null, then it should - /// be the namespace that \p Handler was added to. It is an error - /// to remove a handler that has not been registered. + /// \brief Remove the specific pragma handler from this preprocessor. + /// + /// If \p Namespace is non-null, then it should be the namespace that + /// \p Handler was added to. It is an error to remove a handler that + /// has not been registered. void RemovePragmaHandler(StringRef Namespace, PragmaHandler *Handler); void RemovePragmaHandler(PragmaHandler *Handler) { RemovePragmaHandler(StringRef(), Handler); } + /// Install empty handlers for all pragmas (making them ignored). + void IgnorePragmas(); + /// \brief Add the specified comment handler to the preprocessor. void addCommentHandler(CommentHandler *Handler); @@ -635,7 +687,7 @@ public: /// \brief Clear out the code completion handler. void clearCodeCompletionHandler() { - CodeComplete = 0; + CodeComplete = nullptr; } /// \brief Hook used by the lexer to invoke the "natural language" code @@ -650,51 +702,51 @@ public: /// all macro expansions, macro definitions, etc. void createPreprocessingRecord(); - /// EnterMainSourceFile - Enter the specified FileID as the main source file, + /// \brief Enter the specified FileID as the main source file, /// which implicitly adds the builtin defines etc. void EnterMainSourceFile(); - /// EndSourceFile - Inform the preprocessor callbacks that processing is - /// complete. + /// \brief Inform the preprocessor callbacks that processing is complete. void EndSourceFile(); - /// EnterSourceFile - Add a source file to the top of the include stack and - /// start lexing tokens from it instead of the current buffer. Emit an error - /// and don't enter the file on error. - void EnterSourceFile(FileID CurFileID, const DirectoryLookup *Dir, + /// \brief Add a source file to the top of the include stack and + /// start lexing tokens from it instead of the current buffer. + /// + /// Emits a diagnostic, doesn't enter the file, and returns true on error. + bool EnterSourceFile(FileID CurFileID, const DirectoryLookup *Dir, SourceLocation Loc); - /// EnterMacro - Add a Macro to the top of the include stack and start lexing - /// tokens from it instead of the current buffer. Args specifies the - /// tokens input to a function-like macro. + /// \brief Add a Macro to the top of the include stack and start lexing + /// tokens from it instead of the current buffer. /// - /// ILEnd specifies the location of the ')' for a function-like macro or the - /// identifier for an object-like macro. + /// \param Args specifies the tokens input to a function-like macro. + /// \param ILEnd specifies the location of the ')' for a function-like macro + /// or the identifier for an object-like macro. void EnterMacro(Token &Identifier, SourceLocation ILEnd, MacroInfo *Macro, MacroArgs *Args); - /// EnterTokenStream - Add a "macro" context to the top of the include stack, + /// \brief Add a "macro" context to the top of the include stack, /// which will cause the lexer to start returning the specified tokens. /// - /// If DisableMacroExpansion is true, tokens lexed from the token stream will - /// not be subject to further macro expansion. Otherwise, these tokens will - /// be re-macro-expanded when/if expansion is enabled. - /// - /// If OwnsTokens is false, this method assumes that the specified stream of - /// tokens has a permanent owner somewhere, so they do not need to be copied. - /// If it is true, it assumes the array of tokens is allocated with new[] and - /// must be freed. + /// If \p DisableMacroExpansion is true, tokens lexed from the token stream + /// will not be subject to further macro expansion. Otherwise, these tokens + /// will be re-macro-expanded when/if expansion is enabled. /// + /// If \p OwnsTokens is false, this method assumes that the specified stream + /// of tokens has a permanent owner somewhere, so they do not need to be + /// copied. If it is true, it assumes the array of tokens is allocated with + /// \c new[] and must be freed. void EnterTokenStream(const Token *Toks, unsigned NumToks, bool DisableMacroExpansion, bool OwnsTokens); - /// RemoveTopOfLexerStack - Pop the current lexer/macro exp off the top of the - /// lexer stack. This should only be used in situations where the current - /// state of the top-of-stack lexer is known. + /// \brief Pop the current lexer/macro exp off the top of the lexer stack. + /// + /// This should only be used in situations where the current state of the + /// top-of-stack lexer is known. void RemoveTopOfLexerStack(); - /// EnableBacktrackAtThisPos - From the point that this method is called, and - /// until CommitBacktrackedTokens() or Backtrack() is called, the Preprocessor + /// From the point that this method is called, and until + /// CommitBacktrackedTokens() or Backtrack() is called, the Preprocessor /// keeps track of the lexed tokens so that a subsequent Backtrack() call will /// make the Preprocessor re-lex the same tokens. /// @@ -708,18 +760,18 @@ public: /// void EnableBacktrackAtThisPos(); - /// CommitBacktrackedTokens - Disable the last EnableBacktrackAtThisPos call. + /// \brief Disable the last EnableBacktrackAtThisPos call. void CommitBacktrackedTokens(); - /// Backtrack - Make Preprocessor re-lex the tokens that were lexed since + /// \brief Make Preprocessor re-lex the tokens that were lexed since /// EnableBacktrackAtThisPos() was previously called. void Backtrack(); - /// isBacktrackEnabled - True if EnableBacktrackAtThisPos() was called and + /// \brief True if EnableBacktrackAtThisPos() was called and /// caching of tokens is on. bool isBacktrackEnabled() const { return !BacktrackPositions.empty(); } - /// Lex - Lex the next token for this preprocessor. + /// \brief Lex the next token for this preprocessor. void Lex(Token &Result); void LexAfterModuleImport(Token &Result); @@ -743,17 +795,18 @@ public: const char *DiagnosticTag, bool AllowMacroExpansion); - /// LexNonComment - Lex a token. If it's a comment, keep lexing until we get - /// something not a comment. This is useful in -E -C mode where comments - /// would foul up preprocessor directive handling. + /// \brief Lex a token. If it's a comment, keep lexing until we get + /// something not a comment. + /// + /// This is useful in -E -C mode where comments would foul up preprocessor + /// directive handling. void LexNonComment(Token &Result) { do Lex(Result); while (Result.getKind() == tok::comment); } - /// LexUnexpandedToken - This is just like Lex, but this disables macro - /// expansion of identifier tokens. + /// \brief Just like Lex, but disables macro expansion of identifier tokens. void LexUnexpandedToken(Token &Result) { // Disable macro expansion. bool OldVal = DisableMacroExpansion; @@ -765,24 +818,31 @@ public: DisableMacroExpansion = OldVal; } - /// LexUnexpandedNonComment - Like LexNonComment, but this disables macro - /// expansion of identifier tokens. + /// \brief Like LexNonComment, but this disables macro expansion of + /// identifier tokens. void LexUnexpandedNonComment(Token &Result) { do LexUnexpandedToken(Result); while (Result.getKind() == tok::comment); } + /// \brief Parses a simple integer literal to get its numeric value. Floating + /// point literals and user defined literals are rejected. Used primarily to + /// handle pragmas that accept integer arguments. + bool parseSimpleIntegerLiteral(Token &Tok, uint64_t &Value); + /// Disables macro expansion everywhere except for preprocessor directives. void SetMacroExpansionOnlyInDirectives() { DisableMacroExpansion = true; MacroExpansionInDirectivesOverride = true; } - /// LookAhead - This peeks ahead N tokens and returns that token without - /// consuming any tokens. LookAhead(0) returns the next token that would be - /// returned by Lex(), LookAhead(1) returns the token after it, etc. This - /// returns normal tokens after phase 5. As such, it is equivalent to using + /// \brief Peeks ahead N tokens and returns that token without consuming any + /// tokens. + /// + /// LookAhead(0) returns the next token that would be returned by Lex(), + /// LookAhead(1) returns the token after it, etc. This returns normal + /// tokens after phase 5. As such, it is equivalent to using /// 'Lex', not 'LexUnexpandedToken'. const Token &LookAhead(unsigned N) { if (CachedLexPos + N < CachedTokens.size()) @@ -791,8 +851,9 @@ public: return PeekAhead(N+1); } - /// RevertCachedTokens - When backtracking is enabled and tokens are cached, + /// \brief When backtracking is enabled and tokens are cached, /// this allows to revert a specific number of tokens. + /// /// Note that the number of tokens being reverted should be up to the last /// backtrack position, not more. void RevertCachedTokens(unsigned N) { @@ -805,20 +866,21 @@ public: CachedLexPos -= N; } - /// EnterToken - Enters a token in the token stream to be lexed next. If - /// BackTrack() is called afterwards, the token will remain at the insertion - /// point. + /// \brief Enters a token in the token stream to be lexed next. + /// + /// If BackTrack() is called afterwards, the token will remain at the + /// insertion point. void EnterToken(const Token &Tok) { EnterCachingLexMode(); CachedTokens.insert(CachedTokens.begin()+CachedLexPos, Tok); } - /// AnnotateCachedTokens - We notify the Preprocessor that if it is caching - /// tokens (because backtrack is enabled) it should replace the most recent - /// cached tokens with the given annotation token. This function has no effect - /// if backtracking is not enabled. + /// We notify the Preprocessor that if it is caching tokens (because + /// backtrack is enabled) it should replace the most recent cached tokens + /// with the given annotation token. This function has no effect if + /// backtracking is not enabled. /// - /// Note that the use of this function is just for optimization; so that the + /// Note that the use of this function is just for optimization, so that the /// cached tokens doesn't get re-parsed and re-resolved after a backtrack is /// invoked. void AnnotateCachedTokens(const Token &Tok) { @@ -848,7 +910,7 @@ public: CachedTokens[CachedLexPos-1] = Tok; } - /// TypoCorrectToken - Update the current token to represent the provided + /// Update the current token to represent the provided /// identifier, in order to cache an action performed by typo correction. void TypoCorrectToken(const Token &Tok) { assert(Tok.getIdentifierInfo() && "Expected identifier token"); @@ -886,14 +948,16 @@ public: unsigned Line, unsigned Column); /// \brief Determine if we are performing code completion. - bool isCodeCompletionEnabled() const { return CodeCompletionFile != 0; } + bool isCodeCompletionEnabled() const { return CodeCompletionFile != nullptr; } /// \brief Returns the location of the code-completion point. + /// /// Returns an invalid location if code-completion is not enabled or the file /// containing the code-completion point has not been lexed yet. SourceLocation getCodeCompletionLoc() const { return CodeCompletionLoc; } /// \brief Returns the start location of the file of code-completion point. + /// /// Returns an invalid location if code-completion is not enabled or the file /// containing the code-completion point has not been lexed yet. SourceLocation getCodeCompletionFileLoc() const { @@ -913,8 +977,9 @@ public: } /// \brief The location of the currently-active \#pragma clang - /// arc_cf_code_audited begin. Returns an invalid location if there - /// is no such pragma active. + /// arc_cf_code_audited begin. + /// + /// Returns an invalid location if there is no such pragma active. SourceLocation getPragmaARCCFCodeAuditedLoc() const { return PragmaARCCFCodeAuditedLoc; } @@ -936,7 +1001,7 @@ public: SkipMainFilePreamble.second = StartOfLine; } - /// Diag - Forwarding function for diagnostics. This emits a diagnostic at + /// Forwarding function for diagnostics. This emits a diagnostic at /// the specified Token's location, translating the token's start /// position in the current buffer into a SourcePosition object for rendering. DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const { @@ -947,7 +1012,7 @@ public: return Diags->Report(Tok.getLocation(), DiagID); } - /// getSpelling() - Return the 'spelling' of the token at the given + /// Return the 'spelling' of the token at the given /// location; does not go up to the spelling location or down to the /// expansion location. /// @@ -956,25 +1021,28 @@ public: /// \param invalid If non-null, will be set \c true if an error occurs. StringRef getSpelling(SourceLocation loc, SmallVectorImpl<char> &buffer, - bool *invalid = 0) const { + bool *invalid = nullptr) const { return Lexer::getSpelling(loc, buffer, SourceMgr, LangOpts, invalid); } - /// getSpelling() - Return the 'spelling' of the Tok token. The spelling of a - /// token is the characters used to represent the token in the source file - /// after trigraph expansion and escaped-newline folding. In particular, this - /// wants to get the true, uncanonicalized, spelling of things like digraphs - /// UCNs, etc. + /// \brief Return the 'spelling' of the Tok token. + /// + /// The spelling of a token is the characters used to represent the token in + /// the source file after trigraph expansion and escaped-newline folding. In + /// particular, this wants to get the true, uncanonicalized, spelling of + /// things like digraphs, UCNs, etc. /// /// \param Invalid If non-null, will be set \c true if an error occurs. - std::string getSpelling(const Token &Tok, bool *Invalid = 0) const { + std::string getSpelling(const Token &Tok, bool *Invalid = nullptr) const { return Lexer::getSpelling(Tok, SourceMgr, LangOpts, Invalid); } - /// getSpelling - This method is used to get the spelling of a token into a - /// preallocated buffer, instead of as an std::string. The caller is required - /// to allocate enough space for the token, which is guaranteed to be at least - /// Tok.getLength() bytes long. The length of the actual result is returned. + /// \brief Get the spelling of a token into a preallocated buffer, instead + /// of as an std::string. + /// + /// The caller is required to allocate enough space for the token, which is + /// guaranteed to be at least Tok.getLength() bytes long. The length of the + /// actual result is returned. /// /// Note that this method may do two possible things: it may either fill in /// the buffer specified with characters, or it may *change the input pointer* @@ -982,16 +1050,17 @@ public: /// copy). The caller is not allowed to modify the returned buffer pointer /// if an internal buffer is returned. unsigned getSpelling(const Token &Tok, const char *&Buffer, - bool *Invalid = 0) const { + bool *Invalid = nullptr) const { return Lexer::getSpelling(Tok, Buffer, SourceMgr, LangOpts, Invalid); } - /// getSpelling - This method is used to get the spelling of a token into a - /// SmallVector. Note that the returned StringRef may not point to the + /// \brief Get the spelling of a token into a SmallVector. + /// + /// Note that the returned StringRef may not point to the /// supplied buffer if a copy can be avoided. StringRef getSpelling(const Token &Tok, SmallVectorImpl<char> &Buffer, - bool *Invalid = 0) const; + bool *Invalid = nullptr) const; /// \brief Relex the token at the specified location. /// \returns true if there was a failure, false on success. @@ -1000,10 +1069,11 @@ public: return Lexer::getRawToken(Loc, Result, SourceMgr, LangOpts, IgnoreWhiteSpace); } - /// getSpellingOfSingleCharacterNumericConstant - Tok is a numeric constant - /// with length 1, return the character. - char getSpellingOfSingleCharacterNumericConstant(const Token &Tok, - bool *Invalid = 0) const { + /// \brief Given a Token \p Tok that is a numeric constant with length 1, + /// return the character. + char + getSpellingOfSingleCharacterNumericConstant(const Token &Tok, + bool *Invalid = nullptr) const { assert(Tok.is(tok::numeric_constant) && Tok.getLength() == 1 && "Called on unsupported token"); assert(!Tok.needsCleaning() && "Token can't need cleaning with length 1"); @@ -1019,18 +1089,21 @@ public: /// \brief Retrieve the name of the immediate macro expansion. /// - /// This routine starts from a source location, and finds the name of the macro - /// responsible for its immediate expansion. It looks through any intervening - /// macro argument expansions to compute this. It returns a StringRef which - /// refers to the SourceManager-owned buffer of the source where that macro - /// name is spelled. Thus, the result shouldn't out-live the SourceManager. + /// This routine starts from a source location, and finds the name of the + /// macro responsible for its immediate expansion. It looks through any + /// intervening macro argument expansions to compute this. It returns a + /// StringRef that refers to the SourceManager-owned buffer of the source + /// where that macro name is spelled. Thus, the result shouldn't out-live + /// the SourceManager. StringRef getImmediateMacroName(SourceLocation Loc) { return Lexer::getImmediateMacroName(Loc, SourceMgr, getLangOpts()); } - /// CreateString - Plop the specified string into a scratch buffer and set the - /// specified token's location and length to it. If specified, the source - /// location provides a location of the expansion point of the token. + /// \brief Plop the specified string into a scratch buffer and set the + /// specified token's location and length to it. + /// + /// If specified, the source location provides a location of the expansion + /// point of the token. void CreateString(StringRef Str, Token &Tok, SourceLocation ExpansionLocStart = SourceLocation(), SourceLocation ExpansionLocEnd = SourceLocation()); @@ -1060,7 +1133,7 @@ public: /// \param MacroBegin If non-null and function returns true, it is set to /// begin location of the macro. bool isAtStartOfMacroExpansion(SourceLocation loc, - SourceLocation *MacroBegin = 0) const { + SourceLocation *MacroBegin = nullptr) const { return Lexer::isAtStartOfMacroExpansion(loc, SourceMgr, LangOpts, MacroBegin); } @@ -1071,27 +1144,26 @@ public: /// \param MacroEnd If non-null and function returns true, it is set to /// end location of the macro. bool isAtEndOfMacroExpansion(SourceLocation loc, - SourceLocation *MacroEnd = 0) const { + SourceLocation *MacroEnd = nullptr) const { return Lexer::isAtEndOfMacroExpansion(loc, SourceMgr, LangOpts, MacroEnd); } - /// DumpToken - Print the token to stderr, used for debugging. - /// + /// \brief Print the token to stderr, used for debugging. void DumpToken(const Token &Tok, bool DumpFlags = false) const; void DumpLocation(SourceLocation Loc) const; void DumpMacro(const MacroInfo &MI) const; - /// AdvanceToTokenCharacter - Given a location that specifies the start of a + /// \brief Given a location that specifies the start of a /// token, return a new location that specifies a character within the token. SourceLocation AdvanceToTokenCharacter(SourceLocation TokStart, unsigned Char) const { return Lexer::AdvanceToTokenCharacter(TokStart, Char, SourceMgr, LangOpts); } - /// IncrementPasteCounter - Increment the counters for the number of token - /// paste operations performed. If fast was specified, this is a 'fast paste' - /// case we handled. + /// \brief Increment the counters for the number of token paste operations + /// performed. /// + /// If fast was specified, this is a 'fast paste' case we handled. void IncrementPasteCounter(bool isFast) { if (isFast) ++NumFastTokenPaste; @@ -1103,16 +1175,16 @@ public: size_t getTotalMemory() const; - /// HandleMicrosoftCommentPaste - When the macro expander pastes together a - /// comment (/##/) in microsoft mode, this method handles updating the current - /// state, returning the token on the next source line. + /// When the macro expander pastes together a comment (/##/) in Microsoft + /// mode, this method handles updating the current state, returning the + /// token on the next source line. void HandleMicrosoftCommentPaste(Token &Tok); //===--------------------------------------------------------------------===// // Preprocessor callback methods. These are invoked by a lexer as various // directives and events are found. - /// LookUpIdentifierInfo - Given a tok::raw_identifier token, look up the + /// Given a tok::raw_identifier token, look up the /// identifier information for the token and install it into the token, /// updating the token kind accordingly. IdentifierInfo *LookUpIdentifierInfo(Token &Identifier) const; @@ -1122,14 +1194,13 @@ private: public: - // SetPoisonReason - Call this function to indicate the reason for - // poisoning an identifier. If that identifier is accessed while - // poisoned, then this reason will be used instead of the default - // "poisoned" diagnostic. + /// \brief Specifies the reason for poisoning an identifier. + /// + /// If that identifier is accessed while poisoned, then this reason will be + /// used instead of the default "poisoned" diagnostic. void SetPoisonReason(IdentifierInfo *II, unsigned DiagID); - // HandlePoisonedIdentifier - Display reason for poisoned - // identifier. + /// \brief Display reason for poisoned identifier. void HandlePoisonedIdentifier(Token & Tok); void MaybeHandlePoisonedIdentifier(Token & Identifier) { @@ -1155,45 +1226,53 @@ private: IdentifierInfo *Ident__abnormal_termination, *Ident___abnormal_termination, *Ident_AbnormalTermination; + + const char *getCurLexerEndPos(); + public: void PoisonSEHIdentifiers(bool Poison = true); // Borland - /// HandleIdentifier - This callback is invoked when the lexer reads an - /// identifier and has filled in the tokens IdentifierInfo member. This - /// callback potentially macro expands it or turns it into a named token (like - /// 'for'). + /// \brief Callback invoked when the lexer reads an identifier and has + /// filled in the tokens IdentifierInfo member. + /// + /// This callback potentially macro expands it or turns it into a named + /// token (like 'for'). /// /// \returns true if we actually computed a token, false if we need to /// lex again. bool HandleIdentifier(Token &Identifier); - /// HandleEndOfFile - This callback is invoked when the lexer hits the end of - /// the current file. This either returns the EOF token and returns true, or + /// \brief Callback invoked when the lexer hits the end of the current file. + /// + /// This either returns the EOF token and returns true, or /// pops a level off the include stack and returns false, at which point the /// client should call lex again. bool HandleEndOfFile(Token &Result, bool isEndOfMacro = false); - /// HandleEndOfTokenLexer - This callback is invoked when the current - /// TokenLexer hits the end of its token stream. + /// \brief Callback invoked when the current TokenLexer hits the end of its + /// token stream. bool HandleEndOfTokenLexer(Token &Result); - /// HandleDirective - This callback is invoked when the lexer sees a # token - /// at the start of a line. This consumes the directive, modifies the - /// lexer/preprocessor state, and advances the lexer(s) so that the next token - /// read is the correct one. + /// \brief Callback invoked when the lexer sees a # token at the start of a + /// line. + /// + /// This consumes the directive, modifies the lexer/preprocessor state, and + /// advances the lexer(s) so that the next token read is the correct one. void HandleDirective(Token &Result); - /// CheckEndOfDirective - Ensure that the next token is a tok::eod token. If - /// not, emit a diagnostic and consume up until the eod. If EnableMacros is - /// true, then we consider macros that expand to zero tokens as being ok. + /// \brief Ensure that the next token is a tok::eod token. + /// + /// If not, emit a diagnostic and consume up until the eod. + /// If \p EnableMacros is true, then we consider macros that expand to zero + /// tokens as being ok. void CheckEndOfDirective(const char *Directive, bool EnableMacros = false); - /// DiscardUntilEndOfDirective - Read and discard all tokens remaining on the - /// current line until the tok::eod token is found. + /// \brief Read and discard all tokens remaining on the current line until + /// the tok::eod token is found. void DiscardUntilEndOfDirective(); - /// SawDateOrTime - This returns true if the preprocessor has seen a use of + /// \brief Returns true if the preprocessor has seen a use of /// __DATE__ or __TIME__ in the file so far. bool SawDateOrTime() const { return DATELoc != SourceLocation() || TIMELoc != SourceLocation(); @@ -1234,17 +1313,20 @@ public: ModuleMap::KnownHeader *SuggestedModule, bool SkipCache = false); - /// GetCurLookup - The DirectoryLookup structure used to find the current - /// FileEntry, if CurLexer is non-null and if applicable. This allows us to - /// implement \#include_next and find directory-specific properties. + /// \brief Get the DirectoryLookup structure used to find the current + /// FileEntry, if CurLexer is non-null and if applicable. + /// + /// This allows us to implement \#include_next and find directory-specific + /// properties. const DirectoryLookup *GetCurDirLookup() { return CurDirLookup; } /// \brief Return true if we're in the top-level file, not in a \#include. bool isInPrimaryFile() const; - /// ConcatenateIncludeName - Handle cases where the \#include name is expanded - /// from a macro as multiple tokens, which need to be glued together. This - /// occurs for code like: + /// \brief Handle cases where the \#include name is expanded + /// from a macro as multiple tokens, which need to be glued together. + /// + /// This occurs for code like: /// \code /// \#define FOO <x/y.h> /// \#include FOO @@ -1257,28 +1339,28 @@ public: bool ConcatenateIncludeName(SmallString<128> &FilenameBuffer, SourceLocation &End); - /// LexOnOffSwitch - Lex an on-off-switch (C99 6.10.6p2) and verify that it is + /// \brief Lex an on-off-switch (C99 6.10.6p2) and verify that it is /// followed by EOD. Return true if the token is not a valid on-off-switch. bool LexOnOffSwitch(tok::OnOffSwitch &OOS); + bool CheckMacroName(Token &MacroNameTok, char isDefineUndef); + private: void PushIncludeMacroStack() { - IncludeMacroStack.push_back(IncludeStackInfo(CurLexerKind, - CurLexer.take(), - CurPTHLexer.take(), - CurPPLexer, - CurTokenLexer.take(), - CurDirLookup)); - CurPPLexer = 0; + IncludeMacroStack.push_back(IncludeStackInfo( + CurLexerKind, CurSubmodule, std::move(CurLexer), std::move(CurPTHLexer), + CurPPLexer, std::move(CurTokenLexer), CurDirLookup)); + CurPPLexer = nullptr; } void PopIncludeMacroStack() { - CurLexer.reset(IncludeMacroStack.back().TheLexer); - CurPTHLexer.reset(IncludeMacroStack.back().ThePTHLexer); + CurLexer = std::move(IncludeMacroStack.back().TheLexer); + CurPTHLexer = std::move(IncludeMacroStack.back().ThePTHLexer); CurPPLexer = IncludeMacroStack.back().ThePPLexer; - CurTokenLexer.reset(IncludeMacroStack.back().TheTokenLexer); + CurTokenLexer = std::move(IncludeMacroStack.back().TheTokenLexer); CurDirLookup = IncludeMacroStack.back().TheDirLookup; + CurSubmodule = IncludeMacroStack.back().TheSubmodule; CurLexerKind = IncludeMacroStack.back().CurLexerKind; IncludeMacroStack.pop_back(); } @@ -1300,15 +1382,16 @@ private: /// This memory will be reused for allocating new MacroInfo objects. void ReleaseMacroInfo(MacroInfo* MI); - /// ReadMacroName - Lex and validate a macro name, which occurs after a - /// \#define or \#undef. This emits a diagnostic, sets the token kind to eod, + /// \brief Lex and validate a macro name, which occurs after a + /// \#define or \#undef. + /// + /// This emits a diagnostic, sets the token kind to eod, /// and discards the rest of the macro line if the macro name is invalid. void ReadMacroName(Token &MacroNameTok, char isDefineUndef = 0); - /// ReadMacroDefinitionArgList - The ( starting an argument list of a macro - /// definition has just been read. Lex the rest of the arguments and the - /// closing ), updating MI with what we learn and saving in LastTok the - /// last token read. + /// The ( starting an argument list of a macro definition has just been read. + /// Lex the rest of the arguments and the closing ), updating \p MI with + /// what we learn and saving in \p LastTok the last token read. /// Return true if an error occurs parsing the arg list. bool ReadMacroDefinitionArgList(MacroInfo *MI, Token& LastTok); @@ -1327,21 +1410,22 @@ private: /// \brief A fast PTH version of SkipExcludedConditionalBlock. void PTHSkipExcludedConditionalBlock(); - /// EvaluateDirectiveExpression - Evaluate an integer constant expression that - /// may occur after a #if or #elif directive and return it as a bool. If the - /// expression is equivalent to "!defined(X)" return X in IfNDefMacro. + /// \brief Evaluate an integer constant expression that may occur after a + /// \#if or \#elif directive and return it as a bool. + /// + /// If the expression is equivalent to "!defined(X)" return X in IfNDefMacro. bool EvaluateDirectiveExpression(IdentifierInfo *&IfNDefMacro); - /// RegisterBuiltinPragmas - Install the standard preprocessor pragmas: + /// \brief Install the standard preprocessor pragmas: /// \#pragma GCC poison/system_header/dependency and \#pragma once. void RegisterBuiltinPragmas(); /// \brief Register builtin macros such as __LINE__ with the identifier table. void RegisterBuiltinMacros(); - /// HandleMacroExpandedIdentifier - If an identifier token is read that is to - /// be expanded as a macro, handle it and return the next token as 'Tok'. If - /// we lexed a token, return true; otherwise the caller should lex again. + /// If an identifier token is read that is to be expanded as a macro, handle + /// it and return the next token as 'Tok'. If we lexed a token, return true; + /// otherwise the caller should lex again. bool HandleMacroExpandedIdentifier(Token &Tok, MacroDirective *MD); /// \brief Cache macro expanded tokens for TokenLexers. @@ -1354,52 +1438,51 @@ private: void removeCachedMacroExpandedTokensOfLastLexer(); friend void TokenLexer::ExpandFunctionArguments(); - /// isNextPPTokenLParen - Determine whether the next preprocessor token to be + /// Determine whether the next preprocessor token to be /// lexed is a '('. If so, consume the token and return true, if not, this /// method should have no observable side-effect on the lexed tokens. bool isNextPPTokenLParen(); - /// ReadFunctionLikeMacroArgs - After reading "MACRO(", this method is - /// invoked to read all of the formal arguments specified for the macro - /// invocation. This returns null on error. + /// After reading "MACRO(", this method is invoked to read all of the formal + /// arguments specified for the macro invocation. Returns null on error. MacroArgs *ReadFunctionLikeMacroArgs(Token &MacroName, MacroInfo *MI, SourceLocation &ExpansionEnd); - /// ExpandBuiltinMacro - If an identifier token is read that is to be expanded + /// \brief If an identifier token is read that is to be expanded /// as a builtin macro, handle it and return the next token as 'Tok'. void ExpandBuiltinMacro(Token &Tok); - /// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then - /// return the first token after the directive. The _Pragma token has just - /// been read into 'Tok'. + /// \brief Read a \c _Pragma directive, slice it up, process it, then + /// return the first token after the directive. + /// This assumes that the \c _Pragma token has just been read into \p Tok. void Handle_Pragma(Token &Tok); - /// HandleMicrosoft__pragma - Like Handle_Pragma except the pragma text - /// is not enclosed within a string literal. + /// \brief Like Handle_Pragma except the pragma text is not enclosed within + /// a string literal. void HandleMicrosoft__pragma(Token &Tok); - /// EnterSourceFileWithLexer - Add a lexer to the top of the include stack and + /// \brief Add a lexer to the top of the include stack and /// start lexing tokens from it instead of the current buffer. void EnterSourceFileWithLexer(Lexer *TheLexer, const DirectoryLookup *Dir); - /// EnterSourceFileWithPTH - Add a lexer to the top of the include stack and + /// \brief Add a lexer to the top of the include stack and /// start getting tokens from it using the PTH cache. void EnterSourceFileWithPTH(PTHLexer *PL, const DirectoryLookup *Dir); - /// \brief Set the file ID for the preprocessor predefines. + /// \brief Set the FileID for the preprocessor predefines. void setPredefinesFileID(FileID FID) { assert(PredefinesFileID.isInvalid() && "PredefinesFileID already set!"); PredefinesFileID = FID; } - /// IsFileLexer - Returns true if we are lexing from a file and not a - /// pragma or a macro. + /// \brief Returns true if we are lexing from a file and not a + /// pragma or a macro. static bool IsFileLexer(const Lexer* L, const PreprocessorLexer* P) { - return L ? !L->isPragmaLexer() : P != 0; + return L ? !L->isPragmaLexer() : P != nullptr; } static bool IsFileLexer(const IncludeStackInfo& I) { - return IsFileLexer(I.TheLexer, I.ThePPLexer); + return IsFileLexer(I.TheLexer.get(), I.ThePPLexer); } bool IsFileLexer() const { @@ -1437,7 +1520,7 @@ private: // File inclusion. void HandleIncludeDirective(SourceLocation HashLoc, Token &Tok, - const DirectoryLookup *LookupFrom = 0, + const DirectoryLookup *LookupFrom = nullptr, bool isImport = false); void HandleIncludeNextDirective(SourceLocation HashLoc, Token &Tok); void HandleIncludeMacrosDirective(SourceLocation HashLoc, Token &Tok); @@ -1449,25 +1532,6 @@ private: /// points to. Module *getModuleForLocation(SourceLocation FilenameLoc); - /// \brief Verify that a private header is included only from within its - /// module. - bool violatesPrivateInclude(Module *RequestingModule, - const FileEntry *IncFileEnt, - ModuleMap::ModuleHeaderRole Role, - Module *RequestedModule); - - /// \brief Verify that a module includes headers only from modules that it - /// has declared that it uses. - bool violatesUseDeclarations(Module *RequestingModule, - Module *RequestedModule); - - /// \brief Verify that it is legal for the source file that \p FilenameLoc - /// points to to include the file \p Filename. - /// - /// Tries to reuse \p IncFileEnt. - void verifyModuleInclude(SourceLocation FilenameLoc, StringRef Filename, - const FileEntry *IncFileEnt); - // Macro handling. void HandleDefineDirective(Token &Tok, bool ImmediatelyAfterTopLevelIfndef); void HandleUndefDirective(Token &Tok); |