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 ILEnd, 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   InstantiateLocStart = Tok.getLocation();
  36   InstantiateLocEnd = ILEnd;
  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
  44   // If this is a function-like macro, expand the arguments and change
  45   // Tokens to point to the expanded tokens.
  46   if (Macro->isFunctionLike() && Macro->getNumArgs())
  47     ExpandFunctionArguments();
  48
  49   // Mark the macro as currently disabled, so that it is not recursively
  50   // expanded.  The macro must be disabled only after argument pre-expansion of
  51   // function-like macro arguments occurs.
  52   Macro->DisableMacro();
  53 }
  54
  55
  56
  57 /// Create a TokenLexer for the specified token stream.  This does not
  58 /// take ownership of the specified token vector.
  59 void TokenLexer::Init(const Token *TokArray, unsigned NumToks,
  60                       bool disableMacroExpansion, bool ownsTokens) {
  61   // If the client is reusing a TokenLexer, make sure to free any memory
  62   // associated with it.
  63   destroy();
  64
  65   Macro = 0;
  66   ActualArgs = 0;
  67   Tokens = TokArray;
  68   OwnsTokens = ownsTokens;
  69   DisableMacroExpansion = disableMacroExpansion;
  70   NumTokens = NumToks;
  71   CurToken = 0;
  72   InstantiateLocStart = InstantiateLocEnd = SourceLocation();
  73   AtStartOfLine = false;
  74   HasLeadingSpace = false;
  75
  76   // Set HasLeadingSpace/AtStartOfLine so that the first token will be
  77   // returned unmodified.
  78   if (NumToks != 0) {
  79     AtStartOfLine   = TokArray[0].isAtStartOfLine();
  80     HasLeadingSpace = TokArray[0].hasLeadingSpace();
  81   }
  82 }
  83
  84
  85 void TokenLexer::destroy() {
  86   // If this was a function-like macro that actually uses its arguments, delete
  87   // the expanded tokens.
  88   if (OwnsTokens) {
  89     delete [] Tokens;
  90     Tokens = 0;
  91     OwnsTokens = false;
  92   }
  93
  94   // TokenLexer owns its formal arguments.
  95   if (ActualArgs) ActualArgs->destroy(PP);
  96 }
  97
  98 /// Expand the arguments of a function-like macro so that we can quickly
  99 /// return preexpanded tokens from Tokens.
 100 void TokenLexer::ExpandFunctionArguments() {
 101   llvm::SmallVector<Token, 128> ResultToks;
 102
 103   // Loop through 'Tokens', expanding them into ResultToks.  Keep
 104   // track of whether we change anything.  If not, no need to keep them.  If so,
 105   // we install the newly expanded sequence as the new 'Tokens' list.
 106   bool MadeChange = false;
 107
 108   // NextTokGetsSpace - When this is true, the next token appended to the
 109   // output list will get a leading space, regardless of whether it had one to
 110   // begin with or not.  This is used for placemarker support.
 111   bool NextTokGetsSpace = false;
 112
 113   for (unsigned i = 0, e = NumTokens; i != e; ++i) {
 114     // If we found the stringify operator, get the argument stringified.  The
 115     // preprocessor already verified that the following token is a macro name
 116     // when the #define was parsed.
 117     const Token &CurTok = Tokens[i];
 118     if (CurTok.is(tok::hash) || CurTok.is(tok::hashat)) {
 119       int ArgNo = Macro->getArgumentNum(Tokens[i+1].getIdentifierInfo());
 120       assert(ArgNo != -1 && "Token following # is not an argument?");
 121
 122       Token Res;
 123       if (CurTok.is(tok::hash))  // Stringify
 124         Res = ActualArgs->getStringifiedArgument(ArgNo, PP);
 125       else {
 126         // 'charify': don't bother caching these.
 127         Res = MacroArgs::StringifyArgument(ActualArgs->getUnexpArgument(ArgNo),
 128                                            PP, true);
 129       }
 130
 131       // The stringified/charified string leading space flag gets set to match
 132       // the #/#@ operator.
 133       if (CurTok.hasLeadingSpace() || NextTokGetsSpace)
 134         Res.setFlag(Token::LeadingSpace);
 135
 136       ResultToks.push_back(Res);
 137       MadeChange = true;
 138       ++i;  // Skip arg name.
 139       NextTokGetsSpace = false;
 140       continue;
 141     }
 142
 143     // Otherwise, if this is not an argument token, just add the token to the
 144     // output buffer.
 145     IdentifierInfo *II = CurTok.getIdentifierInfo();
 146     int ArgNo = II ? Macro->getArgumentNum(II) : -1;
 147     if (ArgNo == -1) {
 148       // This isn't an argument, just add it.
 149       ResultToks.push_back(CurTok);
 150
 151       if (NextTokGetsSpace) {
 152         ResultToks.back().setFlag(Token::LeadingSpace);
 153         NextTokGetsSpace = false;
 154       }
 155       continue;
 156     }
 157
 158     // An argument is expanded somehow, the result is different than the
 159     // input.
 160     MadeChange = true;
 161
 162     // Otherwise, this is a use of the argument.  Find out if there is a paste
 163     // (##) operator before or after the argument.
 164     bool PasteBefore =
 165       !ResultToks.empty() && ResultToks.back().is(tok::hashhash);
 166     bool PasteAfter = i+1 != e && Tokens[i+1].is(tok::hashhash);
 167
 168     // If it is not the LHS/RHS of a ## operator, we must pre-expand the
 169     // argument and substitute the expanded tokens into the result.  This is
 170     // C99 6.10.3.1p1.
 171     if (!PasteBefore && !PasteAfter) {
 172       const Token *ResultArgToks;
 173
 174       // Only preexpand the argument if it could possibly need it.  This
 175       // avoids some work in common cases.
 176       const Token *ArgTok = ActualArgs->getUnexpArgument(ArgNo);
 177       if (ActualArgs->ArgNeedsPreexpansion(ArgTok, PP))
 178         ResultArgToks = &ActualArgs->getPreExpArgument(ArgNo, Macro, PP)[0];
 179       else
 180         ResultArgToks = ArgTok;  // Use non-preexpanded tokens.
 181
 182       // If the arg token expanded into anything, append it.
 183       if (ResultArgToks->isNot(tok::eof)) {
 184         unsigned FirstResult = ResultToks.size();
 185         unsigned NumToks = MacroArgs::getArgLength(ResultArgToks);
 186         ResultToks.append(ResultArgToks, ResultArgToks+NumToks);
 187
 188         // If any tokens were substituted from the argument, the whitespace
 189         // before the first token should match the whitespace of the arg
 190         // identifier.
 191         ResultToks[FirstResult].setFlagValue(Token::LeadingSpace,
 192                                              CurTok.hasLeadingSpace() ||
 193                                              NextTokGetsSpace);
 194         NextTokGetsSpace = false;
 195       } else {
 196         // If this is an empty argument, and if there was whitespace before the
 197         // formal token, make sure the next token gets whitespace before it.
 198         NextTokGetsSpace = CurTok.hasLeadingSpace();
 199       }
 200       continue;
 201     }
 202
 203     // Okay, we have a token that is either the LHS or RHS of a paste (##)
 204     // argument.  It gets substituted as its non-pre-expanded tokens.
 205     const Token *ArgToks = ActualArgs->getUnexpArgument(ArgNo);
 206     unsigned NumToks = MacroArgs::getArgLength(ArgToks);
 207     if (NumToks) {  // Not an empty argument?
 208       // If this is the GNU ", ## __VA_ARG__" extension, and we just learned
 209       // that __VA_ARG__ expands to multiple tokens, avoid a pasting error when
 210       // the expander trys to paste ',' with the first token of the __VA_ARG__
 211       // expansion.
 212       if (PasteBefore && ResultToks.size() >= 2 &&
 213           ResultToks[ResultToks.size()-2].is(tok::comma) &&
 214           (unsigned)ArgNo == Macro->getNumArgs()-1 &&
 215           Macro->isVariadic()) {
 216         // Remove the paste operator, report use of the extension.
 217         PP.Diag(ResultToks.back().getLocation(), diag::ext_paste_comma);
 218         ResultToks.pop_back();
 219       }
 220
 221       ResultToks.append(ArgToks, ArgToks+NumToks);
 222
 223       // If this token (the macro argument) was supposed to get leading
 224       // whitespace, transfer this information onto the first token of the
 225       // expansion.
 226       //
 227       // Do not do this if the paste operator occurs before the macro argument,
 228       // as in "A ## MACROARG".  In valid code, the first token will get
 229       // smooshed onto the preceding one anyway (forming AMACROARG).  In
 230       // assembler-with-cpp mode, invalid pastes are allowed through: in this
 231       // case, we do not want the extra whitespace to be added.  For example,
 232       // we want ". ## foo" -> ".foo" not ". foo".
 233       if ((CurTok.hasLeadingSpace() || NextTokGetsSpace) &&
 234           !PasteBefore)
 235         ResultToks[ResultToks.size()-NumToks].setFlag(Token::LeadingSpace);
 236
 237       NextTokGetsSpace = false;
 238       continue;
 239     }
 240
 241     // If an empty argument is on the LHS or RHS of a paste, the standard (C99
 242     // 6.10.3.3p2,3) calls for a bunch of placemarker stuff to occur.  We
 243     // implement this by eating ## operators when a LHS or RHS expands to
 244     // empty.
 245     NextTokGetsSpace |= CurTok.hasLeadingSpace();
 246     if (PasteAfter) {
 247       // Discard the argument token and skip (don't copy to the expansion
 248       // buffer) the paste operator after it.
 249       NextTokGetsSpace |= Tokens[i+1].hasLeadingSpace();
 250       ++i;
 251       continue;
 252     }
 253
 254     // If this is on the RHS of a paste operator, we've already copied the
 255     // paste operator to the ResultToks list.  Remove it.
 256     assert(PasteBefore && ResultToks.back().is(tok::hashhash));
 257     NextTokGetsSpace |= ResultToks.back().hasLeadingSpace();
 258     ResultToks.pop_back();
 259
 260     // If this is the __VA_ARGS__ token, and if the argument wasn't provided,
 261     // and if the macro had at least one real argument, and if the token before
 262     // the ## was a comma, remove the comma.
 263     if ((unsigned)ArgNo == Macro->getNumArgs()-1 && // is __VA_ARGS__
 264         ActualArgs->isVarargsElidedUse() &&       // Argument elided.
 265         !ResultToks.empty() && ResultToks.back().is(tok::comma)) {
 266       // Never add a space, even if the comma, ##, or arg had a space.
 267       NextTokGetsSpace = false;
 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     continue;
 273   }
 274
 275   // If anything changed, install this as the new Tokens list.
 276   if (MadeChange) {
 277     assert(!OwnsTokens && "This would leak if we already own the token list");
 278     // This is deleted in the dtor.
 279     NumTokens = ResultToks.size();
 280     llvm::BumpPtrAllocator &Alloc = PP.getPreprocessorAllocator();
 281     Token *Res =
 282       static_cast<Token *>(Alloc.Allocate(sizeof(Token)*ResultToks.size(),
 283                                           llvm::alignof<Token>()));
 284     if (NumTokens)
 285       memcpy(Res, &ResultToks[0], NumTokens*sizeof(Token));
 286     Tokens = Res;
 287
 288     // The preprocessor bump pointer owns these tokens, not us.
 289     OwnsTokens = false;
 290   }
 291 }
 292
 293 /// Lex - Lex and return a token from this macro stream.
 294 ///
 295 void TokenLexer::Lex(Token &Tok) {
 296   // Lexing off the end of the macro, pop this macro off the expansion stack.
 297   if (isAtEnd()) {
 298     // If this is a macro (not a token stream), mark the macro enabled now
 299     // that it is no longer being expanded.
 300     if (Macro) Macro->EnableMacro();
 301
 302     // Pop this context off the preprocessors lexer stack and get the next
 303     // token.  This will delete "this" so remember the PP instance var.
 304     Preprocessor &PPCache = PP;
 305     if (PP.HandleEndOfTokenLexer(Tok))
 306       return;
 307
 308     // HandleEndOfTokenLexer may not return a token.  If it doesn't, lex
 309     // whatever is next.
 310     return PPCache.Lex(Tok);
 311   }
 312
 313   // If this is the first token of the expanded result, we inherit spacing
 314   // properties later.
 315   bool isFirstToken = CurToken == 0;
 316
 317   // Get the next token to return.
 318   Tok = Tokens[CurToken++];
 319
 320   bool TokenIsFromPaste = false;
 321
 322   // If this token is followed by a token paste (##) operator, paste the tokens!
 323   if (!isAtEnd() && Tokens[CurToken].is(tok::hashhash)) {
 324     // When handling the microsoft /##/ extension, the final token is
 325     // returned by PasteTokens, not the pasted token.
 326     if (PasteTokens(Tok))
 327       return;
 328
 329     TokenIsFromPaste = true;
 330   }
 331
 332   // The token's current location indicate where the token was lexed from.  We
 333   // need this information to compute the spelling of the token, but any
 334   // diagnostics for the expanded token should appear as if they came from
 335   // InstantiationLoc.  Pull this information together into a new SourceLocation
 336   // that captures all of this.
 337   if (InstantiateLocStart.isValid()) {   // Don't do this for token streams.
 338     SourceManager &SM = PP.getSourceManager();
 339     Tok.setLocation(SM.createInstantiationLoc(Tok.getLocation(),
 340                                               InstantiateLocStart,
 341                                               InstantiateLocEnd,
 342                                               Tok.getLength()));
 343   }
 344
 345   // If this is the first token, set the lexical properties of the token to
 346   // match the lexical properties of the macro identifier.
 347   if (isFirstToken) {
 348     Tok.setFlagValue(Token::StartOfLine , AtStartOfLine);
 349     Tok.setFlagValue(Token::LeadingSpace, HasLeadingSpace);
 350   }
 351
 352   // Handle recursive expansion!
 353   if (!Tok.isAnnotation() && Tok.getIdentifierInfo() != 0) {
 354     // Change the kind of this identifier to the appropriate token kind, e.g.
 355     // turning "for" into a keyword.
 356     IdentifierInfo *II = Tok.getIdentifierInfo();
 357     Tok.setKind(II->getTokenID());
 358
 359     // If this identifier was poisoned and from a paste, emit an error.  This
 360     // won't be handled by Preprocessor::HandleIdentifier because this is coming
 361     // from a macro expansion.
 362     if (II->isPoisoned() && TokenIsFromPaste) {
 363       // We warn about __VA_ARGS__ with poisoning.
 364       if (II->isStr("__VA_ARGS__"))
 365         PP.Diag(Tok, diag::ext_pp_bad_vaargs_use);
 366       else
 367         PP.Diag(Tok, diag::err_pp_used_poisoned_id);
 368     }
 369
 370     if (!DisableMacroExpansion && II->isHandleIdentifierCase())
 371       PP.HandleIdentifier(Tok);
 372   }
 373
 374   // Otherwise, return a normal token.
 375 }
 376
 377 /// PasteTokens - Tok is the LHS of a ## operator, and CurToken is the ##
 378 /// operator.  Read the ## and RHS, and paste the LHS/RHS together.  If there
 379 /// are more ## after it, chomp them iteratively.  Return the result as Tok.
 380 /// If this returns true, the caller should immediately return the token.
 381 bool TokenLexer::PasteTokens(Token &Tok) {
 382   llvm::SmallString<128> Buffer;
 383   const char *ResultTokStrPtr = 0;
 384   do {
 385     // Consume the ## operator.
 386     SourceLocation PasteOpLoc = Tokens[CurToken].getLocation();
 387     ++CurToken;
 388     assert(!isAtEnd() && "No token on the RHS of a paste operator!");
 389
 390     // Get the RHS token.
 391     const Token &RHS = Tokens[CurToken];
 392
 393     // Allocate space for the result token.  This is guaranteed to be enough for
 394     // the two tokens.
 395     Buffer.resize(Tok.getLength() + RHS.getLength());
 396
 397     // Get the spelling of the LHS token in Buffer.
 398     const char *BufPtr = &Buffer[0];
 399     unsigned LHSLen = PP.getSpelling(Tok, BufPtr);
 400     if (BufPtr != &Buffer[0])   // Really, we want the chars in Buffer!
 401       memcpy(&Buffer[0], BufPtr, LHSLen);
 402
 403     BufPtr = &Buffer[LHSLen];
 404     unsigned RHSLen = PP.getSpelling(RHS, BufPtr);
 405     if (BufPtr != &Buffer[LHSLen])   // Really, we want the chars in Buffer!
 406       memcpy(&Buffer[LHSLen], BufPtr, RHSLen);
 407
 408     // Trim excess space.
 409     Buffer.resize(LHSLen+RHSLen);
 410
 411     // Plop the pasted result (including the trailing newline and null) into a
 412     // scratch buffer where we can lex it.
 413     Token ResultTokTmp;
 414     ResultTokTmp.startToken();
 415
 416     // Claim that the tmp token is a string_literal so that we can get the
 417     // character pointer back from CreateString in getLiteralData().
 418     ResultTokTmp.setKind(tok::string_literal);
 419     PP.CreateString(&Buffer[0], Buffer.size(), ResultTokTmp);
 420     SourceLocation ResultTokLoc = ResultTokTmp.getLocation();
 421     ResultTokStrPtr = ResultTokTmp.getLiteralData();
 422
 423     // Lex the resultant pasted token into Result.
 424     Token Result;
 425
 426     if (Tok.is(tok::identifier) && RHS.is(tok::identifier)) {
 427       // Common paste case: identifier+identifier = identifier.  Avoid creating
 428       // a lexer and other overhead.
 429       PP.IncrementPasteCounter(true);
 430       Result.startToken();
 431       Result.setKind(tok::identifier);
 432       Result.setLocation(ResultTokLoc);
 433       Result.setLength(LHSLen+RHSLen);
 434     } else {
 435       PP.IncrementPasteCounter(false);
 436
 437       assert(ResultTokLoc.isFileID() &&
 438              "Should be a raw location into scratch buffer");
 439       SourceManager &SourceMgr = PP.getSourceManager();
 440       FileID LocFileID = SourceMgr.getFileID(ResultTokLoc);
 441
 442       bool Invalid = false;
 443       const char *ScratchBufStart
 444         = SourceMgr.getBufferData(LocFileID, &Invalid).data();
 445       if (Invalid)
 446         return false;
 447
 448       // Make a lexer to lex this string from.  Lex just this one token.
 449       // Make a lexer object so that we lex and expand the paste result.
 450       Lexer TL(SourceMgr.getLocForStartOfFile(LocFileID),
 451                PP.getLangOptions(), ScratchBufStart,
 452                ResultTokStrPtr, ResultTokStrPtr+LHSLen+RHSLen);
 453
 454       // Lex a token in raw mode.  This way it won't look up identifiers
 455       // automatically, lexing off the end will return an eof token, and
 456       // warnings are disabled.  This returns true if the result token is the
 457       // entire buffer.
 458       bool isInvalid = !TL.LexFromRawLexer(Result);
 459
 460       // If we got an EOF token, we didn't form even ONE token.  For example, we
 461       // did "/ ## /" to get "//".
 462       isInvalid |= Result.is(tok::eof);
 463
 464       // If pasting the two tokens didn't form a full new token, this is an
 465       // error.  This occurs with "x ## +"  and other stuff.  Return with Tok
 466       // unmodified and with RHS as the next token to lex.
 467       if (isInvalid) {
 468         // Test for the Microsoft extension of /##/ turning into // here on the
 469         // error path.
 470         if (PP.getLangOptions().Microsoft && Tok.is(tok::slash) &&
 471             RHS.is(tok::slash)) {
 472           HandleMicrosoftCommentPaste(Tok);
 473           return true;
 474         }
 475
 476         // Do not emit the warning when preprocessing assembler code.
 477         if (!PP.getLangOptions().AsmPreprocessor) {
 478           // Explicitly convert the token location to have proper instantiation
 479           // information so that the user knows where it came from.
 480           SourceManager &SM = PP.getSourceManager();
 481           SourceLocation Loc =
 482             SM.createInstantiationLoc(PasteOpLoc, InstantiateLocStart,
 483                                       InstantiateLocEnd, 2);
 484           PP.Diag(Loc, diag::err_pp_bad_paste)
 485             << std::string(Buffer.begin(), Buffer.end());
 486         }
 487
 488         // Do not consume the RHS.
 489         --CurToken;
 490       }
 491
 492       // Turn ## into 'unknown' to avoid # ## # from looking like a paste
 493       // operator.
 494       if (Result.is(tok::hashhash))
 495         Result.setKind(tok::unknown);
 496     }
 497
 498     // Transfer properties of the LHS over the the Result.
 499     Result.setFlagValue(Token::StartOfLine , Tok.isAtStartOfLine());
 500     Result.setFlagValue(Token::LeadingSpace, Tok.hasLeadingSpace());
 501
 502     // Finally, replace LHS with the result, consume the RHS, and iterate.
 503     ++CurToken;
 504     Tok = Result;
 505   } while (!isAtEnd() && Tokens[CurToken].is(tok::hashhash));
 506
 507   // Now that we got the result token, it will be subject to expansion.  Since
 508   // token pasting re-lexes the result token in raw mode, identifier information
 509   // isn't looked up.  As such, if the result is an identifier, look up id info.
 510   if (Tok.is(tok::identifier)) {
 511     // Look up the identifier info for the token.  We disabled identifier lookup
 512     // by saying we're skipping contents, so we need to do this manually.
 513     PP.LookUpIdentifierInfo(Tok, ResultTokStrPtr);
 514   }
 515   return false;
 516 }
 517
 518 /// isNextTokenLParen - If the next token lexed will pop this macro off the
 519 /// expansion stack, return 2.  If the next unexpanded token is a '(', return
 520 /// 1, otherwise return 0.
 521 unsigned TokenLexer::isNextTokenLParen() const {
 522   // Out of tokens?
 523   if (isAtEnd())
 524     return 2;
 525   return Tokens[CurToken].is(tok::l_paren);
 526 }
 527
 528
 529 /// HandleMicrosoftCommentPaste - In microsoft compatibility mode, /##/ pastes
 530 /// together to form a comment that comments out everything in the current
 531 /// macro, other active macros, and anything left on the current physical
 532 /// source line of the instantiated buffer.  Handle this by returning the
 533 /// first token on the next line.
 534 void TokenLexer::HandleMicrosoftCommentPaste(Token &Tok) {
 535   // We 'comment out' the rest of this macro by just ignoring the rest of the
 536   // tokens that have not been lexed yet, if any.
 537
 538   // Since this must be a macro, mark the macro enabled now that it is no longer
 539   // being expanded.
 540   assert(Macro && "Token streams can't paste comments");
 541   Macro->EnableMacro();
 542
 543   PP.HandleMicrosoftCommentPaste(Tok);
 544 }