Add Preprocessor::LookNext method, which implements an efficient way to 'take a peek' at the next token without consuming it.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@53375 91177308-0d34-0410-b5e6-96231b3b80d8

2 files changed, 58 insertions, 1 deletions

diff --git a/include/clang/Lex/Preprocessor.h b/include/clang/Lex/Preprocessor.h
index 2617f2838b..01d88d1e90 100644
--- a/include/clang/Lex/Preprocessor.h
+++ b/include/clang/Lex/Preprocessor.h
@@ -138,6 +138,11 @@ class Preprocessor {
   enum { TokenLexerCacheSize = 8 };
   unsigned NumCachedTokenLexers;
   TokenLexer *TokenLexerCache[TokenLexerCacheSize];
+
+  /// PeekedToken - Cache the token that was retrieved through LookNext().
+  /// This is a valid token (its Location is valid) when LookNext() is
+  /// called and gets invalid again when it is "consumed" by Lex().
+  Token PeekedToken;
 public:
   Preprocessor(Diagnostic &diags, const LangOptions &opts, TargetInfo &target,
                SourceManager &SM, HeaderSearch &Headers);
@@ -258,8 +263,13 @@ public:
   void Lex(Token &Result) {
     if (CurLexer)
       CurLexer->Lex(Result);
-    else
+    else if (CurTokenLexer)
       CurTokenLexer->Lex(Result);
+    else {
+      // We have a peeked token that hasn't been consumed yet.
+      Result = PeekedToken;
+      ConsumedPeekedToken();
+    }
   }
   
   /// LexNonComment - Lex a token.  If it's a comment, keep lexing until we get
@@ -294,6 +304,27 @@ public:
   /// code paths if possible!
   ///
   Token LookAhead(unsigned N);
+
+  /// LookNext - Returns the next token that would be returned by Lex() without
+  /// consuming it.
+  const Token &LookNext() {
+    if (PeekedToken.getLocation().isInvalid()) {
+      // We don't have a peeked token that hasn't been consumed yet.
+      // Peek it now.
+      PeekToken();
+    }
+    return PeekedToken;
+  }
+
+private:
+  /// PeekToken - Lexes one token into PeekedToken and pushes CurLexer,
+  /// CurLexerToken into the IncludeMacroStack before setting them to null.
+  void PeekToken();
+
+  /// ConsumedPeekedToken - Called when Lex() is about to return the PeekedToken
+  /// and have it "consumed".
+  void ConsumedPeekedToken();
+public:
   
   /// Diag - Forwarding function for diagnostics.  This emits a diagnostic at
   /// the specified Token's location, translating the token's start
diff --git a/lib/Lex/PPLexerChange.cpp b/lib/Lex/PPLexerChange.cpp
index c15675114d..bef522e346 100644
--- a/lib/Lex/PPLexerChange.cpp
+++ b/lib/Lex/PPLexerChange.cpp
@@ -85,6 +85,10 @@ Token Preprocessor::LookAhead(unsigned N) {
   // size we new to a multiple of 16 tokens.  If the previous buffer has space
   // left, we can just grow it.  This means we only have to do the new 1/16th as
   // often.
+
+  // Optimized LookAhead(0) case.
+  if (N == 0)
+    return LookNext();
   
   Token *LookaheadTokens = new Token[N+1];
 
@@ -122,6 +126,28 @@ Token Preprocessor::LookAhead(unsigned N) {
   return Tok;
 }
 
+/// PeekToken - Lexes one token into PeekedToken and pushes CurLexer,

+/// CurLexerToken into the IncludeMacroStack before setting them to null.

+void Preprocessor::PeekToken() {

+  Lex(PeekedToken);

+  // Cache the current Lexer, TokenLexer and set them both to null.

+  // When Lex() is called, PeekedToken will be "consumed".

+  IncludeMacroStack.push_back(IncludeStackInfo(CurLexer, CurDirLookup,

+                                               CurTokenLexer));

+  CurLexer = 0;

+  CurTokenLexer = 0;

+}

+
+/// ConsumedPeekedToken - Called when Lex() is about to return the PeekedToken

+/// and have it "consumed".

+void Preprocessor::ConsumedPeekedToken() {

+  assert(PeekedToken.getLocation().isValid() && "Confused Peeking?");

+  // Restore CurLexer, TokenLexer.

+  RemoveTopOfLexerStack();

+  // Make PeekedToken invalid.

+  PeekedToken.startToken();

+}

+
 
 //===----------------------------------------------------------------------===//
 // Methods for Entering and Callbacks for leaving various contexts