Home | History | Annotate | Download | only in Lex
      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&);  // DO NOT IMPLEMENT
     48   void operator=(const PTHLexer&); // DO NOT IMPLEMENT
     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 
     68   ~PTHLexer() {}
     69 
     70   /// Lex - Return the next token.
     71   void 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.
     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.
     93   void IndirectLex(Token &Result) { Lex(Result); }
     94 
     95   /// getSourceLocation - Return a source location for the token in
     96   /// the current file.
     97   SourceLocation getSourceLocation();
     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