Preprocessor.h revision 0ea76727ae91bca918a8414ed85b530eddcfedeb
1ce99120084f549a523213064648662a704e8b789Chris Lattner//===--- Preprocessor.h - C Language Family Preprocessor --------*- C++ -*-===// 2ce99120084f549a523213064648662a704e8b789Chris Lattner// 3ce99120084f549a523213064648662a704e8b789Chris Lattner// The LLVM Compiler Infrastructure 4ce99120084f549a523213064648662a704e8b789Chris Lattner// 5ce99120084f549a523213064648662a704e8b789Chris Lattner// This file is distributed under the University of Illinois Open Source 6ce99120084f549a523213064648662a704e8b789Chris Lattner// License. See LICENSE.TXT for details. 7ce99120084f549a523213064648662a704e8b789Chris Lattner// 8ce99120084f549a523213064648662a704e8b789Chris Lattner//===----------------------------------------------------------------------===// 9ce99120084f549a523213064648662a704e8b789Chris Lattner// 10ce99120084f549a523213064648662a704e8b789Chris Lattner// This file defines the Preprocessor interface. 11ce99120084f549a523213064648662a704e8b789Chris Lattner// 12ce99120084f549a523213064648662a704e8b789Chris Lattner//===----------------------------------------------------------------------===// 139d434dbff3eb0501efc3457acec2401afdffef2fEli Friedman 14255f89faee13dc491cb64fbeae3c763e7e2ea4e6Chandler Carruth#ifndef LLVM_CLANG_LEX_PREPROCESSOR_H 15ce99120084f549a523213064648662a704e8b789Chris Lattner#define LLVM_CLANG_LEX_PREPROCESSOR_H 16ce99120084f549a523213064648662a704e8b789Chris Lattner 17ce99120084f549a523213064648662a704e8b789Chris Lattner#include "clang/Lex/Lexer.h" 18ce99120084f549a523213064648662a704e8b789Chris Lattner#include "clang/Lex/PTHLexer.h" 19ce99120084f549a523213064648662a704e8b789Chris Lattner#include "clang/Lex/PPCallbacks.h" 20ce99120084f549a523213064648662a704e8b789Chris Lattner#include "clang/Lex/TokenLexer.h" 21cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge#include "clang/Lex/PTHManager.h" 22cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge#include "clang/Basic/Diagnostic.h" 23cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge#include "clang/Basic/IdentifierTable.h" 24cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge#include "clang/Basic/SourceLocation.h" 258e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer#include "llvm/ADT/DenseMap.h" 268e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer#include "llvm/ADT/OwningPtr.h" 2772c8331ec1437f8c33fff1dac1ea0ebb11009411Richard Smith#include "llvm/Support/Allocator.h" 2872c8331ec1437f8c33fff1dac1ea0ebb11009411Richard Smith 298e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramernamespace clang { 308e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer 3172c8331ec1437f8c33fff1dac1ea0ebb11009411Richard Smithclass SourceManager; 3272c8331ec1437f8c33fff1dac1ea0ebb11009411Richard Smithclass FileManager; 338e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramerclass FileEntry; 348e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramerclass HeaderSearch; 358e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramerclass PragmaNamespace; 368e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramerclass PragmaHandler; 378e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramerclass ScratchBuffer; 388e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramerclass TargetInfo; 398e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramerclass PPCallbacks; 408e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramerclass DirectoryLookup; 418e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer 428e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer/// Preprocessor - This object engages in a tight little dance with the lexer to 438e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer/// efficiently preprocess tokens. Lexers know only about tokens within a 448e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer/// single source file, and don't know anything about preprocessor-level issues 458e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer/// like the #include stack, token expansion, etc. 468e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer/// 478e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramerclass Preprocessor { 488e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer Diagnostic &Diags; 49208130f11331eccab26c0a6f3146cd1891e53e33Bob Wilson const LangOptions &Features; 50208130f11331eccab26c0a6f3146cd1891e53e33Bob Wilson TargetInfo &Target; 51208130f11331eccab26c0a6f3146cd1891e53e33Bob Wilson FileManager &FileMgr; 52208130f11331eccab26c0a6f3146cd1891e53e33Bob Wilson SourceManager &SourceMgr; 53d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson ScratchBuffer *ScratchBuf; 54d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson HeaderSearch &HeaderInfo; 55d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson 56d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson /// PTH - An optional PTHManager object used for getting tokens from 57d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson /// a token cache rather than lexing the original source file. 58d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson llvm::OwningPtr<PTHManager> PTH; 59d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson 60d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson /// BP - A BumpPtrAllocator object used to quickly allocate and release 61d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson /// objects internal to the Preprocessor. 62cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge llvm::BumpPtrAllocator BP; 63cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 64cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// Identifiers for builtin macros and other builtins. 65cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge IdentifierInfo *Ident__LINE__, *Ident__FILE__; // __LINE__, __FILE__ 66d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson IdentifierInfo *Ident__DATE__, *Ident__TIME__; // __DATE__, __TIME__ 67d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson IdentifierInfo *Ident__INCLUDE_LEVEL__; // __INCLUDE_LEVEL__ 68208130f11331eccab26c0a6f3146cd1891e53e33Bob Wilson IdentifierInfo *Ident__BASE_FILE__; // __BASE_FILE__ 69208130f11331eccab26c0a6f3146cd1891e53e33Bob Wilson IdentifierInfo *Ident__TIMESTAMP__; // __TIMESTAMP__ 7036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines IdentifierInfo *Ident_Pragma, *Ident__VA_ARGS__; // _Pragma, __VA_ARGS__ 7136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 72208130f11331eccab26c0a6f3146cd1891e53e33Bob Wilson SourceLocation DATELoc, TIMELoc; 73208130f11331eccab26c0a6f3146cd1891e53e33Bob Wilson 74208130f11331eccab26c0a6f3146cd1891e53e33Bob Wilson enum { 75208130f11331eccab26c0a6f3146cd1891e53e33Bob Wilson /// MaxIncludeStackDepth - Maximum depth of #includes. 76b704d23062aa78b00999b75dcdcb628d4d84ee3fPreston Gurd MaxAllowedIncludeStackDepth = 200 77b704d23062aa78b00999b75dcdcb628d4d84ee3fPreston Gurd }; 78b704d23062aa78b00999b75dcdcb628d4d84ee3fPreston Gurd 79b704d23062aa78b00999b75dcdcb628d4d84ee3fPreston Gurd // State that is set before the preprocessor begins. 80b704d23062aa78b00999b75dcdcb628d4d84ee3fPreston Gurd bool KeepComments : 1; 81b704d23062aa78b00999b75dcdcb628d4d84ee3fPreston Gurd bool KeepMacroComments : 1; 82cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 83cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge // State that changes while the preprocessor runs: 84cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge bool DisableMacroExpansion : 1; // True if macro expansion is disabled. 85cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge bool InMacroArgs : 1; // True if parsing fn macro invocation args. 86cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 87cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// Identifiers - This is mapping/lookup information for all identifiers in 886098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge /// the program, including program keywords. 896098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge IdentifierTable Identifiers; 90cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 91cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// Selectors - This table contains all the selectors in the program. Unlike 928ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier /// IdentifierTable above, this table *isn't* populated by the preprocessor. 938ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier /// It is declared/instantiated here because it's role/lifetime is 948ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier /// conceptually similar the IdentifierTable. In addition, the current control 958ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier /// flow (in clang::ParseAST()), make it convenient to put here. 966871d1eceba0455707de29708c36ae3c2778c160Chad Rosier /// FIXME: Make sure the lifetime of Identifiers/Selectors *isn't* tied to 976871d1eceba0455707de29708c36ae3c2778c160Chad Rosier /// the lifetime fo the preprocessor. 986871d1eceba0455707de29708c36ae3c2778c160Chad Rosier SelectorTable Selectors; 996871d1eceba0455707de29708c36ae3c2778c160Chad Rosier 1006871d1eceba0455707de29708c36ae3c2778c160Chad Rosier /// PragmaHandlers - This tracks all of the pragmas that the client registered 1016871d1eceba0455707de29708c36ae3c2778c160Chad Rosier /// with this preprocessor. 102d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson PragmaNamespace *PragmaHandlers; 103d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson 1048ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier /// CurLexer - This is the current top of the stack that we're lexing from if 1058ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier /// not expanding a macro and we are lexing directly from source code. 1068ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier /// Only one of CurLexer, CurPTHLexer, or CurTokenLexer will be non-null. 1078ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier llvm::OwningPtr<Lexer> CurLexer; 1086871d1eceba0455707de29708c36ae3c2778c160Chad Rosier 1096871d1eceba0455707de29708c36ae3c2778c160Chad Rosier /// CurPTHLexer - This is the current top of stack that we're lexing from if 1106871d1eceba0455707de29708c36ae3c2778c160Chad Rosier /// not expanding from a macro and we are lexing from a PTH cache. 1116871d1eceba0455707de29708c36ae3c2778c160Chad Rosier /// Only one of CurLexer, CurPTHLexer, or CurTokenLexer will be non-null. 1126871d1eceba0455707de29708c36ae3c2778c160Chad Rosier llvm::OwningPtr<PTHLexer> CurPTHLexer; 1136871d1eceba0455707de29708c36ae3c2778c160Chad Rosier 114d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson /// CurPPLexer - This is the current top of the stack what we're lexing from 115d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson /// if not expanding a macro. This is an alias for either CurLexer or 1168ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier /// CurPTHLexer. 1178ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier PreprocessorLexer* CurPPLexer; 11832b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier 11932b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier /// CurLookup - The DirectoryLookup structure used to find the current 12032b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier /// FileEntry, if CurLexer is non-null and if applicable. This allows us to 12132b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier /// implement #include_next and find directory-specific properties. 122d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson const DirectoryLookup *CurDirLookup; 123d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson 124d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson /// CurTokenLexer - This is the current macro we are expanding, if we are 125d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson /// expanding a macro. One of CurLexer and CurTokenLexer must be null. 1266871d1eceba0455707de29708c36ae3c2778c160Chad Rosier llvm::OwningPtr<TokenLexer> CurTokenLexer; 1276871d1eceba0455707de29708c36ae3c2778c160Chad Rosier 1286871d1eceba0455707de29708c36ae3c2778c160Chad Rosier /// IncludeMacroStack - This keeps track of the stack of files currently 1296871d1eceba0455707de29708c36ae3c2778c160Chad Rosier /// #included, and macros currently being expanded from, not counting 1306871d1eceba0455707de29708c36ae3c2778c160Chad Rosier /// CurLexer/CurTokenLexer. 1316871d1eceba0455707de29708c36ae3c2778c160Chad Rosier struct IncludeStackInfo { 132d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson Lexer *TheLexer; 133d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson PTHLexer *ThePTHLexer; 134cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge PreprocessorLexer *ThePPLexer; 135cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge TokenLexer *TheTokenLexer; 136cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge const DirectoryLookup *TheDirLookup; 137cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 138cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge IncludeStackInfo(Lexer *L, PTHLexer* P, PreprocessorLexer* PPL, 139cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge TokenLexer* TL, const DirectoryLookup *D) 140cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge : TheLexer(L), ThePTHLexer(P), ThePPLexer(PPL), TheTokenLexer(TL), 141cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge TheDirLookup(D) {} 142cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge }; 143cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge std::vector<IncludeStackInfo> IncludeMacroStack; 144cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 145cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// Callbacks - These are actions invoked when some preprocessor activity is 146cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// encountered (e.g. a file is #included, etc). 147cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge PPCallbacks *Callbacks; 1488e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer 1498e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer /// Macros - For each IdentifierInfo with 'HasMacro' set, we keep a mapping 1506871d1eceba0455707de29708c36ae3c2778c160Chad Rosier /// to the actual definition of the macro. 1516871d1eceba0455707de29708c36ae3c2778c160Chad Rosier llvm::DenseMap<IdentifierInfo*, MacroInfo*> Macros; 1526871d1eceba0455707de29708c36ae3c2778c160Chad Rosier 1536871d1eceba0455707de29708c36ae3c2778c160Chad Rosier /// MICache - A "freelist" of MacroInfo objects that can be reused for quick 1546871d1eceba0455707de29708c36ae3c2778c160Chad Rosier /// allocation. 1556871d1eceba0455707de29708c36ae3c2778c160Chad Rosier std::vector<MacroInfo*> MICache; 1568ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier 1578ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier // Various statistics we track for performance analysis. 1588ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier unsigned NumDirectives, NumIncluded, NumDefined, NumUndefined, NumPragma; 1598ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier unsigned NumIf, NumElse, NumEndif; 160d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson unsigned NumEnteredSourceFiles, MaxIncludeStackDepth; 161d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson unsigned NumMacroExpanded, NumFnMacroExpanded, NumBuiltinMacroExpanded; 162cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge unsigned NumFastMacroExpanded, NumTokenPaste, NumFastTokenPaste; 163cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge unsigned NumSkipped; 164cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 165cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// Predefines - This string is the predefined macros that preprocessor 166cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// should use from the command line etc. 167cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge std::string Predefines; 168cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 169cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// TokenLexerCache - Cache macro expanders to reduce malloc traffic. 170243eb9ecbbc6775e346e94025bd255bbceac9fcaOwen Anderson enum { TokenLexerCacheSize = 8 }; 171243eb9ecbbc6775e346e94025bd255bbceac9fcaOwen Anderson unsigned NumCachedTokenLexers; 172243eb9ecbbc6775e346e94025bd255bbceac9fcaOwen Anderson TokenLexer *TokenLexerCache[TokenLexerCacheSize]; 173243eb9ecbbc6775e346e94025bd255bbceac9fcaOwen Anderson 174243eb9ecbbc6775e346e94025bd255bbceac9fcaOwen Andersonprivate: // Cached tokens state. 175243eb9ecbbc6775e346e94025bd255bbceac9fcaOwen Anderson typedef std::vector<Token> CachedTokensTy; 1768ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier 1778ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier /// CachedTokens - Cached tokens are stored here when we do backtracking or 1788ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier /// lookahead. They are "lexed" by the CachingLex() method. 1798ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier CachedTokensTy CachedTokens; 1808ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier 1818ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier /// CachedLexPos - The position of the cached token that CachingLex() should 1828ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier /// "lex" next. If it points beyond the CachedTokens vector, it means that 1838ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier /// a normal Lex() should be invoked. 184d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson CachedTokensTy::size_type CachedLexPos; 185d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson 186d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson /// BacktrackPositions - Stack of backtrack positions, allowing nested 187d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson /// backtracks. The EnableBacktrackAtThisPos() method pushes a position to 188cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// indicate where CachedLexPos should be set when the BackTrack() method is 189cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// invoked (at which point the last position is popped). 1908ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier std::vector<CachedTokensTy::size_type> BacktrackPositions; 1918ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier 1926871d1eceba0455707de29708c36ae3c2778c160Chad Rosierpublic: 1936871d1eceba0455707de29708c36ae3c2778c160Chad Rosier Preprocessor(Diagnostic &diags, const LangOptions &opts, TargetInfo &target, 1946871d1eceba0455707de29708c36ae3c2778c160Chad Rosier SourceManager &SM, HeaderSearch &Headers); 1956871d1eceba0455707de29708c36ae3c2778c160Chad Rosier ~Preprocessor(); 1966871d1eceba0455707de29708c36ae3c2778c160Chad Rosier 1976871d1eceba0455707de29708c36ae3c2778c160Chad Rosier Diagnostic &getDiagnostics() const { return Diags; } 1988ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier const LangOptions &getLangOptions() const { return Features; } 1998ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier TargetInfo &getTargetInfo() const { return Target; } 2008ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier FileManager &getFileManager() const { return FileMgr; } 2018ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier SourceManager &getSourceManager() const { return SourceMgr; } 202d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson HeaderSearch &getHeaderSearchInfo() const { return HeaderInfo; } 203d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson 204d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson IdentifierTable &getIdentifierTable() { return Identifiers; } 205d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson SelectorTable &getSelectorTable() { return Selectors; } 206d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson 207d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson void setPTHManager(PTHManager* pm) { PTH.reset(pm); } 2088ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier 2098ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier /// SetCommentRetentionState - Control whether or not the preprocessor retains 2108ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier /// comments in output. 211d5bda5ec663f43710fe462f44b77ddbcf8fe9d9eJoe Groff void SetCommentRetentionState(bool KeepComments, bool KeepMacroComments) { 212d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson this->KeepComments = KeepComments | KeepMacroComments; 213d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson this->KeepMacroComments = KeepMacroComments; 2148ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier } 2158ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier 2168ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier bool getCommentRetentionState() const { return KeepComments; } 2178ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier 218d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson /// isCurrentLexer - Return true if we are lexing directly from the specified 219d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson /// lexer. 220cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge bool isCurrentLexer(const PreprocessorLexer *L) const { 221cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge return CurPPLexer == L; 222cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge } 223cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 224cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// getCurrentLexer - Return the current file lexer being lexed from. Note 225cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// that this ignores any potentially active macro expansions and _Pragma 226cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// expansions going on at the time. 227cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge PreprocessorLexer *getCurrentFileLexer() const; 228cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 229cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// getPPCallbacks/setPPCallbacks - Accessors for preprocessor callbacks. 2306098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge /// Note that this class takes ownership of any PPCallbacks object given to 2316098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge /// it. 2326098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge PPCallbacks *getPPCallbacks() const { return Callbacks; } 2336098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge void setPPCallbacks(PPCallbacks *C) { 2346098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge delete Callbacks; 2356098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge Callbacks = C; 236cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge } 237cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 238cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// getMacroInfo - Given an identifier, return the MacroInfo it is #defined to 239cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// or null if it isn't #define'd. 240cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge MacroInfo *getMacroInfo(IdentifierInfo *II) const { 241cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge return II->hasMacroDefinition() ? Macros.find(II)->second : 0; 242cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge } 243cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 244d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson /// setMacroInfo - Specify a macro for this identifier. 245d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson /// 246cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge void setMacroInfo(IdentifierInfo *II, MacroInfo *MI); 247cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 2488ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier const std::string &getPredefines() const { return Predefines; } 2498ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier /// setPredefines - Set the predefines for this Preprocessor. These 2508ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier /// predefines are automatically injected when parsing the main file. 2518ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier void setPredefines(const char *P) { Predefines = P; } 252d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson void setPredefines(const std::string &P) { Predefines = P; } 253d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson 25436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines /// getIdentifierInfo - Return information about the specified preprocessor 25536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines /// identifier token. The version of this method that takes two character 25636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines /// pointers is preferred unless the identifier is already available as a 25736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines /// string (this avoids allocation and copying of memory to construct an 25836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines /// std::string). 25936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines IdentifierInfo *getIdentifierInfo(const char *NameStart, 26036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const char *NameEnd) { 26136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return &Identifiers.get(NameStart, NameEnd); 26236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 26336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines IdentifierInfo *getIdentifierInfo(const char *NameStr) { 26436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return getIdentifierInfo(NameStr, NameStr+strlen(NameStr)); 26536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 26632b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier 26732b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier /// AddPragmaHandler - Add the specified pragma handler to the preprocessor. 26832b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier /// If 'Namespace' is non-null, then it is a token required to exist on the 26932b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier /// pragma line before the pragma string starts, e.g. "STDC" or "GCC". 270d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson void AddPragmaHandler(const char *Namespace, PragmaHandler *Handler); 271d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson 272cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// RemovePragmaHandler - Remove the specific pragma handler from 273cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// the preprocessor. If \arg Namespace is non-null, then it should 274cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// be the namespace that \arg Handler was added to. It is an error 275cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// to remove a handler that has not been registered. 2766098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge void RemovePragmaHandler(const char *Namespace, PragmaHandler *Handler); 2776098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge 2788d32463a9fa2aba9de552350a5019099edf0b90dNuno Lopes /// EnterMainSourceFile - Enter the specified FileID as the main source file, 2798d32463a9fa2aba9de552350a5019099edf0b90dNuno Lopes /// which implicitly adds the builtin defines etc. 280683e47b1dd8672b0b026a45022cf91f4faf7df9bChad Rosier void EnterMainSourceFile(); 281683e47b1dd8672b0b026a45022cf91f4faf7df9bChad Rosier 282cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// EnterSourceFile - Add a source file to the top of the include stack and 283cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// start lexing tokens from it instead of the current buffer. If isMainFile 2848e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer /// is true, this is the main file for the translation unit. 2858e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer void EnterSourceFile(unsigned CurFileID, const DirectoryLookup *Dir); 286cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 287cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// EnterMacro - Add a Macro to the top of the include stack and start lexing 288cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// tokens from it instead of the current buffer. Args specifies the 289cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// tokens input to a function-like macro. 290cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge void EnterMacro(Token &Identifier, MacroArgs *Args); 291cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 292cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// EnterTokenStream - Add a "macro" context to the top of the include stack, 293cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// which will cause the lexer to start returning the specified tokens. 294cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// 295cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// If DisableMacroExpansion is true, tokens lexed from the token stream will 296cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// not be subject to further macro expansion. Otherwise, these tokens will 297cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// be re-macro-expanded when/if expansion is enabled. 298cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// 299cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// If OwnsTokens is false, this method assumes that the specified stream of 300cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// tokens has a permanent owner somewhere, so they do not need to be copied. 301cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// If it is true, it assumes the array of tokens is allocated with new[] and 302cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// must be freed. 303cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// 304cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge void EnterTokenStream(const Token *Toks, unsigned NumToks, 305cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge bool DisableMacroExpansion, bool OwnsTokens); 306cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 307cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// RemoveTopOfLexerStack - Pop the current lexer/macro exp off the top of the 308cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// lexer stack. This should only be used in situations where the current 309cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// state of the top-of-stack lexer is known. 310cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge void RemoveTopOfLexerStack(); 311cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 312cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// EnableBacktrackAtThisPos - From the point that this method is called, and 313cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// until CommitBacktrackedTokens() or Backtrack() is called, the Preprocessor 314cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// keeps track of the lexed tokens so that a subsequent Backtrack() call will 315cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// make the Preprocessor re-lex the same tokens. 316cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// 317cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// Nested backtracks are allowed, meaning that EnableBacktrackAtThisPos can 318cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// be called multiple times and CommitBacktrackedTokens/Backtrack calls will 319cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// be combined with the EnableBacktrackAtThisPos calls in reverse order. 320683e47b1dd8672b0b026a45022cf91f4faf7df9bChad Rosier /// 321683e47b1dd8672b0b026a45022cf91f4faf7df9bChad Rosier /// NOTE: *DO NOT* forget to call either CommitBacktrackedTokens or Backtrack 322683e47b1dd8672b0b026a45022cf91f4faf7df9bChad Rosier /// at some point after EnableBacktrackAtThisPos. If you don't, caching of 323cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// tokens will continue indefinitely. 324cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// 325cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge void EnableBacktrackAtThisPos(); 326cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 327cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// CommitBacktrackedTokens - Disable the last EnableBacktrackAtThisPos call. 328cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge void CommitBacktrackedTokens(); 329cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 330cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// Backtrack - Make Preprocessor re-lex the tokens that were lexed since 331cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// EnableBacktrackAtThisPos() was previously called. 332cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge void Backtrack(); 333cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 334cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// isBacktrackEnabled - True if EnableBacktrackAtThisPos() was called and 335cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// caching of tokens is on. 336cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge bool isBacktrackEnabled() const { return !BacktrackPositions.empty(); } 337cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 338cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// Lex - To lex a token from the preprocessor, just pull a token from the 339f0f85eab0469ac93f9bb6c7d19aca2c35868d83aMichael Gottesman /// current lexer or macro object. 340f0f85eab0469ac93f9bb6c7d19aca2c35868d83aMichael Gottesman void Lex(Token &Result) { 341cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge if (CurLexer) 342cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge CurLexer->Lex(Result); 343cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge else if (CurPTHLexer) 344cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge CurPTHLexer->Lex(Result); 345683e47b1dd8672b0b026a45022cf91f4faf7df9bChad Rosier else if (CurTokenLexer) 346683e47b1dd8672b0b026a45022cf91f4faf7df9bChad Rosier CurTokenLexer->Lex(Result); 3476098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge else 3486098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge CachingLex(Result); 3496098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge } 3506098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge 3516098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge /// LexNonComment - Lex a token. If it's a comment, keep lexing until we get 3526098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge /// something not a comment. This is useful in -E -C mode where comments 353cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// would foul up preprocessor directive handling. 354cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge void LexNonComment(Token &Result) { 35536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines do 35636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Lex(Result); 35736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines while (Result.getKind() == tok::comment); 35836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 35936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 36036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines /// LexUnexpandedToken - This is just like Lex, but this disables macro 3616098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge /// expansion of identifier tokens. 3626098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge void LexUnexpandedToken(Token &Result) { 3638ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier // Disable macro expansion. 3648ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier bool OldVal = DisableMacroExpansion; 3658ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier DisableMacroExpansion = true; 3668ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier // Lex the token. 3678ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier Lex(Result); 3688ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier 369d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson // Reenable it. 370d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson DisableMacroExpansion = OldVal; 3718ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier } 3728ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier 3738ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier /// LookAhead - This peeks ahead N tokens and returns that token without 3748ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier /// consuming any tokens. LookAhead(0) returns the next token that would be 375d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson /// returned by Lex(), LookAhead(1) returns the token after it, etc. This 376d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson /// returns normal tokens after phase 5. As such, it is equivalent to using 377d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson /// 'Lex', not 'LexUnexpandedToken'. 378d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson const Token &LookAhead(unsigned N) { 379d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson if (CachedLexPos + N < CachedTokens.size()) 380d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson return CachedTokens[CachedLexPos+N]; 381d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson else 382d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson return PeekAhead(N+1); 3836871d1eceba0455707de29708c36ae3c2778c160Chad Rosier } 3846871d1eceba0455707de29708c36ae3c2778c160Chad Rosier 3856871d1eceba0455707de29708c36ae3c2778c160Chad Rosier /// RevertCachedTokens - When backtracking is enabled and tokens are cached, 3866871d1eceba0455707de29708c36ae3c2778c160Chad Rosier /// this allows to revert a specific number of tokens. 3876871d1eceba0455707de29708c36ae3c2778c160Chad Rosier /// Note that the number of tokens being reverted should be up to the last 3886871d1eceba0455707de29708c36ae3c2778c160Chad Rosier /// backtrack position, not more. 389d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson void RevertCachedTokens(unsigned N) { 390d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson assert(isBacktrackEnabled() && 391d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson "Should only be called when tokens are cached for backtracking"); 392d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson assert(signed(CachedLexPos) - signed(N) >= signed(BacktrackPositions.back()) 393cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge && "Should revert tokens up to the last backtrack position, not more"); 394cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge assert(signed(CachedLexPos) - signed(N) >= 0 && 395cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge "Corrupted backtrack positions ?"); 396cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge CachedLexPos -= N; 3978e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer } 3988e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer 399cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// EnterToken - Enters a token in the token stream to be lexed next. If 400cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// BackTrack() is called afterwards, the token will remain at the insertion 401cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// point. 402cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge void EnterToken(const Token &Tok) { 4038d32463a9fa2aba9de552350a5019099edf0b90dNuno Lopes EnterCachingLexMode(); 4048d32463a9fa2aba9de552350a5019099edf0b90dNuno Lopes CachedTokens.insert(CachedTokens.begin()+CachedLexPos, Tok); 4058d32463a9fa2aba9de552350a5019099edf0b90dNuno Lopes } 4068d32463a9fa2aba9de552350a5019099edf0b90dNuno Lopes 407683e47b1dd8672b0b026a45022cf91f4faf7df9bChad Rosier /// AnnotateCachedTokens - We notify the Preprocessor that if it is caching 408398c0d8b7417dedbe244020ffb67abb54aaa1c59Chris Lattner /// tokens (because backtrack is enabled) it should replace the most recent 409683e47b1dd8672b0b026a45022cf91f4faf7df9bChad Rosier /// cached tokens with the given annotation token. This function has no effect 410149f5283f93ec85b96888c284f56099a72cc2731Chris Lattner /// if backtracking is not enabled. 411cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// 412cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// Note that the use of this function is just for optimization; so that the 413683e47b1dd8672b0b026a45022cf91f4faf7df9bChad Rosier /// cached tokens doesn't get re-parsed and re-resolved after a backtrack is 414683e47b1dd8672b0b026a45022cf91f4faf7df9bChad Rosier /// invoked. 415ce99120084f549a523213064648662a704e8b789Chris Lattner void AnnotateCachedTokens(const Token &Tok) { 416ce99120084f549a523213064648662a704e8b789Chris Lattner assert(Tok.isAnnotationToken() && "Expected annotation token"); 417cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge if (CachedLexPos != 0 && InCachingLexMode()) 418cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge AnnotatePreviousCachedTokens(Tok); 419cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge } 420cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 421cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// Diag - Forwarding function for diagnostics. This emits a diagnostic at 422cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// the specified Token's location, translating the token's start 423cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// position in the current buffer into a SourcePosition object for rendering. 424cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) { 425cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge return Diags.Report(FullSourceLoc(Loc, getSourceManager()), DiagID); 426cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge } 427243eb9ecbbc6775e346e94025bd255bbceac9fcaOwen Anderson 428243eb9ecbbc6775e346e94025bd255bbceac9fcaOwen Anderson DiagnosticBuilder Diag(const Token &Tok, unsigned DiagID) { 429243eb9ecbbc6775e346e94025bd255bbceac9fcaOwen Anderson return Diags.Report(FullSourceLoc(Tok.getLocation(), getSourceManager()), 430243eb9ecbbc6775e346e94025bd255bbceac9fcaOwen Anderson DiagID); 431243eb9ecbbc6775e346e94025bd255bbceac9fcaOwen Anderson } 432243eb9ecbbc6775e346e94025bd255bbceac9fcaOwen Anderson 433cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// getSpelling() - Return the 'spelling' of the Tok token. The spelling of a 434cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// token is the characters used to represent the token in the source file 435cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// after trigraph expansion and escaped-newline folding. In particular, this 436cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// wants to get the true, uncanonicalized, spelling of things like digraphs 437cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// UCNs, etc. 438cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge std::string getSpelling(const Token &Tok) const; 439cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 440cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// getSpelling - This method is used to get the spelling of a token into a 441cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// preallocated buffer, instead of as an std::string. The caller is required 442cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// to allocate enough space for the token, which is guaranteed to be at least 443cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// Tok.getLength() bytes long. The length of the actual result is returned. 444cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// 445cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// Note that this method may do two possible things: it may either fill in 446cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// the buffer specified with characters, or it may *change the input pointer* 447cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// to point to a constant buffer with the data already in it (avoiding a 448cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// copy). The caller is not allowed to modify the returned buffer pointer 4498e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer /// if an internal buffer is returned. 4508e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer unsigned getSpelling(const Token &Tok, const char *&Buffer) const; 4518ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier 4528ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier 4538ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier /// CreateString - Plop the specified string into a scratch buffer and return 4548ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier /// a location for it. If specified, the source location provides a source 4558ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier /// location for the token. 4568ff4115ef0bcad0a46750bb2bd4376a61b346362Chad Rosier SourceLocation CreateString(const char *Buf, unsigned Len, 457cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge SourceLocation SourceLoc = SourceLocation()); 458cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 4596098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge /// DumpToken - Print the token to stderr, used for debugging. 4606098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge /// 461cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge void DumpToken(const Token &Tok, bool DumpFlags = false) const; 462cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge void DumpLocation(SourceLocation Loc) const; 4638d32463a9fa2aba9de552350a5019099edf0b90dNuno Lopes void DumpMacro(const MacroInfo &MI) const; 4648d32463a9fa2aba9de552350a5019099edf0b90dNuno Lopes 4658d32463a9fa2aba9de552350a5019099edf0b90dNuno Lopes /// AdvanceToTokenCharacter - Given a location that specifies the start of a 4668d32463a9fa2aba9de552350a5019099edf0b90dNuno Lopes /// token, return a new location that specifies a character within the token. 467cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge SourceLocation AdvanceToTokenCharacter(SourceLocation TokStart,unsigned Char); 468cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 469cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// IncrementPasteCounter - Increment the counters for the number of token 470cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// paste operations performed. If fast was specified, this is a 'fast paste' 471cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// case we handled. 472cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// 473cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge void IncrementPasteCounter(bool isFast) { 474cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge if (isFast) 475cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge ++NumFastTokenPaste; 476cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge else 4778e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer ++NumTokenPaste; 4788e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer } 4798e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer 4808e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer void PrintStats(); 481cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 482cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// HandleMicrosoftCommentPaste - When the macro expander pastes together a 483cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// comment (/##/) in microsoft mode, this method handles updating the current 484cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// state, returning the token on the next source line. 485cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge void HandleMicrosoftCommentPaste(Token &Tok); 486cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 487cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge //===--------------------------------------------------------------------===// 488cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge // Preprocessor callback methods. These are invoked by a lexer as various 489243eb9ecbbc6775e346e94025bd255bbceac9fcaOwen Anderson // directives and events are found. 490243eb9ecbbc6775e346e94025bd255bbceac9fcaOwen Anderson 491243eb9ecbbc6775e346e94025bd255bbceac9fcaOwen Anderson /// LookUpIdentifierInfo - Given a tok::identifier token, look up the 492243eb9ecbbc6775e346e94025bd255bbceac9fcaOwen Anderson /// identifier information for the token and install it into the token. 493d5bda5ec663f43710fe462f44b77ddbcf8fe9d9eJoe Groff IdentifierInfo *LookUpIdentifierInfo(Token &Identifier, 494243eb9ecbbc6775e346e94025bd255bbceac9fcaOwen Anderson const char *BufPtr = 0); 495cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 496cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// HandleIdentifier - This callback is invoked when the lexer reads an 497d5bda5ec663f43710fe462f44b77ddbcf8fe9d9eJoe Groff /// identifier and has filled in the tokens IdentifierInfo member. This 498d5bda5ec663f43710fe462f44b77ddbcf8fe9d9eJoe Groff /// callback potentially macro expands it or turns it into a named token (like 499d5bda5ec663f43710fe462f44b77ddbcf8fe9d9eJoe Groff /// 'for'). 500d5bda5ec663f43710fe462f44b77ddbcf8fe9d9eJoe Groff void HandleIdentifier(Token &Identifier); 501d5bda5ec663f43710fe462f44b77ddbcf8fe9d9eJoe Groff 502d5bda5ec663f43710fe462f44b77ddbcf8fe9d9eJoe Groff 503cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// HandleEndOfFile - This callback is invoked when the lexer hits the end of 504cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// the current file. This either returns the EOF token and returns true, or 505cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// pops a level off the include stack and returns false, at which point the 506cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// client should call lex again. 507cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge bool HandleEndOfFile(Token &Result, bool isEndOfMacro = false); 508cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 509cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// HandleEndOfTokenLexer - This callback is invoked when the current 510cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// TokenLexer hits the end of its token stream. 511cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge bool HandleEndOfTokenLexer(Token &Result); 51232b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier 51332b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier /// HandleDirective - This callback is invoked when the lexer sees a # token 51432b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier /// at the start of a line. This consumes the directive, modifies the 51532b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier /// lexer/preprocessor state, and advances the lexer(s) so that the next token 51632b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier /// read is the correct one. 51732b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier void HandleDirective(Token &Result); 51832b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier 51932b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier /// CheckEndOfDirective - Ensure that the next token is a tok::eom token. If 520d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson /// not, emit a diagnostic and consume up until the eom. 521d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson void CheckEndOfDirective(const char *Directive); 522d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilsonprivate: 523d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson 524419454ad3720b8cf4613d9e790669c8beaccd1a4Richard Osborne void PushIncludeMacroStack() { 525419454ad3720b8cf4613d9e790669c8beaccd1a4Richard Osborne IncludeMacroStack.push_back(IncludeStackInfo(CurLexer.take(), 526cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge CurPTHLexer.take(), 527cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge CurPPLexer, 5286098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge CurTokenLexer.take(), 5296098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge CurDirLookup)); 5303d925d24e8c54cde05228258c25cc21687cad922Chad Rosier CurPPLexer = 0; 5313d925d24e8c54cde05228258c25cc21687cad922Chad Rosier } 5323d925d24e8c54cde05228258c25cc21687cad922Chad Rosier 5333d925d24e8c54cde05228258c25cc21687cad922Chad Rosier void PopIncludeMacroStack() { 534d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson CurLexer.reset(IncludeMacroStack.back().TheLexer); 535d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson CurPTHLexer.reset(IncludeMacroStack.back().ThePTHLexer); 536cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge CurPPLexer = IncludeMacroStack.back().ThePPLexer; 537cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge CurTokenLexer.reset(IncludeMacroStack.back().TheTokenLexer); 538cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge CurDirLookup = IncludeMacroStack.back().TheDirLookup; 539cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge IncludeMacroStack.pop_back(); 540cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge } 541cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 542cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// AllocateMacroInfo - Allocate a new MacroInfo object with the provide 543cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// SourceLocation. 544cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge MacroInfo* AllocateMacroInfo(SourceLocation L); 545cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 546939f5002027e3ccb710ac1c3050dc25471251565Meador Inge /// ReleaseMacroInfo - Release the specified MacroInfo. This memory will 547939f5002027e3ccb710ac1c3050dc25471251565Meador Inge /// be reused for allocating new MacroInfo objects. 548cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge void ReleaseMacroInfo(MacroInfo* MI) { 549cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge MICache.push_back(MI); 550cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge } 551cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 5520841e63ede092283d824843a068df3f7b0b90dd8Nuno Lopes /// isInPrimaryFile - Return true if we're in the top-level file, not in a 5530841e63ede092283d824843a068df3f7b0b90dd8Nuno Lopes /// #include. 5548d32463a9fa2aba9de552350a5019099edf0b90dNuno Lopes bool isInPrimaryFile() const; 5558d32463a9fa2aba9de552350a5019099edf0b90dNuno Lopes 556939f5002027e3ccb710ac1c3050dc25471251565Meador Inge /// DiscardUntilEndOfDirective - Read and discard all tokens remaining on the 557939f5002027e3ccb710ac1c3050dc25471251565Meador Inge /// current line until the tok::eom token is found. 558cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge void DiscardUntilEndOfDirective(); 559cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 5600841e63ede092283d824843a068df3f7b0b90dd8Nuno Lopes /// ReadMacroName - Lex and validate a macro name, which occurs after a 5610841e63ede092283d824843a068df3f7b0b90dd8Nuno Lopes /// #define or #undef. This emits a diagnostic, sets the token kind to eom, 562939f5002027e3ccb710ac1c3050dc25471251565Meador Inge /// and discards the rest of the macro line if the macro name is invalid. 563939f5002027e3ccb710ac1c3050dc25471251565Meador Inge void ReadMacroName(Token &MacroNameTok, char isDefineUndef = 0); 5648e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer 5658e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer /// ReadMacroDefinitionArgList - The ( starting an argument list of a macro 5660841e63ede092283d824843a068df3f7b0b90dd8Nuno Lopes /// definition has just been read. Lex the rest of the arguments and the 5670841e63ede092283d824843a068df3f7b0b90dd8Nuno Lopes /// closing ), updating MI with what we learn. Return true if an error occurs 568cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// parsing the arg list. 569cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge bool ReadMacroDefinitionArgList(MacroInfo *MI); 5700841e63ede092283d824843a068df3f7b0b90dd8Nuno Lopes 5710841e63ede092283d824843a068df3f7b0b90dd8Nuno Lopes /// SkipExcludedConditionalBlock - We just read a #if or related directive and 5728d32463a9fa2aba9de552350a5019099edf0b90dNuno Lopes /// decided that the subsequent tokens are in the #if'd out portion of the 5738d32463a9fa2aba9de552350a5019099edf0b90dNuno Lopes /// file. Lex the rest of the file, until we see an #endif. If 5740841e63ede092283d824843a068df3f7b0b90dd8Nuno Lopes /// FoundNonSkipPortion is true, then we have already emitted code for part of 5750841e63ede092283d824843a068df3f7b0b90dd8Nuno Lopes /// this #if directive, so #else/#elif blocks should never be entered. If 5768e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer /// FoundElse is false, then #else directives are ok, if not, then we have 5778e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer /// already seen one so a #else directive is a duplicate. When this returns, 5780841e63ede092283d824843a068df3f7b0b90dd8Nuno Lopes /// the caller can lex the first valid token. 5790841e63ede092283d824843a068df3f7b0b90dd8Nuno Lopes void SkipExcludedConditionalBlock(SourceLocation IfTokenLoc, 580939f5002027e3ccb710ac1c3050dc25471251565Meador Inge bool FoundNonSkipPortion, bool FoundElse); 581939f5002027e3ccb710ac1c3050dc25471251565Meador Inge 582939f5002027e3ccb710ac1c3050dc25471251565Meador Inge /// PTHSkipExcludedConditionalBlock - A fast PTH version of 583939f5002027e3ccb710ac1c3050dc25471251565Meador Inge /// SkipExcludedConditionalBlock. 584939f5002027e3ccb710ac1c3050dc25471251565Meador Inge void PTHSkipExcludedConditionalBlock(); 585939f5002027e3ccb710ac1c3050dc25471251565Meador Inge 586939f5002027e3ccb710ac1c3050dc25471251565Meador Inge /// EvaluateDirectiveExpression - Evaluate an integer constant expression that 587939f5002027e3ccb710ac1c3050dc25471251565Meador Inge /// may occur after a #if or #elif directive and return it as a bool. If the 588939f5002027e3ccb710ac1c3050dc25471251565Meador Inge /// expression is equivalent to "!defined(X)" return X in IfNDefMacro. 589939f5002027e3ccb710ac1c3050dc25471251565Meador Inge bool EvaluateDirectiveExpression(IdentifierInfo *&IfNDefMacro); 590939f5002027e3ccb710ac1c3050dc25471251565Meador Inge 591939f5002027e3ccb710ac1c3050dc25471251565Meador Inge /// RegisterBuiltinPragmas - Install the standard preprocessor pragmas: 592cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// #pragma GCC poison/system_header/dependency and #pragma once. 593cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge void RegisterBuiltinPragmas(); 594cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 595cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// RegisterBuiltinMacros - Register builtin macros, such as __LINE__ with the 596939f5002027e3ccb710ac1c3050dc25471251565Meador Inge /// identifier table. 597939f5002027e3ccb710ac1c3050dc25471251565Meador Inge void RegisterBuiltinMacros(); 598939f5002027e3ccb710ac1c3050dc25471251565Meador Inge IdentifierInfo *RegisterBuiltinMacro(const char *Name); 599939f5002027e3ccb710ac1c3050dc25471251565Meador Inge 600939f5002027e3ccb710ac1c3050dc25471251565Meador Inge /// HandleMacroExpandedIdentifier - If an identifier token is read that is to 601939f5002027e3ccb710ac1c3050dc25471251565Meador Inge /// be expanded as a macro, handle it and return the next token as 'Tok'. If 602939f5002027e3ccb710ac1c3050dc25471251565Meador Inge /// the macro should not be expanded return true, otherwise return false. 603939f5002027e3ccb710ac1c3050dc25471251565Meador Inge bool HandleMacroExpandedIdentifier(Token &Tok, MacroInfo *MI); 604939f5002027e3ccb710ac1c3050dc25471251565Meador Inge 605939f5002027e3ccb710ac1c3050dc25471251565Meador Inge /// isNextPPTokenLParen - Determine whether the next preprocessor token to be 606939f5002027e3ccb710ac1c3050dc25471251565Meador Inge /// lexed is a '('. If so, consume the token and return true, if not, this 607cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// method should have no observable side-effect on the lexed tokens. 608cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge bool isNextPPTokenLParen(); 609cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 610cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// ReadFunctionLikeMacroArgs - After reading "MACRO(", this method is 61132b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier /// invoked to read all of the formal arguments specified for the macro 61232b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier /// invocation. This returns null on error. 61332b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier MacroArgs *ReadFunctionLikeMacroArgs(Token &MacroName, MacroInfo *MI); 61432b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier 61532b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier /// ExpandBuiltinMacro - If an identifier token is read that is to be expanded 61632b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier /// as a builtin macro, handle it and return the next token as 'Tok'. 61732b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier void ExpandBuiltinMacro(Token &Tok); 61832b6c59ad068d2bb2466dd33bc17d8c865760215Chad Rosier 619d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson /// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then 620d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson /// return the first token after the directive. The _Pragma token has just 621d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson /// been read into 'Tok'. 622d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson void Handle_Pragma(Token &Tok); 623cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 624cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// EnterSourceFileWithLexer - Add a lexer to the top of the include stack and 625cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// start lexing tokens from it instead of the current buffer. 626cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge void EnterSourceFileWithLexer(Lexer *TheLexer, const DirectoryLookup *Dir); 627cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 628cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// EnterSourceFileWithPTH - Add a lexer to the top of the include stack and 6296098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge /// start getting tokens from it using the PTH cache. 6306098c6b56be5a8e3c7ac5273110589f251b03573Meador Inge void EnterSourceFileWithPTH(PTHLexer *PL, const DirectoryLookup *Dir); 631243eb9ecbbc6775e346e94025bd255bbceac9fcaOwen Anderson 632243eb9ecbbc6775e346e94025bd255bbceac9fcaOwen Anderson /// GetIncludeFilenameSpelling - Turn the specified lexer token into a fully 633243eb9ecbbc6775e346e94025bd255bbceac9fcaOwen Anderson /// checked and spelled filename, e.g. as an operand of #include. This returns 634243eb9ecbbc6775e346e94025bd255bbceac9fcaOwen Anderson /// true if the input filename was in <>'s or false if it were in ""'s. The 635243eb9ecbbc6775e346e94025bd255bbceac9fcaOwen Anderson /// caller is expected to provide a buffer that is large enough to hold the 636243eb9ecbbc6775e346e94025bd255bbceac9fcaOwen Anderson /// spelling of the filename, but is also expected to handle the case when 637cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// this method decides to use a different buffer. 638cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge bool GetIncludeFilenameSpelling(SourceLocation Loc, 639cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge const char *&BufStart, const char *&BufEnd); 640cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 641cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// LookupFile - Given a "foo" or <foo> reference, look up the indicated file, 642cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// return null on failure. isAngled indicates whether the file reference is 643cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// for system #include's or not (i.e. using <> instead of ""). 644cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge const FileEntry *LookupFile(const char *FilenameStart,const char *FilenameEnd, 645cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge bool isAngled, const DirectoryLookup *FromDir, 646cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge const DirectoryLookup *&CurDir); 647cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 648cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 6498e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer 6508e0d1c03ca7fd86e6879b4e37d0d7f0e982feef6Benjamin Kramer /// IsFileLexer - Returns true if we are lexing from a file and not a 651cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge /// pragma or a macro. 652cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge static bool IsFileLexer(const Lexer* L, const PreprocessorLexer* P) { 653cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge return L ? !L->isPragmaLexer() : P != 0; 654cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge } 655cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 656cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge static bool IsFileLexer(const IncludeStackInfo& I) { 657cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge return IsFileLexer(I.TheLexer, I.ThePPLexer); 658cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge } 659cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 660cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge bool IsFileLexer() const { 661cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge return IsFileLexer(CurLexer.get(), CurPPLexer); 662cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge } 663cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge 664cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge //===--------------------------------------------------------------------===// 665cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge // Caching stuff. 666cf70590c38ef580758c8a255519959fc7160fdb2Meador Inge void CachingLex(Token &Result); 6679d434dbff3eb0501efc3457acec2401afdffef2fEli Friedman bool InCachingLexMode() const { return CurPPLexer == 0 && CurTokenLexer == 0;} 668ce99120084f549a523213064648662a704e8b789Chris Lattner void EnterCachingLexMode(); 669ce99120084f549a523213064648662a704e8b789Chris Lattner void ExitCachingLexMode() { 670ce99120084f549a523213064648662a704e8b789Chris Lattner if (InCachingLexMode()) 671ce99120084f549a523213064648662a704e8b789Chris Lattner RemoveTopOfLexerStack(); 672ce99120084f549a523213064648662a704e8b789Chris Lattner } 673ce99120084f549a523213064648662a704e8b789Chris Lattner const Token &PeekAhead(unsigned N); 674ce99120084f549a523213064648662a704e8b789Chris Lattner void AnnotatePreviousCachedTokens(const Token &Tok); 675ce99120084f549a523213064648662a704e8b789Chris Lattner 6762d24e2a396a1d211baaeedf32148a3b657240170David Blaikie //===--------------------------------------------------------------------===// 6779d434dbff3eb0501efc3457acec2401afdffef2fEli Friedman /// Handle*Directive - implement the various preprocessor directives. These 6789d434dbff3eb0501efc3457acec2401afdffef2fEli Friedman /// should side-effect the current preprocessor object so that the next call 6799d434dbff3eb0501efc3457acec2401afdffef2fEli Friedman /// to Lex() will return the appropriate token next. 6809d434dbff3eb0501efc3457acec2401afdffef2fEli Friedman 6819d434dbff3eb0501efc3457acec2401afdffef2fEli Friedman void HandleUserDiagnosticDirective(Token &Tok, bool isWarning); 6829d434dbff3eb0501efc3457acec2401afdffef2fEli Friedman void HandleIdentSCCSDirective(Token &Tok); 6839d434dbff3eb0501efc3457acec2401afdffef2fEli Friedman 6849d434dbff3eb0501efc3457acec2401afdffef2fEli Friedman // File inclusion. 6859d434dbff3eb0501efc3457acec2401afdffef2fEli Friedman void HandleIncludeDirective(Token &Tok, 6869d434dbff3eb0501efc3457acec2401afdffef2fEli Friedman const DirectoryLookup *LookupFrom = 0, 6879d434dbff3eb0501efc3457acec2401afdffef2fEli Friedman bool isImport = false); 6889d434dbff3eb0501efc3457acec2401afdffef2fEli Friedman void HandleIncludeNextDirective(Token &Tok); 6899d434dbff3eb0501efc3457acec2401afdffef2fEli Friedman void HandleImportDirective(Token &Tok); 6909d434dbff3eb0501efc3457acec2401afdffef2fEli Friedman 6919d434dbff3eb0501efc3457acec2401afdffef2fEli Friedman // Macro handling. 6929d434dbff3eb0501efc3457acec2401afdffef2fEli Friedman void HandleDefineDirective(Token &Tok); 6939d434dbff3eb0501efc3457acec2401afdffef2fEli Friedman void HandleUndefDirective(Token &Tok); 694ce99120084f549a523213064648662a704e8b789Chris Lattner // HandleAssertDirective(Token &Tok); 695ce99120084f549a523213064648662a704e8b789Chris Lattner // HandleUnassertDirective(Token &Tok); 696ce99120084f549a523213064648662a704e8b789Chris Lattner 697ce99120084f549a523213064648662a704e8b789Chris Lattner // Conditional Inclusion. 69840f5fbcc5c95bb96c43ce2d06d57ae9b7f852539Chris Lattner void HandleIfdefDirective(Token &Tok, bool isIfndef, 699ce99120084f549a523213064648662a704e8b789Chris Lattner bool ReadAnyTokensBeforeDirective); 700d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson void HandleIfDirective(Token &Tok, bool ReadAnyTokensBeforeDirective); 701d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson void HandleEndifDirective(Token &Tok); 702d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson void HandleElseDirective(Token &Tok); 703d1e672e0234b99dbff78baed0e47d033cf963abeBob Wilson void HandleElifDirective(Token &Tok); 704ce99120084f549a523213064648662a704e8b789Chris Lattner 705ce99120084f549a523213064648662a704e8b789Chris Lattner // Pragmas. 706ce99120084f549a523213064648662a704e8b789Chris Lattner void HandlePragmaDirective(); 7079d434dbff3eb0501efc3457acec2401afdffef2fEli Friedmanpublic: 7089d434dbff3eb0501efc3457acec2401afdffef2fEli Friedman void HandlePragmaOnce(Token &OnceTok); 7099d434dbff3eb0501efc3457acec2401afdffef2fEli Friedman void HandlePragmaMark(); 710982dc84762fc0c2ca35e6947d648a690dd22343cBob Wilson void HandlePragmaPoison(Token &PoisonTok); 711982dc84762fc0c2ca35e6947d648a690dd22343cBob Wilson void HandlePragmaSystemHeader(Token &SysHeaderTok); 712982dc84762fc0c2ca35e6947d648a690dd22343cBob Wilson void HandlePragmaDependency(Token &DependencyTok); 713982dc84762fc0c2ca35e6947d648a690dd22343cBob Wilson}; 714982dc84762fc0c2ca35e6947d648a690dd22343cBob Wilson 715982dc84762fc0c2ca35e6947d648a690dd22343cBob Wilson/// PreprocessorFactory - A generic factory interface for lazily creating 716982dc84762fc0c2ca35e6947d648a690dd22343cBob Wilson/// Preprocessor objects on-demand when they are needed. 717982dc84762fc0c2ca35e6947d648a690dd22343cBob Wilsonclass PreprocessorFactory { 718982dc84762fc0c2ca35e6947d648a690dd22343cBob Wilsonpublic: 719982dc84762fc0c2ca35e6947d648a690dd22343cBob Wilson virtual ~PreprocessorFactory(); 720982dc84762fc0c2ca35e6947d648a690dd22343cBob Wilson virtual Preprocessor* CreatePreprocessor() = 0; 721982dc84762fc0c2ca35e6947d648a690dd22343cBob Wilson}; 722b704d23062aa78b00999b75dcdcb628d4d84ee3fPreston Gurd 723b704d23062aa78b00999b75dcdcb628d4d84ee3fPreston Gurd} // end namespace clang 72436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 72536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#endif 726982dc84762fc0c2ca35e6947d648a690dd22343cBob Wilson