From 82a500b141b9a8001dac69f047478a43e2aebdff Mon Sep 17 00:00:00 2001
From: Ted Kremenek <kremenek@apple.com>
Date: Thu, 27 Nov 2008 00:38:24 +0000
Subject: [PATCH] PTHLexer now owns the Token vector.

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@60136 91177308-0d34-0410-b5e6-96231b3b80d8
---
 include/clang/Lex/PTHLexer.h | 22 +++++++++-------------
 lib/Lex/PPLexerChange.cpp    | 26 ++++++++++++++------------
 lib/Lex/PTHLexer.cpp         | 15 ++++-----------
 3 files changed, 27 insertions(+), 36 deletions(-)

diff --git a/include/clang/Lex/PTHLexer.h b/include/clang/Lex/PTHLexer.h
index 3218a1dd5d..679e7b576f 100644
--- a/include/clang/Lex/PTHLexer.h
+++ b/include/clang/Lex/PTHLexer.h
@@ -15,30 +15,24 @@
 #define LLVM_CLANG_PTHLEXER_H
 
 #include "clang/Lex/PreprocessorLexer.h"
+#include <vector>
 
 namespace clang {
   
 class PTHLexer : public PreprocessorLexer {
-  /// Tokens - This is the pointer to an array of tokens that the macro is
-  /// defined to, with arguments expanded for function-like macros.  If this is
-  /// a token stream, these are the tokens we are returning.
-  const Token *Tokens;
-  
-  /// LastTokenIdx - The index of the last token in Tokens.  This token
-  ///  will be an eof token.
-  unsigned LastTokenIdx;
-  
+  /// Tokens - Vector of raw tokens.
+  std::vector<Token> Tokens;
+
   /// CurTokenIdx - This is the index of the next token that Lex will return.
   unsigned CurTokenIdx;
         
   PTHLexer(const PTHLexer&);  // DO NOT IMPLEMENT
   void operator=(const PTHLexer&); // DO NOT IMPLEMENT
 
-public:
+public:  
 
   /// Create a PTHLexer for the specified token stream.
-  PTHLexer(Preprocessor& pp, SourceLocation fileloc,
-           const Token *TokArray, unsigned NumToks);
+  PTHLexer(Preprocessor& pp, SourceLocation fileloc);
   ~PTHLexer() {}
     
   /// Lex - Return the next token.
@@ -46,6 +40,8 @@ public:
   
   void setEOF(Token &Tok);
   
+  std::vector<Token>& getTokens() { return Tokens; }
+  
   /// DiscardToEndOfLine - Read the rest of the current preprocessor line as an
   /// uninterpreted string.  This switches the lexer out of directive mode.
   void DiscardToEndOfLine();
@@ -64,7 +60,7 @@ public:
 private:
   
   /// AtLastToken - Returns true if the PTHLexer is at the last token.
-  bool AtLastToken() const { return CurTokenIdx == LastTokenIdx; }
+  bool AtLastToken() const { return CurTokenIdx+1 == Tokens.size(); }
   
   /// GetToken - Returns the next token.  This method does not advance the
   ///  PTHLexer to the next token.
diff --git a/lib/Lex/PPLexerChange.cpp b/lib/Lex/PPLexerChange.cpp
index 5716d49207..5129d58bd7 100644
--- a/lib/Lex/PPLexerChange.cpp
+++ b/lib/Lex/PPLexerChange.cpp
@@ -78,6 +78,16 @@ void Preprocessor::EnterSourceFile(unsigned FileID,
   Lexer *TheLexer = new Lexer(SourceLocation::getFileLoc(FileID, 0), *this);
   EnterSourceFileWithLexer(TheLexer, CurDir);
 #else
+  if (CurPPLexer || CurTokenLexer)
+    PushIncludeMacroStack();
+  
+  CurDirLookup = CurDir;
+  SourceLocation Loc = SourceLocation::getFileLoc(FileID, 0);
+  CurPTHLexer.reset(new PTHLexer(*this, Loc));
+  CurPPLexer = CurPTHLexer.get();
+
+  // Generate the tokens.
+  
   const llvm::MemoryBuffer* B = getSourceManager().getBuffer(FileID);
   
   // Create a raw lexer.
@@ -89,7 +99,7 @@ void Preprocessor::EnterSourceFile(unsigned FileID,
   L.SetCommentRetentionState(false);
   
   // Lex the file, populating our data structures.
-  std::vector<Token>* Tokens = new std::vector<Token>();
+  std::vector<Token>& Tokens = CurPTHLexer->getTokens();
   Token Tok;
   
   do {
@@ -101,7 +111,7 @@ void Preprocessor::EnterSourceFile(unsigned FileID,
     else if (Tok.is(tok::hash) && Tok.isAtStartOfLine()) {
       // Special processing for #include.  Store the '#' token and lex
       // the next token.
-      Tokens->push_back(Tok);
+      Tokens.push_back(Tok);
       L.LexFromRawLexer(Tok);
       
       // Did we see 'include'/'import'/'include_next'?
@@ -116,7 +126,7 @@ void Preprocessor::EnterSourceFile(unsigned FileID,
           K == tok::pp_include_next) {
         
         // Save the 'include' token.
-        Tokens->push_back(Tok);
+        Tokens.push_back(Tok);
         
         // Lex the next token as an include string.
         L.ParsingPreprocessorDirective = true;
@@ -128,15 +138,7 @@ void Preprocessor::EnterSourceFile(unsigned FileID,
       }
     }    
   }
-  while (Tokens->push_back(Tok), Tok.isNot(tok::eof));
-  
-  if (CurPPLexer || CurTokenLexer)
-    PushIncludeMacroStack();
-  
-  CurDirLookup = CurDir;
-  SourceLocation Loc = SourceLocation::getFileLoc(FileID, 0);
-  CurPTHLexer.reset(new PTHLexer(*this, Loc, &(*Tokens)[0], Tokens->size()));
-  CurPPLexer = CurPTHLexer.get();
+  while (Tokens.push_back(Tok), Tok.isNot(tok::eof));
   
   // Notify the client, if desired, that we are in a new source file.
   if (Callbacks) {
diff --git a/lib/Lex/PTHLexer.cpp b/lib/Lex/PTHLexer.cpp
index 21fb9831a4..bc9e714776 100644
--- a/lib/Lex/PTHLexer.cpp
+++ b/lib/Lex/PTHLexer.cpp
@@ -16,16 +16,8 @@
 #include "clang/Basic/TokenKinds.h"
 using namespace clang;
 
-PTHLexer::PTHLexer(Preprocessor& pp, SourceLocation fileloc,
-                   const Token *TokArray, unsigned NumTokens)
-  : PreprocessorLexer(&pp, fileloc),
-    Tokens(TokArray),
-    LastTokenIdx(NumTokens - 1),
-    CurTokenIdx(0) {
-
-  assert(NumTokens >= 1);
-  assert(Tokens[LastTokenIdx].is(tok::eof));
-}
+PTHLexer::PTHLexer(Preprocessor& pp, SourceLocation fileloc)
+  : PreprocessorLexer(&pp, fileloc), CurTokenIdx(0) {}
 
 Token PTHLexer::GetToken() { 
   Token Tok = Tokens[CurTokenIdx];
@@ -104,7 +96,8 @@ bool PTHLexer::LexEndOfFile(Token &Tok) {
 }
 
 void PTHLexer::setEOF(Token& Tok) {
-  Tok = Tokens[LastTokenIdx];
+  assert(!Tokens.empty());
+  Tok = Tokens[Tokens.size()-1];
 }
 
 void PTHLexer::DiscardToEndOfLine() {
-- 
2.40.0