contrib/llvm/tools/clang/lib/Lex/TokenLexer.cpp

   1 //===--- TokenLexer.cpp - Lex from a token stream -------------------------===//
   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 implements the TokenLexer interface.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/Lex/TokenLexer.h"
  15 #include "MacroArgs.h"
  16 #include "clang/Lex/MacroInfo.h"
  17 #include "clang/Lex/Preprocessor.h"
  18 #include "clang/Basic/SourceManager.h"
  19 #include "clang/Lex/LexDiagnostic.h"
  20 #include "llvm/ADT/SmallVector.h"
  21 using namespace clang;
  22
  23
  24 /// Create a TokenLexer for the specified macro with the specified actual
  25 /// arguments.  Note that this ctor takes ownership of the ActualArgs pointer.
  26 void TokenLexer::Init(Token &Tok, SourceLocation ELEnd, MacroArgs *Actuals) {
  27   // If the client is reusing a TokenLexer, make sure to free any memory
  28   // associated with it.
  29   destroy();
  30
  31   Macro = PP.getMacroInfo(Tok.getIdentifierInfo());
  32   ActualArgs = Actuals;
  33   CurToken = 0;
  34
  35   ExpandLocStart = Tok.getLocation();
  36   ExpandLocEnd = ELEnd;
  37   AtStartOfLine = Tok.isAtStartOfLine();
  38   HasLeadingSpace = Tok.hasLeadingSpace();
  39   Tokens = &*Macro->tokens_begin();
  40   OwnsTokens = false;
  41   DisableMacroExpansion = false;
  42   NumTokens = Macro->tokens_end()-Macro->tokens_begin();
  43   MacroExpansionStart = SourceLocation();
  44
  45   SourceManager &SM = PP.getSourceManager();
  46   MacroStartSLocOffset = SM.getNextOffset();
  47
  48   if (NumTokens > 0) {
  49     assert(Tokens[0].getLocation().isValid());
  50     assert((Tokens[0].getLocation().isFileID() || Tokens[0].is(tok::comment)) &&
  51            "Macro defined in macro?");
  52     assert(ExpandLocStart.isValid());
  53
  54     // Reserve a source location entry chunk for the length of the macro
  55     // definition. Tokens that get lexed directly from the definition will
  56     // have their locations pointing inside this chunk. This is to avoid
  57     // creating separate source location entries for each token.
  58     SourceLocation macroStart = SM.getInstantiationLoc(Tokens[0].getLocation());
  59     MacroDefStartInfo = SM.getDecomposedLoc(macroStart);
  60     MacroExpansionStart = SM.createInstantiationLoc(macroStart,
  61                                               ExpandLocStart,
  62                                               ExpandLocEnd,
  63                                               Macro->getDefinitionLength(SM));
  64   }
  65
  66   // If this is a function-like macro, expand the arguments and change
  67   // Tokens to point to the expanded tokens.
  68   if (Macro->isFunctionLike() && Macro->getNumArgs())
  69     ExpandFunctionArguments();
  70
  71   // Mark the macro as currently disabled, so that it is not recursively
  72   // expanded.  The macro must be disabled only after argument pre-expansion of
  73   // function-like macro arguments occurs.
  74   Macro->DisableMacro();
  75 }
  76
  77
  78
  79 /// Create a TokenLexer for the specified token stream.  This does not
  80 /// take ownership of the specified token vector.
  81 void TokenLexer::Init(const Token *TokArray, unsigned NumToks,
  82                       bool disableMacroExpansion, bool ownsTokens) {
  83   // If the client is reusing a TokenLexer, make sure to free any memory
  84   // associated with it.
  85   destroy();
  86
  87   Macro = 0;
  88   ActualArgs = 0;
  89   Tokens = TokArray;
  90   OwnsTokens = ownsTokens;
  91   DisableMacroExpansion = disableMacroExpansion;
  92   NumTokens = NumToks;
  93   CurToken = 0;
  94   ExpandLocStart = ExpandLocEnd = SourceLocation();
  95   AtStartOfLine = false;
  96   HasLeadingSpace = false;
  97   MacroExpansionStart = SourceLocation();
  98
  99   // Set HasLeadingSpace/AtStartOfLine so that the first token will be
 100   // returned unmodified.
 101   if (NumToks != 0) {
 102     AtStartOfLine   = TokArray[0].isAtStartOfLine();
 103     HasLeadingSpace = TokArray[0].hasLeadingSpace();
 104   }
 105 }
 106
 107
 108 void TokenLexer::destroy() {
 109   // If this was a function-like macro that actually uses its arguments, delete
 110   // the expanded tokens.
 111   if (OwnsTokens) {
 112     delete [] Tokens;
 113     Tokens = 0;
 114     OwnsTokens = false;
 115   }
 116
 117   // TokenLexer owns its formal arguments.
 118   if (ActualArgs) ActualArgs->destroy(PP);
 119 }
 120
 121 /// Expand the arguments of a function-like macro so that we can quickly
 122 /// return preexpanded tokens from Tokens.
 123 void TokenLexer::ExpandFunctionArguments() {
 124   SourceManager &SM = PP.getSourceManager();
 125
 126   llvm::SmallVector<Token, 128> ResultToks;
 127
 128   // Loop through 'Tokens', expanding them into ResultToks.  Keep
 129   // track of whether we change anything.  If not, no need to keep them.  If so,
 130   // we install the newly expanded sequence as the new 'Tokens' list.
 131   bool MadeChange = false;
 132
 133   // NextTokGetsSpace - When this is true, the next token appended to the
 134   // output list will get a leading space, regardless of whether it had one to
 135   // begin with or not.  This is used for placemarker support.
 136   bool NextTokGetsSpace = false;
 137
 138   for (unsigned i = 0, e = NumTokens; i != e; ++i) {
 139     // If we found the stringify operator, get the argument stringified.  The
 140     // preprocessor already verified that the following token is a macro name
 141     // when the #define was parsed.
 142     const Token &CurTok = Tokens[i];
 143     if (CurTok.is(tok::hash) || CurTok.is(tok::hashat)) {
 144       int ArgNo = Macro->getArgumentNum(Tokens[i+1].getIdentifierInfo());
 145       assert(ArgNo != -1 && "Token following # is not an argument?");
 146
 147       SourceLocation hashInstLoc;
 148       if(ExpandLocStart.isValid()) {
 149         hashInstLoc = getMacroExpansionLocation(CurTok.getLocation());
 150         assert(hashInstLoc.isValid() && "Expected '#' to come from definition");
 151       }
 152
 153       Token Res;
 154       if (CurTok.is(tok::hash))  // Stringify
 155         Res = ActualArgs->getStringifiedArgument(ArgNo, PP, hashInstLoc);
 156       else {
 157         // 'charify': don't bother caching these.
 158         Res = MacroArgs::StringifyArgument(ActualArgs->getUnexpArgument(ArgNo),
 159                                            PP, true, hashInstLoc);
 160       }
 161
 162       // The stringified/charified string leading space flag gets set to match
 163       // the #/#@ operator.
 164       if (CurTok.hasLeadingSpace() || NextTokGetsSpace)
 165         Res.setFlag(Token::LeadingSpace);
 166
 167       ResultToks.push_back(Res);
 168       MadeChange = true;
 169       ++i;  // Skip arg name.
 170       NextTokGetsSpace = false;
 171       continue;
 172     }
 173
 174     // Otherwise, if this is not an argument token, just add the token to the
 175     // output buffer.
 176     IdentifierInfo *II = CurTok.getIdentifierInfo();
 177     int ArgNo = II ? Macro->getArgumentNum(II) : -1;
 178     if (ArgNo == -1) {
 179       // This isn't an argument, just add it.
 180       ResultToks.push_back(CurTok);
 181
 182       if (NextTokGetsSpace) {
 183         ResultToks.back().setFlag(Token::LeadingSpace);
 184         NextTokGetsSpace = false;
 185       }
 186       continue;
 187     }
 188
 189     // An argument is expanded somehow, the result is different than the
 190     // input.
 191     MadeChange = true;
 192
 193     // Otherwise, this is a use of the argument.  Find out if there is a paste
 194     // (##) operator before or after the argument.
 195     bool PasteBefore =
 196       !ResultToks.empty() && ResultToks.back().is(tok::hashhash);
 197     bool PasteAfter = i+1 != e && Tokens[i+1].is(tok::hashhash);
 198
 199     // If it is not the LHS/RHS of a ## operator, we must pre-expand the
 200     // argument and substitute the expanded tokens into the result.  This is
 201     // C99 6.10.3.1p1.
 202     if (!PasteBefore && !PasteAfter) {
 203       const Token *ResultArgToks;
 204
 205       // Only preexpand the argument if it could possibly need it.  This
 206       // avoids some work in common cases.
 207       const Token *ArgTok = ActualArgs->getUnexpArgument(ArgNo);
 208       if (ActualArgs->ArgNeedsPreexpansion(ArgTok, PP))
 209         ResultArgToks = &ActualArgs->getPreExpArgument(ArgNo, Macro, PP)[0];
 210       else
 211         ResultArgToks = ArgTok;  // Use non-preexpanded tokens.
 212
 213       // If the arg token expanded into anything, append it.
 214       if (ResultArgToks->isNot(tok::eof)) {
 215         unsigned FirstResult = ResultToks.size();
 216         unsigned NumToks = MacroArgs::getArgLength(ResultArgToks);
 217         ResultToks.append(ResultArgToks, ResultArgToks+NumToks);
 218
 219         // If the '##' came from expanding an argument, turn it into 'unknown'
 220         // to avoid pasting.
 221         for (unsigned i = FirstResult, e = ResultToks.size(); i != e; ++i) {
 222           Token &Tok = ResultToks[i];
 223           if (Tok.is(tok::hashhash))
 224             Tok.setKind(tok::unknown);
 225         }
 226
 227         if(ExpandLocStart.isValid()) {
 228           SourceLocation curInst =
 229               getMacroExpansionLocation(CurTok.getLocation());
 230           assert(curInst.isValid() &&
 231                  "Expected arg identifier to come from definition");
 232           for (unsigned i = FirstResult, e = ResultToks.size(); i != e; ++i) {
 233             Token &Tok = ResultToks[i];
 234             Tok.setLocation(SM.createMacroArgInstantiationLoc(Tok.getLocation(),
 235                                                               curInst,
 236                                                               Tok.getLength()));
 237           }
 238         }
 239
 240         // If any tokens were substituted from the argument, the whitespace
 241         // before the first token should match the whitespace of the arg
 242         // identifier.
 243         ResultToks[FirstResult].setFlagValue(Token::LeadingSpace,
 244                                              CurTok.hasLeadingSpace() ||
 245                                              NextTokGetsSpace);
 246         NextTokGetsSpace = false;
 247       } else {
 248         // If this is an empty argument, and if there was whitespace before the
 249         // formal token, make sure the next token gets whitespace before it.
 250         NextTokGetsSpace = CurTok.hasLeadingSpace();
 251       }
 252       continue;
 253     }
 254
 255     // Okay, we have a token that is either the LHS or RHS of a paste (##)
 256     // argument.  It gets substituted as its non-pre-expanded tokens.
 257     const Token *ArgToks = ActualArgs->getUnexpArgument(ArgNo);
 258     unsigned NumToks = MacroArgs::getArgLength(ArgToks);
 259     if (NumToks) {  // Not an empty argument?
 260       // If this is the GNU ", ## __VA_ARG__" extension, and we just learned
 261       // that __VA_ARG__ expands to multiple tokens, avoid a pasting error when
 262       // the expander trys to paste ',' with the first token of the __VA_ARG__
 263       // expansion.
 264       if (PasteBefore && ResultToks.size() >= 2 &&
 265           ResultToks[ResultToks.size()-2].is(tok::comma) &&
 266           (unsigned)ArgNo == Macro->getNumArgs()-1 &&
 267           Macro->isVariadic()) {
 268         // Remove the paste operator, report use of the extension.
 269         PP.Diag(ResultToks.back().getLocation(), diag::ext_paste_comma);
 270         ResultToks.pop_back();
 271       }
 272
 273       ResultToks.append(ArgToks, ArgToks+NumToks);
 274
 275       // If the '##' came from expanding an argument, turn it into 'unknown'
 276       // to avoid pasting.
 277       for (unsigned i = ResultToks.size() - NumToks, e = ResultToks.size();
 278              i != e; ++i) {
 279         Token &Tok = ResultToks[i];
 280         if (Tok.is(tok::hashhash))
 281           Tok.setKind(tok::unknown);
 282       }
 283
 284       if (ExpandLocStart.isValid()) {
 285         SourceLocation curInst =
 286             getMacroExpansionLocation(CurTok.getLocation());
 287         assert(curInst.isValid() &&
 288                "Expected arg identifier to come from definition");
 289         for (unsigned i = ResultToks.size() - NumToks, e = ResultToks.size();
 290                i != e; ++i) {
 291           Token &Tok = ResultToks[i];
 292           Tok.setLocation(SM.createMacroArgInstantiationLoc(Tok.getLocation(),
 293                                                             curInst,
 294                                                             Tok.getLength()));
 295         }
 296       }
 297
 298       // If this token (the macro argument) was supposed to get leading
 299       // whitespace, transfer this information onto the first token of the
 300       // expansion.
 301       //
 302       // Do not do this if the paste operator occurs before the macro argument,
 303       // as in "A ## MACROARG".  In valid code, the first token will get
 304       // smooshed onto the preceding one anyway (forming AMACROARG).  In
 305       // assembler-with-cpp mode, invalid pastes are allowed through: in this
 306       // case, we do not want the extra whitespace to be added.  For example,
 307       // we want ". ## foo" -> ".foo" not ". foo".
 308       if ((CurTok.hasLeadingSpace() || NextTokGetsSpace) &&
 309           !PasteBefore)
 310         ResultToks[ResultToks.size()-NumToks].setFlag(Token::LeadingSpace);
 311
 312       NextTokGetsSpace = false;
 313       continue;
 314     }
 315
 316     // If an empty argument is on the LHS or RHS of a paste, the standard (C99
 317     // 6.10.3.3p2,3) calls for a bunch of placemarker stuff to occur.  We
 318     // implement this by eating ## operators when a LHS or RHS expands to
 319     // empty.
 320     NextTokGetsSpace |= CurTok.hasLeadingSpace();
 321     if (PasteAfter) {
 322       // Discard the argument token and skip (don't copy to the expansion
 323       // buffer) the paste operator after it.
 324       NextTokGetsSpace |= Tokens[i+1].hasLeadingSpace();
 325       ++i;
 326       continue;
 327     }
 328
 329     // If this is on the RHS of a paste operator, we've already copied the
 330     // paste operator to the ResultToks list.  Remove it.
 331     assert(PasteBefore && ResultToks.back().is(tok::hashhash));
 332     NextTokGetsSpace |= ResultToks.back().hasLeadingSpace();
 333     ResultToks.pop_back();
 334
 335     // If this is the __VA_ARGS__ token, and if the argument wasn't provided,
 336     // and if the macro had at least one real argument, and if the token before
 337     // the ## was a comma, remove the comma.
 338     if ((unsigned)ArgNo == Macro->getNumArgs()-1 && // is __VA_ARGS__
 339         ActualArgs->isVarargsElidedUse() &&       // Argument elided.
 340         !ResultToks.empty() && ResultToks.back().is(tok::comma)) {
 341       // Never add a space, even if the comma, ##, or arg had a space.
 342       NextTokGetsSpace = false;
 343       // Remove the paste operator, report use of the extension.
 344       PP.Diag(ResultToks.back().getLocation(), diag::ext_paste_comma);
 345       ResultToks.pop_back();
 346
 347       // If the comma was right after another paste (e.g. "X##,##__VA_ARGS__"),
 348       // then removal of the comma should produce a placemarker token (in C99
 349       // terms) which we model by popping off the previous ##, giving us a plain
 350       // "X" when __VA_ARGS__ is empty.
 351       if (!ResultToks.empty() && ResultToks.back().is(tok::hashhash))
 352         ResultToks.pop_back();
 353     }
 354     continue;
 355   }
 356
 357   // If anything changed, install this as the new Tokens list.
 358   if (MadeChange) {
 359     assert(!OwnsTokens && "This would leak if we already own the token list");
 360     // This is deleted in the dtor.
 361     NumTokens = ResultToks.size();
 362     // The tokens will be added to Preprocessor's cache and will be removed
 363     // when this TokenLexer finishes lexing them.
 364     Tokens = PP.cacheMacroExpandedTokens(this, ResultToks);
 365
 366     // The preprocessor cache of macro expanded tokens owns these tokens,not us.
 367     OwnsTokens = false;
 368   }
 369 }
 370
 371 /// Lex - Lex and return a token from this macro stream.
 372 ///
 373 void TokenLexer::Lex(Token &Tok) {
 374   // Lexing off the end of the macro, pop this macro off the expansion stack.
 375   if (isAtEnd()) {
 376     // If this is a macro (not a token stream), mark the macro enabled now
 377     // that it is no longer being expanded.
 378     if (Macro) Macro->EnableMacro();
 379
 380     // Pop this context off the preprocessors lexer stack and get the next
 381     // token.  This will delete "this" so remember the PP instance var.
 382     Preprocessor &PPCache = PP;
 383     if (PP.HandleEndOfTokenLexer(Tok))
 384       return;
 385
 386     // HandleEndOfTokenLexer may not return a token.  If it doesn't, lex
 387     // whatever is next.
 388     return PPCache.Lex(Tok);
 389   }
 390
 391   SourceManager &SM = PP.getSourceManager();
 392
 393   // If this is the first token of the expanded result, we inherit spacing
 394   // properties later.
 395   bool isFirstToken = CurToken == 0;
 396
 397   // Get the next token to return.
 398   Tok = Tokens[CurToken++];
 399
 400   bool TokenIsFromPaste = false;
 401
 402   // If this token is followed by a token paste (##) operator, paste the tokens!
 403   // Note that ## is a normal token when not expanding a macro.
 404   if (!isAtEnd() && Tokens[CurToken].is(tok::hashhash) && Macro) {
 405     // When handling the microsoft /##/ extension, the final token is
 406     // returned by PasteTokens, not the pasted token.
 407     if (PasteTokens(Tok))
 408       return;
 409
 410     TokenIsFromPaste = true;
 411   }
 412
 413   // The token's current location indicate where the token was lexed from.  We
 414   // need this information to compute the spelling of the token, but any
 415   // diagnostics for the expanded token should appear as if they came from
 416   // ExpansionLoc.  Pull this information together into a new SourceLocation
 417   // that captures all of this.
 418   if (ExpandLocStart.isValid() &&   // Don't do this for token streams.
 419       // Check that the token's location was not already set properly.
 420       SM.isBeforeInSourceLocationOffset(Tok.getLocation(),
 421                                         MacroStartSLocOffset)) {
 422     SourceLocation instLoc;
 423     if (Tok.is(tok::comment)) {
 424       instLoc = SM.createInstantiationLoc(Tok.getLocation(),
 425                                           ExpandLocStart,
 426                                           ExpandLocEnd,
 427                                           Tok.getLength());
 428     } else {
 429       instLoc = getMacroExpansionLocation(Tok.getLocation());
 430       assert(instLoc.isValid() &&
 431              "Location for token not coming from definition was not set!");
 432     }
 433
 434     Tok.setLocation(instLoc);
 435   }
 436
 437   // If this is the first token, set the lexical properties of the token to
 438   // match the lexical properties of the macro identifier.
 439   if (isFirstToken) {
 440     Tok.setFlagValue(Token::StartOfLine , AtStartOfLine);
 441     Tok.setFlagValue(Token::LeadingSpace, HasLeadingSpace);
 442   }
 443
 444   // Handle recursive expansion!
 445   if (!Tok.isAnnotation() && Tok.getIdentifierInfo() != 0) {
 446     // Change the kind of this identifier to the appropriate token kind, e.g.
 447     // turning "for" into a keyword.
 448     IdentifierInfo *II = Tok.getIdentifierInfo();
 449     Tok.setKind(II->getTokenID());
 450
 451     // If this identifier was poisoned and from a paste, emit an error.  This
 452     // won't be handled by Preprocessor::HandleIdentifier because this is coming
 453     // from a macro expansion.
 454     if (II->isPoisoned() && TokenIsFromPaste) {
 455       PP.HandlePoisonedIdentifier(Tok);
 456     }
 457
 458     if (!DisableMacroExpansion && II->isHandleIdentifierCase())
 459       PP.HandleIdentifier(Tok);
 460   }
 461
 462   // Otherwise, return a normal token.
 463 }
 464
 465 /// PasteTokens - Tok is the LHS of a ## operator, and CurToken is the ##
 466 /// operator.  Read the ## and RHS, and paste the LHS/RHS together.  If there
 467 /// are more ## after it, chomp them iteratively.  Return the result as Tok.
 468 /// If this returns true, the caller should immediately return the token.
 469 bool TokenLexer::PasteTokens(Token &Tok) {
 470   llvm::SmallString<128> Buffer;
 471   const char *ResultTokStrPtr = 0;
 472   SourceLocation PasteOpLoc;
 473   do {
 474     // Consume the ## operator.
 475     PasteOpLoc = Tokens[CurToken].getLocation();
 476     ++CurToken;
 477     assert(!isAtEnd() && "No token on the RHS of a paste operator!");
 478
 479     // Get the RHS token.
 480     const Token &RHS = Tokens[CurToken];
 481
 482     // Allocate space for the result token.  This is guaranteed to be enough for
 483     // the two tokens.
 484     Buffer.resize(Tok.getLength() + RHS.getLength());
 485
 486     // Get the spelling of the LHS token in Buffer.
 487     const char *BufPtr = &Buffer[0];
 488     bool Invalid = false;
 489     unsigned LHSLen = PP.getSpelling(Tok, BufPtr, &Invalid);
 490     if (BufPtr != &Buffer[0])   // Really, we want the chars in Buffer!
 491       memcpy(&Buffer[0], BufPtr, LHSLen);
 492     if (Invalid)
 493       return true;
 494
 495     BufPtr = &Buffer[LHSLen];
 496     unsigned RHSLen = PP.getSpelling(RHS, BufPtr, &Invalid);
 497     if (Invalid)
 498       return true;
 499     if (BufPtr != &Buffer[LHSLen])   // Really, we want the chars in Buffer!
 500       memcpy(&Buffer[LHSLen], BufPtr, RHSLen);
 501
 502     // Trim excess space.
 503     Buffer.resize(LHSLen+RHSLen);
 504
 505     // Plop the pasted result (including the trailing newline and null) into a
 506     // scratch buffer where we can lex it.
 507     Token ResultTokTmp;
 508     ResultTokTmp.startToken();
 509
 510     // Claim that the tmp token is a string_literal so that we can get the
 511     // character pointer back from CreateString in getLiteralData().
 512     ResultTokTmp.setKind(tok::string_literal);
 513     PP.CreateString(&Buffer[0], Buffer.size(), ResultTokTmp);
 514     SourceLocation ResultTokLoc = ResultTokTmp.getLocation();
 515     ResultTokStrPtr = ResultTokTmp.getLiteralData();
 516
 517     // Lex the resultant pasted token into Result.
 518     Token Result;
 519
 520     if (Tok.isAnyIdentifier() && RHS.isAnyIdentifier()) {
 521       // Common paste case: identifier+identifier = identifier.  Avoid creating
 522       // a lexer and other overhead.
 523       PP.IncrementPasteCounter(true);
 524       Result.startToken();
 525       Result.setKind(tok::raw_identifier);
 526       Result.setRawIdentifierData(ResultTokStrPtr);
 527       Result.setLocation(ResultTokLoc);
 528       Result.setLength(LHSLen+RHSLen);
 529     } else {
 530       PP.IncrementPasteCounter(false);
 531
 532       assert(ResultTokLoc.isFileID() &&
 533              "Should be a raw location into scratch buffer");
 534       SourceManager &SourceMgr = PP.getSourceManager();
 535       FileID LocFileID = SourceMgr.getFileID(ResultTokLoc);
 536
 537       bool Invalid = false;
 538       const char *ScratchBufStart
 539         = SourceMgr.getBufferData(LocFileID, &Invalid).data();
 540       if (Invalid)
 541         return false;
 542
 543       // Make a lexer to lex this string from.  Lex just this one token.
 544       // Make a lexer object so that we lex and expand the paste result.
 545       Lexer TL(SourceMgr.getLocForStartOfFile(LocFileID),
 546                PP.getLangOptions(), ScratchBufStart,
 547                ResultTokStrPtr, ResultTokStrPtr+LHSLen+RHSLen);
 548
 549       // Lex a token in raw mode.  This way it won't look up identifiers
 550       // automatically, lexing off the end will return an eof token, and
 551       // warnings are disabled.  This returns true if the result token is the
 552       // entire buffer.
 553       bool isInvalid = !TL.LexFromRawLexer(Result);
 554
 555       // If we got an EOF token, we didn't form even ONE token.  For example, we
 556       // did "/ ## /" to get "//".
 557       isInvalid |= Result.is(tok::eof);
 558
 559       // If pasting the two tokens didn't form a full new token, this is an
 560       // error.  This occurs with "x ## +"  and other stuff.  Return with Tok
 561       // unmodified and with RHS as the next token to lex.
 562       if (isInvalid) {
 563         // Test for the Microsoft extension of /##/ turning into // here on the
 564         // error path.
 565         if (PP.getLangOptions().Microsoft && Tok.is(tok::slash) &&
 566             RHS.is(tok::slash)) {
 567           HandleMicrosoftCommentPaste(Tok);
 568           return true;
 569         }
 570
 571         // Do not emit the error when preprocessing assembler code.
 572         if (!PP.getLangOptions().AsmPreprocessor) {
 573           // Explicitly convert the token location to have proper expansion
 574           // information so that the user knows where it came from.
 575           SourceManager &SM = PP.getSourceManager();
 576           SourceLocation Loc =
 577             SM.createInstantiationLoc(PasteOpLoc, ExpandLocStart,
 578                                       ExpandLocEnd, 2);
 579           // If we're in microsoft extensions mode, downgrade this from a hard
 580           // error to a warning that defaults to an error.  This allows
 581           // disabling it.
 582           PP.Diag(Loc,
 583                   PP.getLangOptions().Microsoft ? diag::err_pp_bad_paste_ms
 584                                                 : diag::err_pp_bad_paste)
 585             << Buffer.str();
 586         }
 587
 588         // Do not consume the RHS.
 589         --CurToken;
 590       }
 591
 592       // Turn ## into 'unknown' to avoid # ## # from looking like a paste
 593       // operator.
 594       if (Result.is(tok::hashhash))
 595         Result.setKind(tok::unknown);
 596     }
 597
 598     // Transfer properties of the LHS over the the Result.
 599     Result.setFlagValue(Token::StartOfLine , Tok.isAtStartOfLine());
 600     Result.setFlagValue(Token::LeadingSpace, Tok.hasLeadingSpace());
 601
 602     // Finally, replace LHS with the result, consume the RHS, and iterate.
 603     ++CurToken;
 604     Tok = Result;
 605   } while (!isAtEnd() && Tokens[CurToken].is(tok::hashhash));
 606
 607   // The token's current location indicate where the token was lexed from.  We
 608   // need this information to compute the spelling of the token, but any
 609   // diagnostics for the expanded token should appear as if the token was
 610   // expanded from the (##) operator. Pull this information together into
 611   // a new SourceLocation that captures all of this.
 612   if (ExpandLocStart.isValid()) {
 613     SourceManager &SM = PP.getSourceManager();
 614     SourceLocation pasteLocInst =
 615         getMacroExpansionLocation(PasteOpLoc);
 616     assert(pasteLocInst.isValid() &&
 617            "Expected '##' to come from definition");
 618
 619     Tok.setLocation(SM.createInstantiationLoc(Tok.getLocation(),
 620                                               pasteLocInst,
 621                                               pasteLocInst,
 622                                               Tok.getLength()));
 623   }
 624
 625   // Now that we got the result token, it will be subject to expansion.  Since
 626   // token pasting re-lexes the result token in raw mode, identifier information
 627   // isn't looked up.  As such, if the result is an identifier, look up id info.
 628   if (Tok.is(tok::raw_identifier)) {
 629     // Look up the identifier info for the token.  We disabled identifier lookup
 630     // by saying we're skipping contents, so we need to do this manually.
 631     PP.LookUpIdentifierInfo(Tok);
 632   }
 633   return false;
 634 }
 635
 636 /// isNextTokenLParen - If the next token lexed will pop this macro off the
 637 /// expansion stack, return 2.  If the next unexpanded token is a '(', return
 638 /// 1, otherwise return 0.
 639 unsigned TokenLexer::isNextTokenLParen() const {
 640   // Out of tokens?
 641   if (isAtEnd())
 642     return 2;
 643   return Tokens[CurToken].is(tok::l_paren);
 644 }
 645
 646 /// isParsingPreprocessorDirective - Return true if we are in the middle of a
 647 /// preprocessor directive.
 648 bool TokenLexer::isParsingPreprocessorDirective() const {
 649   return Tokens[NumTokens-1].is(tok::eod) && !isAtEnd();
 650 }
 651
 652 /// HandleMicrosoftCommentPaste - In microsoft compatibility mode, /##/ pastes
 653 /// together to form a comment that comments out everything in the current
 654 /// macro, other active macros, and anything left on the current physical
 655 /// source line of the expanded buffer.  Handle this by returning the
 656 /// first token on the next line.
 657 void TokenLexer::HandleMicrosoftCommentPaste(Token &Tok) {
 658   // We 'comment out' the rest of this macro by just ignoring the rest of the
 659   // tokens that have not been lexed yet, if any.
 660
 661   // Since this must be a macro, mark the macro enabled now that it is no longer
 662   // being expanded.
 663   assert(Macro && "Token streams can't paste comments");
 664   Macro->EnableMacro();
 665
 666   PP.HandleMicrosoftCommentPaste(Tok);
 667 }
 668
 669 /// \brief If \arg loc is a FileID and points inside the current macro
 670 /// definition, returns the appropriate source location pointing at the
 671 /// macro expansion source location entry.
 672 SourceLocation TokenLexer::getMacroExpansionLocation(SourceLocation loc) const {
 673   assert(ExpandLocStart.isValid() && MacroExpansionStart.isValid() &&
 674          "Not appropriate for token streams");
 675   assert(loc.isValid());
 676
 677   SourceManager &SM = PP.getSourceManager();
 678   unsigned relativeOffset;
 679   if (loc.isFileID() &&
 680       SM.isInFileID(loc,
 681                     MacroDefStartInfo.first, MacroDefStartInfo.second,
 682                     Macro->getDefinitionLength(SM), &relativeOffset)) {
 683     return MacroExpansionStart.getFileLocWithOffset(relativeOffset);
 684   }
 685
 686   return SourceLocation();
 687 }