1 //===--- PTHLexer.h - Lexer based on Pre-tokenized input --------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file defines the PTHLexer interface. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_CLANG_PTHLEXER_H 15 #define LLVM_CLANG_PTHLEXER_H 16 17 #include "clang/Lex/PreprocessorLexer.h" 18 19 namespace clang { 20 21 class PTHManager; 22 class PTHSpellingSearch; 23 24 class PTHLexer : public PreprocessorLexer { 25 SourceLocation FileStartLoc; 26 27 /// TokBuf - Buffer from PTH file containing raw token data. 28 const unsigned char* TokBuf; 29 30 /// CurPtr - Pointer into current offset of the token buffer where 31 /// the next token will be read. 32 const unsigned char* CurPtr; 33 34 /// LastHashTokPtr - Pointer into TokBuf of the last processed '#' 35 /// token that appears at the start of a line. 36 const unsigned char* LastHashTokPtr; 37 38 /// PPCond - Pointer to a side table in the PTH file that provides a 39 /// a consise summary of the preproccessor conditional block structure. 40 /// This is used to perform quick skipping of conditional blocks. 41 const unsigned char* PPCond; 42 43 /// CurPPCondPtr - Pointer inside PPCond that refers to the next entry 44 /// to process when doing quick skipping of preprocessor blocks. 45 const unsigned char* CurPPCondPtr; 46 47 PTHLexer(const PTHLexer &) LLVM_DELETED_FUNCTION; 48 void operator=(const PTHLexer &) LLVM_DELETED_FUNCTION; 49 50 /// ReadToken - Used by PTHLexer to read tokens TokBuf. 51 void ReadToken(Token& T); 52 53 bool LexEndOfFile(Token &Result); 54 55 /// PTHMgr - The PTHManager object that created this PTHLexer. 56 PTHManager& PTHMgr; 57 58 Token EofToken; 59 60 protected: 61 friend class PTHManager; 62 63 /// Create a PTHLexer for the specified token stream. 64 PTHLexer(Preprocessor& pp, FileID FID, const unsigned char *D, 65 const unsigned char* ppcond, PTHManager &PM); 66 public: 67 ~PTHLexer()68 ~PTHLexer() {} 69 70 /// Lex - Return the next token. 71 bool Lex(Token &Tok); 72 73 void getEOF(Token &Tok); 74 75 /// DiscardToEndOfLine - Read the rest of the current preprocessor line as an 76 /// uninterpreted string. This switches the lexer out of directive mode. 77 void DiscardToEndOfLine(); 78 79 /// isNextPPTokenLParen - Return 1 if the next unexpanded token will return a 80 /// tok::l_paren token, 0 if it is something else and 2 if there are no more 81 /// tokens controlled by this lexer. isNextPPTokenLParen()82 unsigned isNextPPTokenLParen() { 83 // isNextPPTokenLParen is not on the hot path, and all we care about is 84 // whether or not we are at a token with kind tok::eof or tok::l_paren. 85 // Just read the first byte from the current token pointer to determine 86 // its kind. 87 tok::TokenKind x = (tok::TokenKind)*CurPtr; 88 return x == tok::eof ? 2 : x == tok::l_paren; 89 } 90 91 /// IndirectLex - An indirect call to 'Lex' that can be invoked via 92 /// the PreprocessorLexer interface. IndirectLex(Token & Result)93 void IndirectLex(Token &Result) override { Lex(Result); } 94 95 /// getSourceLocation - Return a source location for the token in 96 /// the current file. 97 SourceLocation getSourceLocation() override; 98 99 /// SkipBlock - Used by Preprocessor to skip the current conditional block. 100 bool SkipBlock(); 101 }; 102 103 } // end namespace clang 104 105 #endif 106