Preprocessor.h revision 7abe1666f225b6d1a11aa7ed19d9a0dcc49391cb
15821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)//===--- Preprocessor.h - C Language Family Preprocessor --------*- C++ -*-===// 25821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 35821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// The LLVM Compiler Infrastructure 45821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 55821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// This file is distributed under the University of Illinois Open Source 65821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// License. See LICENSE.TXT for details. 75821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 85821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)//===----------------------------------------------------------------------===// 95821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// This file defines the Preprocessor interface. 115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)// 12868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles)//===----------------------------------------------------------------------===// 13868fa2fe829687343ffae624259930155e16dbd8Torne (Richard Coles) 145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#ifndef LLVM_CLANG_LEX_PREPROCESSOR_H 152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#define LLVM_CLANG_LEX_PREPROCESSOR_H 162a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 172a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "clang/Lex/MacroInfo.h" 182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "clang/Lex/Lexer.h" 195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/Lex/PTHLexer.h" 202a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles)#include "clang/Lex/PPCallbacks.h" 215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/Lex/TokenLexer.h" 225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/Lex/PTHManager.h" 235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/Basic/Builtins.h" 245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/Basic/Diagnostic.h" 255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/Basic/IdentifierTable.h" 265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "clang/Basic/SourceLocation.h" 275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/ADT/DenseMap.h" 285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/ADT/IntrusiveRefCntPtr.h" 295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/ADT/SmallPtrSet.h" 305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/ADT/OwningPtr.h" 315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/ADT/SmallVector.h" 325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/ADT/ArrayRef.h" 335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include "llvm/Support/Allocator.h" 345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)#include <vector> 355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)namespace llvm { 375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) template<unsigned InternalLen> class SmallString; 385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)} 395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)namespace clang { 415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class SourceManager; 435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class ExternalPreprocessorSource; 445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class FileManager; 455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class FileEntry; 465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class HeaderSearch; 475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class PragmaNamespace; 485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class PragmaHandler; 495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class CommentHandler; 505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class ScratchBuffer; 515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class TargetInfo; 525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class PPCallbacks; 535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class CodeCompletionHandler; 545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class DirectoryLookup; 555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class PreprocessingRecord; 565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class ModuleLoader; 575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)/// Preprocessor - This object engages in a tight little dance with the lexer to 595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)/// efficiently preprocess tokens. Lexers know only about tokens within a 605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)/// single source file, and don't know anything about preprocessor-level issues 615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)/// like the #include stack, token expansion, etc. 625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)/// 635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)class Preprocessor : public RefCountedBase<Preprocessor> { 645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DiagnosticsEngine *Diags; 655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) LangOptions &Features; 665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const TargetInfo *Target; 675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) FileManager &FileMgr; 685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SourceManager &SourceMgr; 695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ScratchBuffer *ScratchBuf; 705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) HeaderSearch &HeaderInfo; 715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ModuleLoader &TheModuleLoader; 725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief External source of macros. 745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ExternalPreprocessorSource *ExternalSource; 755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// PTH - An optional PTHManager object used for getting tokens from 785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// a token cache rather than lexing the original source file. 795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) OwningPtr<PTHManager> PTH; 805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// BP - A BumpPtrAllocator object used to quickly allocate and release 825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// objects internal to the Preprocessor. 835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::BumpPtrAllocator BP; 845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Identifiers for builtin macros and other builtins. 865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IdentifierInfo *Ident__LINE__, *Ident__FILE__; // __LINE__, __FILE__ 875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IdentifierInfo *Ident__DATE__, *Ident__TIME__; // __DATE__, __TIME__ 885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IdentifierInfo *Ident__INCLUDE_LEVEL__; // __INCLUDE_LEVEL__ 895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IdentifierInfo *Ident__BASE_FILE__; // __BASE_FILE__ 90c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) IdentifierInfo *Ident__TIMESTAMP__; // __TIMESTAMP__ 915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IdentifierInfo *Ident__COUNTER__; // __COUNTER__ 925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IdentifierInfo *Ident_Pragma, *Ident__pragma; // _Pragma, __pragma 935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IdentifierInfo *Ident__VA_ARGS__; // __VA_ARGS__ 945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IdentifierInfo *Ident__has_feature; // __has_feature 955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IdentifierInfo *Ident__has_extension; // __has_extension 965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IdentifierInfo *Ident__has_builtin; // __has_builtin 975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IdentifierInfo *Ident__has_attribute; // __has_attribute 985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IdentifierInfo *Ident__has_include; // __has_include 995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IdentifierInfo *Ident__has_include_next; // __has_include_next 1005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IdentifierInfo *Ident__has_warning; // __has_warning 1015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SourceLocation DATELoc, TIMELoc; 1035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) unsigned CounterValue; // Next __COUNTER__ value. 1045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) enum { 1065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// MaxIncludeStackDepth - Maximum depth of #includes. 1075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) MaxAllowedIncludeStackDepth = 200 1085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) }; 1095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // State that is set before the preprocessor begins. 1115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool KeepComments : 1; 1125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool KeepMacroComments : 1; 1135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool SuppressIncludeNotFoundError : 1; 1145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // State that changes while the preprocessor runs: 1165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool InMacroArgs : 1; // True if parsing fn macro invocation args. 1175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Whether the preprocessor owns the header search object. 1195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool OwnsHeaderSearch : 1; 1205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// DisableMacroExpansion - True if macro expansion is disabled. 1225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool DisableMacroExpansion : 1; 1235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Whether we have already loaded macros from the external source. 1255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) mutable bool ReadMacrosFromExternalSource : 1; 1265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Identifiers - This is mapping/lookup information for all identifiers in 1285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// the program, including program keywords. 1295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) mutable IdentifierTable Identifiers; 1305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Selectors - This table contains all the selectors in the program. Unlike 1325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// IdentifierTable above, this table *isn't* populated by the preprocessor. 1335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// It is declared/expanded here because it's role/lifetime is 1345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// conceptually similar the IdentifierTable. In addition, the current control 1355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// flow (in clang::ParseAST()), make it convenient to put here. 1365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// FIXME: Make sure the lifetime of Identifiers/Selectors *isn't* tied to 1375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// the lifetime of the preprocessor. 1385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SelectorTable Selectors; 1395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// BuiltinInfo - Information about builtins. 1415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Builtin::Context BuiltinInfo; 1425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// PragmaHandlers - This tracks all of the pragmas that the client registered 1445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// with this preprocessor. 1455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PragmaNamespace *PragmaHandlers; 1465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Tracks all of the comment handlers that the client registered 1485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// with this preprocessor. 1495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::vector<CommentHandler *> CommentHandlers; 1505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief The code-completion handler. 1525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CodeCompletionHandler *CodeComplete; 1535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief The file that we're performing code-completion for, if any. 1555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const FileEntry *CodeCompletionFile; 1565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief The offset in file for the code-completion point. 1585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) unsigned CodeCompletionOffset; 1595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief The location for the code-completion point. This gets instantiated 1615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// when the CodeCompletionFile gets #include'ed for preprocessing. 1625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SourceLocation CodeCompletionLoc; 1635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief The start location for the file of the code-completion point. 1655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// This gets instantiated when the CodeCompletionFile gets #include'ed 1665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// for preprocessing. 1675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SourceLocation CodeCompletionFileLoc; 1685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief The source location of the 'import' contextual keyword we just 1705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// lexed, if any. 1715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SourceLocation ModuleImportLoc; 1725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief The module import path that we're currently processing. 1745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::SmallVector<std::pair<IdentifierInfo *, SourceLocation>, 2> 1755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ModuleImportPath; 1765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Whether the module import expectes an identifier next. Otherwise, 1785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// it expects a '.' or ';'. 1795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool ModuleImportExpectsIdentifier; 1805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief The source location of the currently-active 1825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// #pragma clang arc_cf_code_audited begin. 1835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SourceLocation PragmaARCCFCodeAuditedLoc; 1845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief True if we hit the code-completion point. 1865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool CodeCompletionReached; 1875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief The number of bytes that we will initially skip when entering the 1895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// main file, which is used when loading a precompiled preamble, along 1905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// with a flag that indicates whether skipping this number of bytes will 1915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// place the lexer at the start of a line. 1925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::pair<unsigned, bool> SkipMainFilePreamble; 1935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// CurLexer - This is the current top of the stack that we're lexing from if 1955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// not expanding a macro and we are lexing directly from source code. 1965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Only one of CurLexer, CurPTHLexer, or CurTokenLexer will be non-null. 1975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) OwningPtr<Lexer> CurLexer; 1985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 1995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// CurPTHLexer - This is the current top of stack that we're lexing from if 2005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// not expanding from a macro and we are lexing from a PTH cache. 2015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Only one of CurLexer, CurPTHLexer, or CurTokenLexer will be non-null. 2025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) OwningPtr<PTHLexer> CurPTHLexer; 2035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// CurPPLexer - This is the current top of the stack what we're lexing from 2055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// if not expanding a macro. This is an alias for either CurLexer or 2065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// CurPTHLexer. 2075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PreprocessorLexer *CurPPLexer; 2085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// CurLookup - The DirectoryLookup structure used to find the current 2105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// FileEntry, if CurLexer is non-null and if applicable. This allows us to 2115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// implement #include_next and find directory-specific properties. 2125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const DirectoryLookup *CurDirLookup; 2135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// CurTokenLexer - This is the current macro we are expanding, if we are 2155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// expanding a macro. One of CurLexer and CurTokenLexer must be null. 2165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) OwningPtr<TokenLexer> CurTokenLexer; 2175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief The kind of lexer we're currently working with. 2195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) enum CurLexerKind { 2205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CLK_Lexer, 2215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CLK_PTHLexer, 2225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CLK_TokenLexer, 2235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CLK_CachingLexer, 2245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CLK_LexAfterModuleImport 2255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } CurLexerKind; 2265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// IncludeMacroStack - This keeps track of the stack of files currently 2285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// #included, and macros currently being expanded from, not counting 2295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// CurLexer/CurTokenLexer. 2305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) struct IncludeStackInfo { 2315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) enum CurLexerKind CurLexerKind; 2325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Lexer *TheLexer; 2335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PTHLexer *ThePTHLexer; 2345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PreprocessorLexer *ThePPLexer; 2355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) TokenLexer *TheTokenLexer; 2365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const DirectoryLookup *TheDirLookup; 2375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IncludeStackInfo(enum CurLexerKind K, Lexer *L, PTHLexer* P, 2395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PreprocessorLexer* PPL, 2405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) TokenLexer* TL, const DirectoryLookup *D) 2415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) : CurLexerKind(K), TheLexer(L), ThePTHLexer(P), ThePPLexer(PPL), 2425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) TheTokenLexer(TL), TheDirLookup(D) {} 2435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) }; 2445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::vector<IncludeStackInfo> IncludeMacroStack; 2455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Callbacks - These are actions invoked when some preprocessor activity is 2475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// encountered (e.g. a file is #included, etc). 2485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PPCallbacks *Callbacks; 2495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Macros - For each IdentifierInfo with 'HasMacro' set, we keep a mapping 2515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// to the actual definition of the macro. 2525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::DenseMap<IdentifierInfo*, MacroInfo*> Macros; 2535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 254c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) /// \brief Macros that we want to warn because they are not used at the end 2555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// of the translation unit; we store just their SourceLocations instead 2565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// something like MacroInfo*. The benefit of this is that when we are 2575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// deserializing from PCH, we don't need to deserialize identifier & macros 2585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// just so that we can report that they are unused, we just warn using 2595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// the SourceLocations of this set (that will be filled by the ASTReader). 2605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// We are using SmallPtrSet instead of a vector for faster removal. 2615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) typedef llvm::SmallPtrSet<SourceLocation, 32> WarnUnusedMacroLocsTy; 2625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) WarnUnusedMacroLocsTy WarnUnusedMacroLocs; 2635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// MacroArgCache - This is a "freelist" of MacroArg objects that can be 2655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// reused for quick allocation. 2665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) MacroArgs *MacroArgCache; 2675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) friend class MacroArgs; 2685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// PragmaPushMacroInfo - For each IdentifierInfo used in a #pragma 2705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// push_macro directive, we keep a MacroInfo stack used to restore 271c2e0dbddbe15c98d52c4786dac06cb8952a8ae6dTorne (Richard Coles) /// previous macro value. 2725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::DenseMap<IdentifierInfo*, std::vector<MacroInfo*> > PragmaPushMacroInfo; 2735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Various statistics we track for performance analysis. 2755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) unsigned NumDirectives, NumIncluded, NumDefined, NumUndefined, NumPragma; 2765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) unsigned NumIf, NumElse, NumEndif; 2775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) unsigned NumEnteredSourceFiles, MaxIncludeStackDepth; 2785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) unsigned NumMacroExpanded, NumFnMacroExpanded, NumBuiltinMacroExpanded; 2795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) unsigned NumFastMacroExpanded, NumTokenPaste, NumFastTokenPaste; 2805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) unsigned NumSkipped; 2815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Predefines - This string is the predefined macros that preprocessor 2835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// should use from the command line etc. 2845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string Predefines; 2855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// TokenLexerCache - Cache macro expanders to reduce malloc traffic. 2875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) enum { TokenLexerCacheSize = 8 }; 2885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) unsigned NumCachedTokenLexers; 2895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) TokenLexer *TokenLexerCache[TokenLexerCacheSize]; 2905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Keeps macro expanded tokens for TokenLexers. 2925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // 2935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Works like a stack; a TokenLexer adds the macro expanded tokens that is 2945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// going to lex in the cache and when it finishes the tokens are removed 2955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// from the end of the cache. 2965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SmallVector<Token, 16> MacroExpandedTokens; 2975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::vector<std::pair<TokenLexer *, size_t> > MacroExpandingLexersStack; 2985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 2995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief A record of the macro definitions and expansions that 3005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// occurred during preprocessing. 3015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 3025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// This is an optional side structure that can be enabled with 3035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \c createPreprocessingRecord() prior to preprocessing. 3045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PreprocessingRecord *Record; 3055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)private: // Cached tokens state. 3075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) typedef SmallVector<Token, 1> CachedTokensTy; 3085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// CachedTokens - Cached tokens are stored here when we do backtracking or 3105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// lookahead. They are "lexed" by the CachingLex() method. 3115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CachedTokensTy CachedTokens; 3125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// CachedLexPos - The position of the cached token that CachingLex() should 3145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// "lex" next. If it points beyond the CachedTokens vector, it means that 3155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// a normal Lex() should be invoked. 3165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CachedTokensTy::size_type CachedLexPos; 3175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// BacktrackPositions - Stack of backtrack positions, allowing nested 3195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// backtracks. The EnableBacktrackAtThisPos() method pushes a position to 3205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// indicate where CachedLexPos should be set when the BackTrack() method is 3215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// invoked (at which point the last position is popped). 3225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::vector<CachedTokensTy::size_type> BacktrackPositions; 3235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) struct MacroInfoChain { 3255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) MacroInfo MI; 3265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) MacroInfoChain *Next; 3275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) MacroInfoChain *Prev; 3285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) }; 3295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// MacroInfos are managed as a chain for easy disposal. This is the head 3315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// of that list. 3325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) MacroInfoChain *MIChainHead; 3335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// MICache - A "freelist" of MacroInfo objects that can be reused for quick 3355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// allocation. 3365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) MacroInfoChain *MICache; 3375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) MacroInfo *getInfoForMacro(IdentifierInfo *II) const; 3395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)public: 3415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Preprocessor(DiagnosticsEngine &diags, LangOptions &opts, 3425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const TargetInfo *target, 3435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SourceManager &SM, HeaderSearch &Headers, 3445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ModuleLoader &TheModuleLoader, 3455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IdentifierInfoLookup *IILookup = 0, 3465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool OwnsHeaderSearch = false, 3475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool DelayInitialization = false); 3485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ~Preprocessor(); 3505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Initialize the preprocessor, if the constructor did not already 3525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// perform the initialization. 3535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 3545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \param Target Information about the target. 3555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void Initialize(const TargetInfo &Target); 3565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DiagnosticsEngine &getDiagnostics() const { return *Diags; } 3585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void setDiagnostics(DiagnosticsEngine &D) { Diags = &D; } 3595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const LangOptions &getLangOptions() const { return Features; } 3615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const TargetInfo &getTargetInfo() const { return *Target; } 3625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) FileManager &getFileManager() const { return FileMgr; } 3635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SourceManager &getSourceManager() const { return SourceMgr; } 3645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) HeaderSearch &getHeaderSearchInfo() const { return HeaderInfo; } 3655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IdentifierTable &getIdentifierTable() { return Identifiers; } 3675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SelectorTable &getSelectorTable() { return Selectors; } 3685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Builtin::Context &getBuiltinInfo() { return BuiltinInfo; } 3695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::BumpPtrAllocator &getPreprocessorAllocator() { return BP; } 3705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void setPTHManager(PTHManager* pm); 3725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PTHManager *getPTHManager() { return PTH.get(); } 3745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void setExternalSource(ExternalPreprocessorSource *Source) { 3765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ExternalSource = Source; 3775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 3785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ExternalPreprocessorSource *getExternalSource() const { 3805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return ExternalSource; 3815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 3825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Retrieve the module loader associated with this preprocessor. 3845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ModuleLoader &getModuleLoader() const { return TheModuleLoader; } 3855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// SetCommentRetentionState - Control whether or not the preprocessor retains 3875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// comments in output. 3885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void SetCommentRetentionState(bool KeepComments, bool KeepMacroComments) { 3895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) this->KeepComments = KeepComments | KeepMacroComments; 3905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) this->KeepMacroComments = KeepMacroComments; 3915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 3925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool getCommentRetentionState() const { return KeepComments; } 3945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void SetSuppressIncludeNotFoundError(bool Suppress) { 3965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SuppressIncludeNotFoundError = Suppress; 3975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 3985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 3995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool GetSuppressIncludeNotFoundError() { 4005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return SuppressIncludeNotFoundError; 4015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 4025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4032a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) /// isCurrentLexer - Return true if we are lexing directly from the specified 4045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// lexer. 4055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool isCurrentLexer(const PreprocessorLexer *L) const { 4065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return CurPPLexer == L; 4072a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) } 4085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4092a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) /// getCurrentLexer - Return the current lexer being lexed from. Note 4105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// that this ignores any potentially active macro expansions and _Pragma 4115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// expansions going on at the time. 4122a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) PreprocessorLexer *getCurrentLexer() const { return CurPPLexer; } 4132a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// getCurrentFileLexer - Return the current file lexer being lexed from. 4152a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) /// Note that this ignores any potentially active macro expansions and _Pragma 4165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// expansions going on at the time. 4175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PreprocessorLexer *getCurrentFileLexer() const; 4182a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4192a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) /// getPPCallbacks/addPPCallbacks - Accessors for preprocessor callbacks. 4205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Note that this class takes ownership of any PPCallbacks object given to 4212a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) /// it. 4225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PPCallbacks *getPPCallbacks() const { return Callbacks; } 4232a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) void addPPCallbacks(PPCallbacks *C) { 4245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (Callbacks) 4255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) C = new PPChainedCallbacks(C, Callbacks); 4265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Callbacks = C; 4275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 4285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// getMacroInfo - Given an identifier, return the MacroInfo it is #defined to 4305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// or null if it isn't #define'd. 4312a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) MacroInfo *getMacroInfo(IdentifierInfo *II) const { 4322a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) if (!II->hasMacroDefinition()) 4335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return 0; 4345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4352a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) return getInfoForMacro(II); 4365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 4372a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) 4385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// setMacroInfo - Specify a macro for this identifier. 4395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 4402a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) void setMacroInfo(IdentifierInfo *II, MacroInfo *MI, 4415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool LoadedFromAST = false); 4425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// macro_iterator/macro_begin/macro_end - This allows you to walk the current 4442a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) /// state of the macro table. This visits every currently-defined macro. 4455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) typedef llvm::DenseMap<IdentifierInfo*, 4465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) MacroInfo*>::const_iterator macro_iterator; 4475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) macro_iterator macro_begin(bool IncludeExternalMacros = true) const; 4482a99a7e74a7f215066514fe81d2bfa6639d9edddTorne (Richard Coles) macro_iterator macro_end(bool IncludeExternalMacros = true) const; 4495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const std::string &getPredefines() const { return Predefines; } 4515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// setPredefines - Set the predefines for this Preprocessor. These 4525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// predefines are automatically injected when parsing the main file. 4535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void setPredefines(const char *P) { Predefines = P; } 4545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void setPredefines(const std::string &P) { Predefines = P; } 4557d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) 4567d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) /// getIdentifierInfo - Return information about the specified preprocessor 4577d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) /// identifier token. The version of this method that takes two character 4585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// pointers is preferred unless the identifier is already available as a 4595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// string (this avoids allocation and copying of memory to construct an 4605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// std::string). 4615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IdentifierInfo *getIdentifierInfo(StringRef Name) const { 4625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return &Identifiers.get(Name); 4635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 4645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// AddPragmaHandler - Add the specified pragma handler to the preprocessor. 4665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// If 'Namespace' is non-null, then it is a token required to exist on the 4675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// pragma line before the pragma string starts, e.g. "STDC" or "GCC". 4685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void AddPragmaHandler(StringRef Namespace, PragmaHandler *Handler); 4695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void AddPragmaHandler(PragmaHandler *Handler) { 4705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) AddPragmaHandler(StringRef(), Handler); 4715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 4725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// RemovePragmaHandler - Remove the specific pragma handler from 4745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// the preprocessor. If \arg Namespace is non-null, then it should 4755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// be the namespace that \arg Handler was added to. It is an error 4765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// to remove a handler that has not been registered. 4775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void RemovePragmaHandler(StringRef Namespace, PragmaHandler *Handler); 4785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void RemovePragmaHandler(PragmaHandler *Handler) { 4795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) RemovePragmaHandler(StringRef(), Handler); 4805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 4815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Add the specified comment handler to the preprocessor. 4835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void AddCommentHandler(CommentHandler *Handler); 4845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Remove the specified comment handler. 4865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 4875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// It is an error to remove a handler that has not been registered. 4885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void RemoveCommentHandler(CommentHandler *Handler); 4895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Set the code completion handler to the given object. 4915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void setCodeCompletionHandler(CodeCompletionHandler &Handler) { 4925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CodeComplete = &Handler; 4935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 4945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 4955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Retrieve the current code-completion handler. 4965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CodeCompletionHandler *getCodeCompletionHandler() const { 4975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return CodeComplete; 4985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 4995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Clear out the code completion handler. 5015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void clearCodeCompletionHandler() { 5025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CodeComplete = 0; 5035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 5045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Hook used by the lexer to invoke the "natural language" code 5065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// completion point. 5075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void CodeCompleteNaturalLanguage(); 5085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Retrieve the preprocessing record, or NULL if there is no 5105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// preprocessing record. 5115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PreprocessingRecord *getPreprocessingRecord() const { return Record; } 5125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Create a new preprocessing record, which will keep track of 5145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// all macro expansions, macro definitions, etc. 5155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void createPreprocessingRecord(); 5165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// EnterMainSourceFile - Enter the specified FileID as the main source file, 5185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// which implicitly adds the builtin defines etc. 5195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void EnterMainSourceFile(); 5205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// EndSourceFile - Inform the preprocessor callbacks that processing is 5225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// complete. 5235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void EndSourceFile(); 5245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// EnterSourceFile - Add a source file to the top of the include stack and 5265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// start lexing tokens from it instead of the current buffer. Emit an error 5275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// and don't enter the file on error. 5285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void EnterSourceFile(FileID CurFileID, const DirectoryLookup *Dir, 5295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SourceLocation Loc); 5305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// EnterMacro - Add a Macro to the top of the include stack and start lexing 5325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// tokens from it instead of the current buffer. Args specifies the 5335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// tokens input to a function-like macro. 5345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 5355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// ILEnd specifies the location of the ')' for a function-like macro or the 5365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// identifier for an object-like macro. 5375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void EnterMacro(Token &Identifier, SourceLocation ILEnd, MacroArgs *Args); 5385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// EnterTokenStream - Add a "macro" context to the top of the include stack, 5405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// which will cause the lexer to start returning the specified tokens. 5415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 5425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// If DisableMacroExpansion is true, tokens lexed from the token stream will 5435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// not be subject to further macro expansion. Otherwise, these tokens will 5445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// be re-macro-expanded when/if expansion is enabled. 5455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 5465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// If OwnsTokens is false, this method assumes that the specified stream of 5475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// tokens has a permanent owner somewhere, so they do not need to be copied. 5485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// If it is true, it assumes the array of tokens is allocated with new[] and 5495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// must be freed. 5505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 5515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void EnterTokenStream(const Token *Toks, unsigned NumToks, 5525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool DisableMacroExpansion, bool OwnsTokens); 5535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// RemoveTopOfLexerStack - Pop the current lexer/macro exp off the top of the 5555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// lexer stack. This should only be used in situations where the current 5565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// state of the top-of-stack lexer is known. 5575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void RemoveTopOfLexerStack(); 5585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// EnableBacktrackAtThisPos - From the point that this method is called, and 5605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// until CommitBacktrackedTokens() or Backtrack() is called, the Preprocessor 5615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// keeps track of the lexed tokens so that a subsequent Backtrack() call will 5625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// make the Preprocessor re-lex the same tokens. 5635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 5645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Nested backtracks are allowed, meaning that EnableBacktrackAtThisPos can 5655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// be called multiple times and CommitBacktrackedTokens/Backtrack calls will 5665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// be combined with the EnableBacktrackAtThisPos calls in reverse order. 5675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 5685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// NOTE: *DO NOT* forget to call either CommitBacktrackedTokens or Backtrack 5695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// at some point after EnableBacktrackAtThisPos. If you don't, caching of 5705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// tokens will continue indefinitely. 5715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 5725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void EnableBacktrackAtThisPos(); 5735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// CommitBacktrackedTokens - Disable the last EnableBacktrackAtThisPos call. 5755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void CommitBacktrackedTokens(); 5765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Backtrack - Make Preprocessor re-lex the tokens that were lexed since 5785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// EnableBacktrackAtThisPos() was previously called. 5795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void Backtrack(); 5805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// isBacktrackEnabled - True if EnableBacktrackAtThisPos() was called and 5825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// caching of tokens is on. 5835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool isBacktrackEnabled() const { return !BacktrackPositions.empty(); } 5845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Lex - To lex a token from the preprocessor, just pull a token from the 5865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// current lexer or macro object. 5875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void Lex(Token &Result) { 5885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) switch (CurLexerKind) { 5895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) case CLK_Lexer: CurLexer->Lex(Result); break; 5905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) case CLK_PTHLexer: CurPTHLexer->Lex(Result); break; 5915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) case CLK_TokenLexer: CurTokenLexer->Lex(Result); break; 5925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) case CLK_CachingLexer: CachingLex(Result); break; 5935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) case CLK_LexAfterModuleImport: LexAfterModuleImport(Result); break; 5945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 5955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 5965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void LexAfterModuleImport(Token &Result); 5985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 5995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// LexNonComment - Lex a token. If it's a comment, keep lexing until we get 6005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// something not a comment. This is useful in -E -C mode where comments 6015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// would foul up preprocessor directive handling. 6025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void LexNonComment(Token &Result) { 6035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) do 6045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Lex(Result); 6055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) while (Result.getKind() == tok::comment); 6065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 6075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 6085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// LexUnexpandedToken - This is just like Lex, but this disables macro 6095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// expansion of identifier tokens. 6105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void LexUnexpandedToken(Token &Result) { 6115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Disable macro expansion. 6125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool OldVal = DisableMacroExpansion; 6135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DisableMacroExpansion = true; 6145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Lex the token. 6155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Lex(Result); 6165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 6175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Reenable it. 6185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DisableMacroExpansion = OldVal; 6195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 6205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 6215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// LexUnexpandedNonComment - Like LexNonComment, but this disables macro 6225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// expansion of identifier tokens. 6235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void LexUnexpandedNonComment(Token &Result) { 6245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) do 6255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) LexUnexpandedToken(Result); 6265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) while (Result.getKind() == tok::comment); 6275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 6285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 6295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// LookAhead - This peeks ahead N tokens and returns that token without 6305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// consuming any tokens. LookAhead(0) returns the next token that would be 6315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// returned by Lex(), LookAhead(1) returns the token after it, etc. This 6325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// returns normal tokens after phase 5. As such, it is equivalent to using 6335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 'Lex', not 'LexUnexpandedToken'. 6345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) const Token &LookAhead(unsigned N) { 6355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (CachedLexPos + N < CachedTokens.size()) 6365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return CachedTokens[CachedLexPos+N]; 6375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) else 6385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return PeekAhead(N+1); 6395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 6405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 6415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// RevertCachedTokens - When backtracking is enabled and tokens are cached, 6425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// this allows to revert a specific number of tokens. 6435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Note that the number of tokens being reverted should be up to the last 6445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// backtrack position, not more. 6455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void RevertCachedTokens(unsigned N) { 6465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(isBacktrackEnabled() && 6475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) "Should only be called when tokens are cached for backtracking"); 6485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(signed(CachedLexPos) - signed(N) >= signed(BacktrackPositions.back()) 6495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) && "Should revert tokens up to the last backtrack position, not more"); 6505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(signed(CachedLexPos) - signed(N) >= 0 && 6515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) "Corrupted backtrack positions ?"); 6525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CachedLexPos -= N; 6535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 6545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 6555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// EnterToken - Enters a token in the token stream to be lexed next. If 6565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// BackTrack() is called afterwards, the token will remain at the insertion 6575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// point. 6585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void EnterToken(const Token &Tok) { 6595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) EnterCachingLexMode(); 6605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CachedTokens.insert(CachedTokens.begin()+CachedLexPos, Tok); 6615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 6625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 6635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// AnnotateCachedTokens - We notify the Preprocessor that if it is caching 6645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// tokens (because backtrack is enabled) it should replace the most recent 6655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// cached tokens with the given annotation token. This function has no effect 6665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// if backtracking is not enabled. 6675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 6685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Note that the use of this function is just for optimization; so that the 6695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// cached tokens doesn't get re-parsed and re-resolved after a backtrack is 6705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// invoked. 6715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void AnnotateCachedTokens(const Token &Tok) { 6725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(Tok.isAnnotation() && "Expected annotation token"); 6735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (CachedLexPos != 0 && isBacktrackEnabled()) 6745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) AnnotatePreviousCachedTokens(Tok); 6755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 6765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 6775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Replace the last token with an annotation token. 6785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 6795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Like AnnotateCachedTokens(), this routine replaces an 6805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// already-parsed (and resolved) token with an annotation 6815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// token. However, this routine only replaces the last token with 6825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// the annotation token; it does not affect any other cached 6835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// tokens. This function has no effect if backtracking is not 6845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// enabled. 6855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void ReplaceLastTokenWithAnnotation(const Token &Tok) { 6865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(Tok.isAnnotation() && "Expected annotation token"); 6875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (CachedLexPos != 0 && isBacktrackEnabled()) 6885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CachedTokens[CachedLexPos-1] = Tok; 6895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 6905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 6915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Recompute the current lexer kind based on the CurLexer/CurPTHLexer/ 6925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// CurTokenLexer pointers. 6935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void recomputeCurLexerKind(); 6945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 6955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Specify the point at which code-completion will be performed. 6965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 6975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \param File the file in which code completion should occur. If 6985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// this file is included multiple times, code-completion will 6995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// perform completion the first time it is included. If NULL, this 7005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// function clears out the code-completion point. 7015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 7025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \param Line the line at which code completion should occur 7035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// (1-based). 7045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 7055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \param Column the column at which code completion should occur 7065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// (1-based). 7075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 7085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \returns true if an error occurred, false otherwise. 7095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool SetCodeCompletionPoint(const FileEntry *File, 7105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) unsigned Line, unsigned Column); 7115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Determine if we are performing code completion. 7135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool isCodeCompletionEnabled() const { return CodeCompletionFile != 0; } 7145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Returns the location of the code-completion point. 7165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Returns an invalid location if code-completion is not enabled or the file 7175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// containing the code-completion point has not been lexed yet. 7185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SourceLocation getCodeCompletionLoc() const { return CodeCompletionLoc; } 7195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Returns the start location of the file of code-completion point. 7215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Returns an invalid location if code-completion is not enabled or the file 7225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// containing the code-completion point has not been lexed yet. 7235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SourceLocation getCodeCompletionFileLoc() const { 7245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return CodeCompletionFileLoc; 7255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 7265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Returns true if code-completion is enabled and we have hit the 7285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// code-completion point. 7295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool isCodeCompletionReached() const { return CodeCompletionReached; } 7305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Note that we hit the code-completion point. 7325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void setCodeCompletionReached() { 7335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(isCodeCompletionEnabled() && "Code-completion not enabled!"); 7345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) CodeCompletionReached = true; 7355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Silence any diagnostics that occur after we hit the code-completion. 7365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) getDiagnostics().setSuppressAllDiagnostics(true); 7375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 7385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief The location of the currently-active #pragma clang 7405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// arc_cf_code_audited begin. Returns an invalid location if there 7415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// is no such pragma active. 7425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SourceLocation getPragmaARCCFCodeAuditedLoc() const { 7435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return PragmaARCCFCodeAuditedLoc; 7445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 7455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Set the location of the currently-active #pragma clang 7475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// arc_cf_code_audited begin. An invalid location ends the pragma. 7485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void setPragmaARCCFCodeAuditedLoc(SourceLocation Loc) { 7495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) PragmaARCCFCodeAuditedLoc = Loc; 7505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 7515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Instruct the preprocessor to skip part of the main 7535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// the main source file. 7545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 7555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Bytes The number of bytes in the preamble to skip. 7565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 7575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief StartOfLine Whether skipping these bytes puts the lexer at the 7585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// start of a line. 7595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void setSkipMainFilePreamble(unsigned Bytes, bool StartOfLine) { 7605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SkipMainFilePreamble.first = Bytes; 7615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SkipMainFilePreamble.second = StartOfLine; 7625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 7635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Diag - Forwarding function for diagnostics. This emits a diagnostic at 7655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// the specified Token's location, translating the token's start 7665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// position in the current buffer into a SourcePosition object for rendering. 7675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const { 7685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return Diags->Report(Loc, DiagID); 7695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 7705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) DiagnosticBuilder Diag(const Token &Tok, unsigned DiagID) const { 7725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return Diags->Report(Tok.getLocation(), DiagID); 7735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 7745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// getSpelling() - Return the 'spelling' of the token at the given 7765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// location; does not go up to the spelling location or down to the 7775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// expansion location. 7785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 7795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \param buffer A buffer which will be used only if the token requires 7805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// "cleaning", e.g. if it contains trigraphs or escaped newlines 7815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \param invalid If non-null, will be set \c true if an error occurs. 7825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) StringRef getSpelling(SourceLocation loc, 7835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SmallVectorImpl<char> &buffer, 7845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool *invalid = 0) const { 7855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return Lexer::getSpelling(loc, buffer, SourceMgr, Features, invalid); 7865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 7875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// getSpelling() - Return the 'spelling' of the Tok token. The spelling of a 7895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// token is the characters used to represent the token in the source file 7905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// after trigraph expansion and escaped-newline folding. In particular, this 7915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// wants to get the true, uncanonicalized, spelling of things like digraphs 7925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// UCNs, etc. 7935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 7945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \param Invalid If non-null, will be set \c true if an error occurs. 7955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) std::string getSpelling(const Token &Tok, bool *Invalid = 0) const { 7965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return Lexer::getSpelling(Tok, SourceMgr, Features, Invalid); 7975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 7985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 7995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// getSpelling - This method is used to get the spelling of a token into a 8005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// preallocated buffer, instead of as an std::string. The caller is required 8015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// to allocate enough space for the token, which is guaranteed to be at least 8025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Tok.getLength() bytes long. The length of the actual result is returned. 8035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 8045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Note that this method may do two possible things: it may either fill in 8055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// the buffer specified with characters, or it may *change the input pointer* 8065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// to point to a constant buffer with the data already in it (avoiding a 8075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// copy). The caller is not allowed to modify the returned buffer pointer 8085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// if an internal buffer is returned. 8095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) unsigned getSpelling(const Token &Tok, const char *&Buffer, 8105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool *Invalid = 0) const { 8115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return Lexer::getSpelling(Tok, Buffer, SourceMgr, Features, Invalid); 8125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 8135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// getSpelling - This method is used to get the spelling of a token into a 8155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// SmallVector. Note that the returned StringRef may not point to the 8165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// supplied buffer if a copy can be avoided. 8175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) StringRef getSpelling(const Token &Tok, 8185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SmallVectorImpl<char> &Buffer, 8195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool *Invalid = 0) const; 8205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// getSpellingOfSingleCharacterNumericConstant - Tok is a numeric constant 8225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// with length 1, return the character. 8235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) char getSpellingOfSingleCharacterNumericConstant(const Token &Tok, 8245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool *Invalid = 0) const { 8255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(Tok.is(tok::numeric_constant) && 8265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) Tok.getLength() == 1 && "Called on unsupported token"); 8275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) assert(!Tok.needsCleaning() && "Token can't need cleaning with length 1"); 8285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // If the token is carrying a literal data pointer, just use it. 8305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (const char *D = Tok.getLiteralData()) 8315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return *D; 8325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Otherwise, fall back on getCharacterData, which is slower, but always 8345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // works. 8355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return *SourceMgr.getCharacterData(Tok.getLocation(), Invalid); 8365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 8375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Retrieve the name of the immediate macro expansion. 8395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 8405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// This routine starts from a source location, and finds the name of the macro 8415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// responsible for its immediate expansion. It looks through any intervening 8425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// macro argument expansions to compute this. It returns a StringRef which 8435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// refers to the SourceManager-owned buffer of the source where that macro 8445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// name is spelled. Thus, the result shouldn't out-live the SourceManager. 8455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) StringRef getImmediateMacroName(SourceLocation Loc) { 8465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return Lexer::getImmediateMacroName(Loc, SourceMgr, getLangOptions()); 8475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 8485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// CreateString - Plop the specified string into a scratch buffer and set the 8505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// specified token's location and length to it. If specified, the source 8515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// location provides a location of the expansion point of the token. 8525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void CreateString(const char *Buf, unsigned Len, Token &Tok, 8535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SourceLocation ExpansionLocStart = SourceLocation(), 8545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SourceLocation ExpansionLocEnd = SourceLocation()); 8555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Computes the source location just past the end of the 8575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// token at this source location. 8585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 8595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// This routine can be used to produce a source location that 8605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// points just past the end of the token referenced by \p Loc, and 8615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// is generally used when a diagnostic needs to point just after a 8625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// token where it expected something different that it received. If 8635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// the returned source location would not be meaningful (e.g., if 8645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// it points into a macro), this routine returns an invalid 8655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// source location. 8665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 8675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \param Offset an offset from the end of the token, where the source 8685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// location should refer to. The default offset (0) produces a source 8695821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// location pointing just past the end of the token; an offset of 1 produces 8705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// a source location pointing to the last character in the token, etc. 8715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SourceLocation getLocForEndOfToken(SourceLocation Loc, unsigned Offset = 0) { 8725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return Lexer::getLocForEndOfToken(Loc, Offset, SourceMgr, Features); 8735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 8745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Returns true if the given MacroID location points at the first 8765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// token of the macro expansion. 8775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 8785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \param MacroBegin If non-null and function returns true, it is set to 8795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// begin location of the macro. 8805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool isAtStartOfMacroExpansion(SourceLocation loc, 8815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SourceLocation *MacroBegin = 0) const { 8825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return Lexer::isAtStartOfMacroExpansion(loc, SourceMgr, Features, 8835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) MacroBegin); 8845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 8855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \brief Returns true if the given MacroID location points at the last 8875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// token of the macro expansion. 8885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 8895821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// \param MacroBegin If non-null and function returns true, it is set to 8905821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// end location of the macro. 8915821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) bool isAtEndOfMacroExpansion(SourceLocation loc, 8925821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SourceLocation *MacroEnd = 0) const { 8935821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return Lexer::isAtEndOfMacroExpansion(loc, SourceMgr, Features, MacroEnd); 8945821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 8955821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 8965821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// DumpToken - Print the token to stderr, used for debugging. 8975821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 8985821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void DumpToken(const Token &Tok, bool DumpFlags = false) const; 8995821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void DumpLocation(SourceLocation Loc) const; 9005821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void DumpMacro(const MacroInfo &MI) const; 9015821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9025821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// AdvanceToTokenCharacter - Given a location that specifies the start of a 9035821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// token, return a new location that specifies a character within the token. 9045821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) SourceLocation AdvanceToTokenCharacter(SourceLocation TokStart, 9055821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) unsigned Char) const { 9065821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) return Lexer::AdvanceToTokenCharacter(TokStart, Char, SourceMgr, Features); 9075821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 9085821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9095821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// IncrementPasteCounter - Increment the counters for the number of token 9105821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// paste operations performed. If fast was specified, this is a 'fast paste' 9115821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// case we handled. 9125821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 9135821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void IncrementPasteCounter(bool isFast) { 9145821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if (isFast) 9155821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ++NumFastTokenPaste; 9165821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) else 9175821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) ++NumTokenPaste; 9185821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 9195821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9205821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void PrintStats(); 9215821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9225821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) size_t getTotalMemory() const; 9235821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9245821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// HandleMicrosoftCommentPaste - When the macro expander pastes together a 9255821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// comment (/##/) in microsoft mode, this method handles updating the current 9265821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// state, returning the token on the next source line. 9275821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void HandleMicrosoftCommentPaste(Token &Tok); 9285821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9295821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) //===--------------------------------------------------------------------===// 9305821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // Preprocessor callback methods. These are invoked by a lexer as various 9315821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // directives and events are found. 9325821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9335821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// LookUpIdentifierInfo - Given a tok::raw_identifier token, look up the 9345821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// identifier information for the token and install it into the token, 9355821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// updating the token kind accordingly. 9365821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IdentifierInfo *LookUpIdentifierInfo(Token &Identifier) const; 9375821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9385821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)private: 9395821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) llvm::DenseMap<IdentifierInfo*,unsigned> PoisonReasons; 9405821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9415821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)public: 9425821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9435821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // SetPoisonReason - Call this function to indicate the reason for 9445821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // poisoning an identifier. If that identifier is accessed while 9455821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // poisoned, then this reason will be used instead of the default 9465821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // "poisoned" diagnostic. 9475821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void SetPoisonReason(IdentifierInfo *II, unsigned DiagID); 9485821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9495821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // HandlePoisonedIdentifier - Display reason for poisoned 9505821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // identifier. 9515821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void HandlePoisonedIdentifier(Token & Tok); 9525821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9535821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void MaybeHandlePoisonedIdentifier(Token & Identifier) { 9545821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if(IdentifierInfo * II = Identifier.getIdentifierInfo()) { 9555821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) if(II->isPoisoned()) { 9565821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) HandlePoisonedIdentifier(Identifier); 9575821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 9585821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 9595821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) } 9605821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9615821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)private: 9625821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// Identifiers used for SEH handling in Borland. These are only 9635821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// allowed in particular circumstances 9645821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // __except block 9655821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IdentifierInfo *Ident__exception_code, 9665821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) *Ident___exception_code, 9675821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) *Ident_GetExceptionCode; 9685821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // __except filter expression 9697d4cd473f85ac64c3747c96c277f9e506a0d2246Torne (Richard Coles) IdentifierInfo *Ident__exception_info, 9705821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) *Ident___exception_info, 9715821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) *Ident_GetExceptionInfo; 9725821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) // __finally 9735821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) IdentifierInfo *Ident__abnormal_termination, 9745821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) *Ident___abnormal_termination, 9755821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) *Ident_AbnormalTermination; 9765821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles)public: 9775821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void PoisonSEHIdentifiers(bool Poison = true); // Borland 9785821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9795821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// HandleIdentifier - This callback is invoked when the lexer reads an 9805821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// identifier and has filled in the tokens IdentifierInfo member. This 9815821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// callback potentially macro expands it or turns it into a named token (like 9825821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// 'for'). 9835821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) void HandleIdentifier(Token &Identifier); 9845821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9855821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) 9865821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// HandleEndOfFile - This callback is invoked when the lexer hits the end of 9875821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// the current file. This either returns the EOF token and returns true, or 9885821806d5e7f356e8fa4b058a389a808ea183019Torne (Richard Coles) /// pops a level off the include stack and returns false, at which point the 989 /// client should call lex again. 990 bool HandleEndOfFile(Token &Result, bool isEndOfMacro = false); 991 992 /// HandleEndOfTokenLexer - This callback is invoked when the current 993 /// TokenLexer hits the end of its token stream. 994 bool HandleEndOfTokenLexer(Token &Result); 995 996 /// HandleDirective - This callback is invoked when the lexer sees a # token 997 /// at the start of a line. This consumes the directive, modifies the 998 /// lexer/preprocessor state, and advances the lexer(s) so that the next token 999 /// read is the correct one. 1000 void HandleDirective(Token &Result); 1001 1002 /// CheckEndOfDirective - Ensure that the next token is a tok::eod token. If 1003 /// not, emit a diagnostic and consume up until the eod. If EnableMacros is 1004 /// true, then we consider macros that expand to zero tokens as being ok. 1005 void CheckEndOfDirective(const char *Directive, bool EnableMacros = false); 1006 1007 /// DiscardUntilEndOfDirective - Read and discard all tokens remaining on the 1008 /// current line until the tok::eod token is found. 1009 void DiscardUntilEndOfDirective(); 1010 1011 /// SawDateOrTime - This returns true if the preprocessor has seen a use of 1012 /// __DATE__ or __TIME__ in the file so far. 1013 bool SawDateOrTime() const { 1014 return DATELoc != SourceLocation() || TIMELoc != SourceLocation(); 1015 } 1016 unsigned getCounterValue() const { return CounterValue; } 1017 void setCounterValue(unsigned V) { CounterValue = V; } 1018 1019 /// \brief Retrieves the module that we're currently building, if any. 1020 Module *getCurrentModule(); 1021 1022 /// AllocateMacroInfo - Allocate a new MacroInfo object with the provide 1023 /// SourceLocation. 1024 MacroInfo *AllocateMacroInfo(SourceLocation L); 1025 1026 /// CloneMacroInfo - Allocate a new MacroInfo object which is clone of MI. 1027 MacroInfo *CloneMacroInfo(const MacroInfo &MI); 1028 1029 /// GetIncludeFilenameSpelling - Turn the specified lexer token into a fully 1030 /// checked and spelled filename, e.g. as an operand of #include. This returns 1031 /// true if the input filename was in <>'s or false if it were in ""'s. The 1032 /// caller is expected to provide a buffer that is large enough to hold the 1033 /// spelling of the filename, but is also expected to handle the case when 1034 /// this method decides to use a different buffer. 1035 bool GetIncludeFilenameSpelling(SourceLocation Loc,StringRef &Filename); 1036 1037 /// LookupFile - Given a "foo" or <foo> reference, look up the indicated file, 1038 /// return null on failure. isAngled indicates whether the file reference is 1039 /// for system #include's or not (i.e. using <> instead of ""). 1040 const FileEntry *LookupFile(StringRef Filename, 1041 bool isAngled, const DirectoryLookup *FromDir, 1042 const DirectoryLookup *&CurDir, 1043 SmallVectorImpl<char> *SearchPath, 1044 SmallVectorImpl<char> *RelativePath, 1045 Module **SuggestedModule, 1046 bool SkipCache = false); 1047 1048 /// GetCurLookup - The DirectoryLookup structure used to find the current 1049 /// FileEntry, if CurLexer is non-null and if applicable. This allows us to 1050 /// implement #include_next and find directory-specific properties. 1051 const DirectoryLookup *GetCurDirLookup() { return CurDirLookup; } 1052 1053 /// isInPrimaryFile - Return true if we're in the top-level file, not in a 1054 /// #include. 1055 bool isInPrimaryFile() const; 1056 1057 /// ConcatenateIncludeName - Handle cases where the #include name is expanded 1058 /// from a macro as multiple tokens, which need to be glued together. This 1059 /// occurs for code like: 1060 /// #define FOO <a/b.h> 1061 /// #include FOO 1062 /// because in this case, "<a/b.h>" is returned as 7 tokens, not one. 1063 /// 1064 /// This code concatenates and consumes tokens up to the '>' token. It 1065 /// returns false if the > was found, otherwise it returns true if it finds 1066 /// and consumes the EOD marker. 1067 bool ConcatenateIncludeName(SmallString<128> &FilenameBuffer, 1068 SourceLocation &End); 1069 1070 /// LexOnOffSwitch - Lex an on-off-switch (C99 6.10.6p2) and verify that it is 1071 /// followed by EOD. Return true if the token is not a valid on-off-switch. 1072 bool LexOnOffSwitch(tok::OnOffSwitch &OOS); 1073 1074private: 1075 1076 void PushIncludeMacroStack() { 1077 IncludeMacroStack.push_back(IncludeStackInfo(CurLexerKind, 1078 CurLexer.take(), 1079 CurPTHLexer.take(), 1080 CurPPLexer, 1081 CurTokenLexer.take(), 1082 CurDirLookup)); 1083 CurPPLexer = 0; 1084 } 1085 1086 void PopIncludeMacroStack() { 1087 CurLexer.reset(IncludeMacroStack.back().TheLexer); 1088 CurPTHLexer.reset(IncludeMacroStack.back().ThePTHLexer); 1089 CurPPLexer = IncludeMacroStack.back().ThePPLexer; 1090 CurTokenLexer.reset(IncludeMacroStack.back().TheTokenLexer); 1091 CurDirLookup = IncludeMacroStack.back().TheDirLookup; 1092 CurLexerKind = IncludeMacroStack.back().CurLexerKind; 1093 IncludeMacroStack.pop_back(); 1094 } 1095 1096 /// AllocateMacroInfo - Allocate a new MacroInfo object. 1097 MacroInfo *AllocateMacroInfo(); 1098 1099 /// ReleaseMacroInfo - Release the specified MacroInfo. This memory will 1100 /// be reused for allocating new MacroInfo objects. 1101 void ReleaseMacroInfo(MacroInfo* MI); 1102 1103 /// ReadMacroName - Lex and validate a macro name, which occurs after a 1104 /// #define or #undef. This emits a diagnostic, sets the token kind to eod, 1105 /// and discards the rest of the macro line if the macro name is invalid. 1106 void ReadMacroName(Token &MacroNameTok, char isDefineUndef = 0); 1107 1108 /// ReadMacroDefinitionArgList - The ( starting an argument list of a macro 1109 /// definition has just been read. Lex the rest of the arguments and the 1110 /// closing ), updating MI with what we learn. Return true if an error occurs 1111 /// parsing the arg list. 1112 bool ReadMacroDefinitionArgList(MacroInfo *MI); 1113 1114 /// SkipExcludedConditionalBlock - We just read a #if or related directive and 1115 /// decided that the subsequent tokens are in the #if'd out portion of the 1116 /// file. Lex the rest of the file, until we see an #endif. If 1117 /// FoundNonSkipPortion is true, then we have already emitted code for part of 1118 /// this #if directive, so #else/#elif blocks should never be entered. If 1119 /// FoundElse is false, then #else directives are ok, if not, then we have 1120 /// already seen one so a #else directive is a duplicate. When this returns, 1121 /// the caller can lex the first valid token. 1122 void SkipExcludedConditionalBlock(SourceLocation IfTokenLoc, 1123 bool FoundNonSkipPortion, bool FoundElse, 1124 SourceLocation ElseLoc = SourceLocation()); 1125 1126 /// PTHSkipExcludedConditionalBlock - A fast PTH version of 1127 /// SkipExcludedConditionalBlock. 1128 void PTHSkipExcludedConditionalBlock(); 1129 1130 /// EvaluateDirectiveExpression - Evaluate an integer constant expression that 1131 /// may occur after a #if or #elif directive and return it as a bool. If the 1132 /// expression is equivalent to "!defined(X)" return X in IfNDefMacro. 1133 bool EvaluateDirectiveExpression(IdentifierInfo *&IfNDefMacro); 1134 1135 /// RegisterBuiltinPragmas - Install the standard preprocessor pragmas: 1136 /// #pragma GCC poison/system_header/dependency and #pragma once. 1137 void RegisterBuiltinPragmas(); 1138 1139 /// RegisterBuiltinMacros - Register builtin macros, such as __LINE__ with the 1140 /// identifier table. 1141 void RegisterBuiltinMacros(); 1142 1143 /// HandleMacroExpandedIdentifier - If an identifier token is read that is to 1144 /// be expanded as a macro, handle it and return the next token as 'Tok'. If 1145 /// the macro should not be expanded return true, otherwise return false. 1146 bool HandleMacroExpandedIdentifier(Token &Tok, MacroInfo *MI); 1147 1148 /// \brief Cache macro expanded tokens for TokenLexers. 1149 // 1150 /// Works like a stack; a TokenLexer adds the macro expanded tokens that is 1151 /// going to lex in the cache and when it finishes the tokens are removed 1152 /// from the end of the cache. 1153 Token *cacheMacroExpandedTokens(TokenLexer *tokLexer, 1154 ArrayRef<Token> tokens); 1155 void removeCachedMacroExpandedTokensOfLastLexer(); 1156 friend void TokenLexer::ExpandFunctionArguments(); 1157 1158 /// isNextPPTokenLParen - Determine whether the next preprocessor token to be 1159 /// lexed is a '('. If so, consume the token and return true, if not, this 1160 /// method should have no observable side-effect on the lexed tokens. 1161 bool isNextPPTokenLParen(); 1162 1163 /// ReadFunctionLikeMacroArgs - After reading "MACRO(", this method is 1164 /// invoked to read all of the formal arguments specified for the macro 1165 /// invocation. This returns null on error. 1166 MacroArgs *ReadFunctionLikeMacroArgs(Token &MacroName, MacroInfo *MI, 1167 SourceLocation &ExpansionEnd); 1168 1169 /// ExpandBuiltinMacro - If an identifier token is read that is to be expanded 1170 /// as a builtin macro, handle it and return the next token as 'Tok'. 1171 void ExpandBuiltinMacro(Token &Tok); 1172 1173 /// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then 1174 /// return the first token after the directive. The _Pragma token has just 1175 /// been read into 'Tok'. 1176 void Handle_Pragma(Token &Tok); 1177 1178 /// HandleMicrosoft__pragma - Like Handle_Pragma except the pragma text 1179 /// is not enclosed within a string literal. 1180 void HandleMicrosoft__pragma(Token &Tok); 1181 1182 /// EnterSourceFileWithLexer - Add a lexer to the top of the include stack and 1183 /// start lexing tokens from it instead of the current buffer. 1184 void EnterSourceFileWithLexer(Lexer *TheLexer, const DirectoryLookup *Dir); 1185 1186 /// EnterSourceFileWithPTH - Add a lexer to the top of the include stack and 1187 /// start getting tokens from it using the PTH cache. 1188 void EnterSourceFileWithPTH(PTHLexer *PL, const DirectoryLookup *Dir); 1189 1190 /// IsFileLexer - Returns true if we are lexing from a file and not a 1191 /// pragma or a macro. 1192 static bool IsFileLexer(const Lexer* L, const PreprocessorLexer* P) { 1193 return L ? !L->isPragmaLexer() : P != 0; 1194 } 1195 1196 static bool IsFileLexer(const IncludeStackInfo& I) { 1197 return IsFileLexer(I.TheLexer, I.ThePPLexer); 1198 } 1199 1200 bool IsFileLexer() const { 1201 return IsFileLexer(CurLexer.get(), CurPPLexer); 1202 } 1203 1204 //===--------------------------------------------------------------------===// 1205 // Caching stuff. 1206 void CachingLex(Token &Result); 1207 bool InCachingLexMode() const { 1208 // If the Lexer pointers are 0 and IncludeMacroStack is empty, it means 1209 // that we are past EOF, not that we are in CachingLex mode. 1210 return CurPPLexer == 0 && CurTokenLexer == 0 && CurPTHLexer == 0 && 1211 !IncludeMacroStack.empty(); 1212 } 1213 void EnterCachingLexMode(); 1214 void ExitCachingLexMode() { 1215 if (InCachingLexMode()) 1216 RemoveTopOfLexerStack(); 1217 } 1218 const Token &PeekAhead(unsigned N); 1219 void AnnotatePreviousCachedTokens(const Token &Tok); 1220 1221 //===--------------------------------------------------------------------===// 1222 /// Handle*Directive - implement the various preprocessor directives. These 1223 /// should side-effect the current preprocessor object so that the next call 1224 /// to Lex() will return the appropriate token next. 1225 void HandleLineDirective(Token &Tok); 1226 void HandleDigitDirective(Token &Tok); 1227 void HandleUserDiagnosticDirective(Token &Tok, bool isWarning); 1228 void HandleIdentSCCSDirective(Token &Tok); 1229 void HandleMacroPublicDirective(Token &Tok); 1230 void HandleMacroPrivateDirective(Token &Tok); 1231 1232 // File inclusion. 1233 void HandleIncludeDirective(SourceLocation HashLoc, 1234 Token &Tok, 1235 const DirectoryLookup *LookupFrom = 0, 1236 bool isImport = false); 1237 void HandleIncludeNextDirective(SourceLocation HashLoc, Token &Tok); 1238 void HandleIncludeMacrosDirective(SourceLocation HashLoc, Token &Tok); 1239 void HandleImportDirective(SourceLocation HashLoc, Token &Tok); 1240 1241 // Macro handling. 1242 void HandleDefineDirective(Token &Tok); 1243 void HandleUndefDirective(Token &Tok); 1244 1245 // Conditional Inclusion. 1246 void HandleIfdefDirective(Token &Tok, bool isIfndef, 1247 bool ReadAnyTokensBeforeDirective); 1248 void HandleIfDirective(Token &Tok, bool ReadAnyTokensBeforeDirective); 1249 void HandleEndifDirective(Token &Tok); 1250 void HandleElseDirective(Token &Tok); 1251 void HandleElifDirective(Token &Tok); 1252 1253 // Pragmas. 1254 void HandlePragmaDirective(unsigned Introducer); 1255public: 1256 void HandlePragmaOnce(Token &OnceTok); 1257 void HandlePragmaMark(); 1258 void HandlePragmaPoison(Token &PoisonTok); 1259 void HandlePragmaSystemHeader(Token &SysHeaderTok); 1260 void HandlePragmaDependency(Token &DependencyTok); 1261 void HandlePragmaComment(Token &CommentTok); 1262 void HandlePragmaMessage(Token &MessageTok); 1263 void HandlePragmaPushMacro(Token &Tok); 1264 void HandlePragmaPopMacro(Token &Tok); 1265 void HandlePragmaIncludeAlias(Token &Tok); 1266 IdentifierInfo *ParsePragmaPushOrPopMacro(Token &Tok); 1267 1268 // Return true and store the first token only if any CommentHandler 1269 // has inserted some tokens and getCommentRetentionState() is false. 1270 bool HandleComment(Token &Token, SourceRange Comment); 1271 1272 /// \brief A macro is used, update information about macros that need unused 1273 /// warnings. 1274 void markMacroAsUsed(MacroInfo *MI); 1275}; 1276 1277/// \brief Abstract base class that describes a handler that will receive 1278/// source ranges for each of the comments encountered in the source file. 1279class CommentHandler { 1280public: 1281 virtual ~CommentHandler(); 1282 1283 // The handler shall return true if it has pushed any tokens 1284 // to be read using e.g. EnterToken or EnterTokenStream. 1285 virtual bool HandleComment(Preprocessor &PP, SourceRange Comment) = 0; 1286}; 1287 1288} // end namespace clang 1289 1290#endif 1291