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

   1 //===--- MacroExpansion.cpp - Top level Macro Expansion -------------------===//
   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 top level handling of macro expasion for the
  11 // preprocessor.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "clang/Lex/Preprocessor.h"
  16 #include "MacroArgs.h"
  17 #include "clang/Lex/MacroInfo.h"
  18 #include "clang/Basic/SourceManager.h"
  19 #include "clang/Basic/FileManager.h"
  20 #include "clang/Basic/TargetInfo.h"
  21 #include "clang/Lex/LexDiagnostic.h"
  22 #include "clang/Lex/CodeCompletionHandler.h"
  23 #include "clang/Lex/ExternalPreprocessorSource.h"
  24 #include "llvm/ADT/StringSwitch.h"
  25 #include "llvm/ADT/STLExtras.h"
  26 #include "llvm/Config/config.h"
  27 #include "llvm/Support/raw_ostream.h"
  28 #include <cstdio>
  29 #include <ctime>
  30 using namespace clang;
  31
  32 MacroInfo *Preprocessor::getInfoForMacro(IdentifierInfo *II) const {
  33   assert(II->hasMacroDefinition() && "Identifier is not a macro!");
  34
  35   llvm::DenseMap<IdentifierInfo*, MacroInfo*>::const_iterator Pos
  36     = Macros.find(II);
  37   if (Pos == Macros.end()) {
  38     // Load this macro from the external source.
  39     getExternalSource()->LoadMacroDefinition(II);
  40     Pos = Macros.find(II);
  41   }
  42   assert(Pos != Macros.end() && "Identifier macro info is missing!");
  43   return Pos->second;
  44 }
  45
  46 /// setMacroInfo - Specify a macro for this identifier.
  47 ///
  48 void Preprocessor::setMacroInfo(IdentifierInfo *II, MacroInfo *MI) {
  49   if (MI) {
  50     Macros[II] = MI;
  51     II->setHasMacroDefinition(true);
  52   } else if (II->hasMacroDefinition()) {
  53     Macros.erase(II);
  54     II->setHasMacroDefinition(false);
  55   }
  56 }
  57
  58 /// RegisterBuiltinMacro - Register the specified identifier in the identifier
  59 /// table and mark it as a builtin macro to be expanded.
  60 static IdentifierInfo *RegisterBuiltinMacro(Preprocessor &PP, const char *Name){
  61   // Get the identifier.
  62   IdentifierInfo *Id = PP.getIdentifierInfo(Name);
  63
  64   // Mark it as being a macro that is builtin.
  65   MacroInfo *MI = PP.AllocateMacroInfo(SourceLocation());
  66   MI->setIsBuiltinMacro();
  67   PP.setMacroInfo(Id, MI);
  68   return Id;
  69 }
  70
  71
  72 /// RegisterBuiltinMacros - Register builtin macros, such as __LINE__ with the
  73 /// identifier table.
  74 void Preprocessor::RegisterBuiltinMacros() {
  75   Ident__LINE__ = RegisterBuiltinMacro(*this, "__LINE__");
  76   Ident__FILE__ = RegisterBuiltinMacro(*this, "__FILE__");
  77   Ident__DATE__ = RegisterBuiltinMacro(*this, "__DATE__");
  78   Ident__TIME__ = RegisterBuiltinMacro(*this, "__TIME__");
  79   Ident__COUNTER__ = RegisterBuiltinMacro(*this, "__COUNTER__");
  80   Ident_Pragma  = RegisterBuiltinMacro(*this, "_Pragma");
  81
  82   // GCC Extensions.
  83   Ident__BASE_FILE__     = RegisterBuiltinMacro(*this, "__BASE_FILE__");
  84   Ident__INCLUDE_LEVEL__ = RegisterBuiltinMacro(*this, "__INCLUDE_LEVEL__");
  85   Ident__TIMESTAMP__     = RegisterBuiltinMacro(*this, "__TIMESTAMP__");
  86
  87   // Clang Extensions.
  88   Ident__has_feature      = RegisterBuiltinMacro(*this, "__has_feature");
  89   Ident__has_extension    = RegisterBuiltinMacro(*this, "__has_extension");
  90   Ident__has_builtin      = RegisterBuiltinMacro(*this, "__has_builtin");
  91   Ident__has_attribute    = RegisterBuiltinMacro(*this, "__has_attribute");
  92   Ident__has_include      = RegisterBuiltinMacro(*this, "__has_include");
  93   Ident__has_include_next = RegisterBuiltinMacro(*this, "__has_include_next");
  94
  95   // Microsoft Extensions.
  96   if (Features.Microsoft)
  97     Ident__pragma = RegisterBuiltinMacro(*this, "__pragma");
  98   else
  99     Ident__pragma = 0;
 100 }
 101
 102 /// isTrivialSingleTokenExpansion - Return true if MI, which has a single token
 103 /// in its expansion, currently expands to that token literally.
 104 static bool isTrivialSingleTokenExpansion(const MacroInfo *MI,
 105                                           const IdentifierInfo *MacroIdent,
 106                                           Preprocessor &PP) {
 107   IdentifierInfo *II = MI->getReplacementToken(0).getIdentifierInfo();
 108
 109   // If the token isn't an identifier, it's always literally expanded.
 110   if (II == 0) return true;
 111
 112   // If the identifier is a macro, and if that macro is enabled, it may be
 113   // expanded so it's not a trivial expansion.
 114   if (II->hasMacroDefinition() && PP.getMacroInfo(II)->isEnabled() &&
 115       // Fast expanding "#define X X" is ok, because X would be disabled.
 116       II != MacroIdent)
 117     return false;
 118
 119   // If this is an object-like macro invocation, it is safe to trivially expand
 120   // it.
 121   if (MI->isObjectLike()) return true;
 122
 123   // If this is a function-like macro invocation, it's safe to trivially expand
 124   // as long as the identifier is not a macro argument.
 125   for (MacroInfo::arg_iterator I = MI->arg_begin(), E = MI->arg_end();
 126        I != E; ++I)
 127     if (*I == II)
 128       return false;   // Identifier is a macro argument.
 129
 130   return true;
 131 }
 132
 133
 134 /// isNextPPTokenLParen - Determine whether the next preprocessor token to be
 135 /// lexed is a '('.  If so, consume the token and return true, if not, this
 136 /// method should have no observable side-effect on the lexed tokens.
 137 bool Preprocessor::isNextPPTokenLParen() {
 138   // Do some quick tests for rejection cases.
 139   unsigned Val;
 140   if (CurLexer)
 141     Val = CurLexer->isNextPPTokenLParen();
 142   else if (CurPTHLexer)
 143     Val = CurPTHLexer->isNextPPTokenLParen();
 144   else
 145     Val = CurTokenLexer->isNextTokenLParen();
 146
 147   if (Val == 2) {
 148     // We have run off the end.  If it's a source file we don't
 149     // examine enclosing ones (C99 5.1.1.2p4).  Otherwise walk up the
 150     // macro stack.
 151     if (CurPPLexer)
 152       return false;
 153     for (unsigned i = IncludeMacroStack.size(); i != 0; --i) {
 154       IncludeStackInfo &Entry = IncludeMacroStack[i-1];
 155       if (Entry.TheLexer)
 156         Val = Entry.TheLexer->isNextPPTokenLParen();
 157       else if (Entry.ThePTHLexer)
 158         Val = Entry.ThePTHLexer->isNextPPTokenLParen();
 159       else
 160         Val = Entry.TheTokenLexer->isNextTokenLParen();
 161
 162       if (Val != 2)
 163         break;
 164
 165       // Ran off the end of a source file?
 166       if (Entry.ThePPLexer)
 167         return false;
 168     }
 169   }
 170
 171   // Okay, if we know that the token is a '(', lex it and return.  Otherwise we
 172   // have found something that isn't a '(' or we found the end of the
 173   // translation unit.  In either case, return false.
 174   return Val == 1;
 175 }
 176
 177 /// HandleMacroExpandedIdentifier - If an identifier token is read that is to be
 178 /// expanded as a macro, handle it and return the next token as 'Identifier'.
 179 bool Preprocessor::HandleMacroExpandedIdentifier(Token &Identifier,
 180                                                  MacroInfo *MI) {
 181   // If this is a macro expansion in the "#if !defined(x)" line for the file,
 182   // then the macro could expand to different things in other contexts, we need
 183   // to disable the optimization in this case.
 184   if (CurPPLexer) CurPPLexer->MIOpt.ExpandedMacro();
 185
 186   // If this is a builtin macro, like __LINE__ or _Pragma, handle it specially.
 187   if (MI->isBuiltinMacro()) {
 188     if (Callbacks) Callbacks->MacroExpands(Identifier, MI);
 189     ExpandBuiltinMacro(Identifier);
 190     return false;
 191   }
 192
 193   /// Args - If this is a function-like macro expansion, this contains,
 194   /// for each macro argument, the list of tokens that were provided to the
 195   /// invocation.
 196   MacroArgs *Args = 0;
 197
 198   // Remember where the end of the expansion occurred.  For an object-like
 199   // macro, this is the identifier.  For a function-like macro, this is the ')'.
 200   SourceLocation ExpansionEnd = Identifier.getLocation();
 201
 202   // If this is a function-like macro, read the arguments.
 203   if (MI->isFunctionLike()) {
 204     // C99 6.10.3p10: If the preprocessing token immediately after the the macro
 205     // name isn't a '(', this macro should not be expanded.
 206     if (!isNextPPTokenLParen())
 207       return true;
 208
 209     // Remember that we are now parsing the arguments to a macro invocation.
 210     // Preprocessor directives used inside macro arguments are not portable, and
 211     // this enables the warning.
 212     InMacroArgs = true;
 213     Args = ReadFunctionLikeMacroArgs(Identifier, MI, ExpansionEnd);
 214
 215     // Finished parsing args.
 216     InMacroArgs = false;
 217
 218     // If there was an error parsing the arguments, bail out.
 219     if (Args == 0) return false;
 220
 221     ++NumFnMacroExpanded;
 222   } else {
 223     ++NumMacroExpanded;
 224   }
 225
 226   // Notice that this macro has been used.
 227   markMacroAsUsed(MI);
 228
 229   if (Callbacks) Callbacks->MacroExpands(Identifier, MI);
 230
 231   // If we started lexing a macro, enter the macro expansion body.
 232
 233   // Remember where the token is expanded.
 234   SourceLocation ExpandLoc = Identifier.getLocation();
 235
 236   // If this macro expands to no tokens, don't bother to push it onto the
 237   // expansion stack, only to take it right back off.
 238   if (MI->getNumTokens() == 0) {
 239     // No need for arg info.
 240     if (Args) Args->destroy(*this);
 241
 242     // Ignore this macro use, just return the next token in the current
 243     // buffer.
 244     bool HadLeadingSpace = Identifier.hasLeadingSpace();
 245     bool IsAtStartOfLine = Identifier.isAtStartOfLine();
 246
 247     Lex(Identifier);
 248
 249     // If the identifier isn't on some OTHER line, inherit the leading
 250     // whitespace/first-on-a-line property of this token.  This handles
 251     // stuff like "! XX," -> "! ," and "   XX," -> "    ,", when XX is
 252     // empty.
 253     if (!Identifier.isAtStartOfLine()) {
 254       if (IsAtStartOfLine) Identifier.setFlag(Token::StartOfLine);
 255       if (HadLeadingSpace) Identifier.setFlag(Token::LeadingSpace);
 256     }
 257     Identifier.setFlag(Token::LeadingEmptyMacro);
 258     LastEmptyMacroExpansionLoc = ExpandLoc;
 259     ++NumFastMacroExpanded;
 260     return false;
 261
 262   } else if (MI->getNumTokens() == 1 &&
 263              isTrivialSingleTokenExpansion(MI, Identifier.getIdentifierInfo(),
 264                                            *this)) {
 265     // Otherwise, if this macro expands into a single trivially-expanded
 266     // token: expand it now.  This handles common cases like
 267     // "#define VAL 42".
 268
 269     // No need for arg info.
 270     if (Args) Args->destroy(*this);
 271
 272     // Propagate the isAtStartOfLine/hasLeadingSpace markers of the macro
 273     // identifier to the expanded token.
 274     bool isAtStartOfLine = Identifier.isAtStartOfLine();
 275     bool hasLeadingSpace = Identifier.hasLeadingSpace();
 276
 277     // Replace the result token.
 278     Identifier = MI->getReplacementToken(0);
 279
 280     // Restore the StartOfLine/LeadingSpace markers.
 281     Identifier.setFlagValue(Token::StartOfLine , isAtStartOfLine);
 282     Identifier.setFlagValue(Token::LeadingSpace, hasLeadingSpace);
 283
 284     // Update the tokens location to include both its expansion and physical
 285     // locations.
 286     SourceLocation Loc =
 287       SourceMgr.createInstantiationLoc(Identifier.getLocation(), ExpandLoc,
 288                                        ExpansionEnd,Identifier.getLength());
 289     Identifier.setLocation(Loc);
 290
 291     // If this is a disabled macro or #define X X, we must mark the result as
 292     // unexpandable.
 293     if (IdentifierInfo *NewII = Identifier.getIdentifierInfo()) {
 294       if (MacroInfo *NewMI = getMacroInfo(NewII))
 295         if (!NewMI->isEnabled() || NewMI == MI)
 296           Identifier.setFlag(Token::DisableExpand);
 297     }
 298
 299     // Since this is not an identifier token, it can't be macro expanded, so
 300     // we're done.
 301     ++NumFastMacroExpanded;
 302     return false;
 303   }
 304
 305   // Start expanding the macro.
 306   EnterMacro(Identifier, ExpansionEnd, Args);
 307
 308   // Now that the macro is at the top of the include stack, ask the
 309   // preprocessor to read the next token from it.
 310   Lex(Identifier);
 311   return false;
 312 }
 313
 314 /// ReadFunctionLikeMacroArgs - After reading "MACRO" and knowing that the next
 315 /// token is the '(' of the macro, this method is invoked to read all of the
 316 /// actual arguments specified for the macro invocation.  This returns null on
 317 /// error.
 318 MacroArgs *Preprocessor::ReadFunctionLikeMacroArgs(Token &MacroName,
 319                                                    MacroInfo *MI,
 320                                                    SourceLocation &MacroEnd) {
 321   // The number of fixed arguments to parse.
 322   unsigned NumFixedArgsLeft = MI->getNumArgs();
 323   bool isVariadic = MI->isVariadic();
 324
 325   // Outer loop, while there are more arguments, keep reading them.
 326   Token Tok;
 327
 328   // Read arguments as unexpanded tokens.  This avoids issues, e.g., where
 329   // an argument value in a macro could expand to ',' or '(' or ')'.
 330   LexUnexpandedToken(Tok);
 331   assert(Tok.is(tok::l_paren) && "Error computing l-paren-ness?");
 332
 333   // ArgTokens - Build up a list of tokens that make up each argument.  Each
 334   // argument is separated by an EOF token.  Use a SmallVector so we can avoid
 335   // heap allocations in the common case.
 336   llvm::SmallVector<Token, 64> ArgTokens;
 337
 338   unsigned NumActuals = 0;
 339   while (Tok.isNot(tok::r_paren)) {
 340     assert((Tok.is(tok::l_paren) || Tok.is(tok::comma)) &&
 341            "only expect argument separators here");
 342
 343     unsigned ArgTokenStart = ArgTokens.size();
 344     SourceLocation ArgStartLoc = Tok.getLocation();
 345
 346     // C99 6.10.3p11: Keep track of the number of l_parens we have seen.  Note
 347     // that we already consumed the first one.
 348     unsigned NumParens = 0;
 349
 350     while (1) {
 351       // Read arguments as unexpanded tokens.  This avoids issues, e.g., where
 352       // an argument value in a macro could expand to ',' or '(' or ')'.
 353       LexUnexpandedToken(Tok);
 354
 355       if (Tok.is(tok::code_completion)) {
 356         if (CodeComplete)
 357           CodeComplete->CodeCompleteMacroArgument(MacroName.getIdentifierInfo(),
 358                                                   MI, NumActuals);
 359         LexUnexpandedToken(Tok);
 360       }
 361
 362       if (Tok.is(tok::eof) || Tok.is(tok::eod)) { // "#if f(<eof>" & "#if f(\n"
 363         Diag(MacroName, diag::err_unterm_macro_invoc);
 364         // Do not lose the EOF/EOD.  Return it to the client.
 365         MacroName = Tok;
 366         return 0;
 367       } else if (Tok.is(tok::r_paren)) {
 368         // If we found the ) token, the macro arg list is done.
 369         if (NumParens-- == 0) {
 370           MacroEnd = Tok.getLocation();
 371           break;
 372         }
 373       } else if (Tok.is(tok::l_paren)) {
 374         ++NumParens;
 375       } else if (Tok.is(tok::comma) && NumParens == 0) {
 376         // Comma ends this argument if there are more fixed arguments expected.
 377         // However, if this is a variadic macro, and this is part of the
 378         // variadic part, then the comma is just an argument token.
 379         if (!isVariadic) break;
 380         if (NumFixedArgsLeft > 1)
 381           break;
 382       } else if (Tok.is(tok::comment) && !KeepMacroComments) {
 383         // If this is a comment token in the argument list and we're just in
 384         // -C mode (not -CC mode), discard the comment.
 385         continue;
 386       } else if (Tok.getIdentifierInfo() != 0) {
 387         // Reading macro arguments can cause macros that we are currently
 388         // expanding from to be popped off the expansion stack.  Doing so causes
 389         // them to be reenabled for expansion.  Here we record whether any
 390         // identifiers we lex as macro arguments correspond to disabled macros.
 391         // If so, we mark the token as noexpand.  This is a subtle aspect of
 392         // C99 6.10.3.4p2.
 393         if (MacroInfo *MI = getMacroInfo(Tok.getIdentifierInfo()))
 394           if (!MI->isEnabled())
 395             Tok.setFlag(Token::DisableExpand);
 396       }
 397       ArgTokens.push_back(Tok);
 398     }
 399
 400     // If this was an empty argument list foo(), don't add this as an empty
 401     // argument.
 402     if (ArgTokens.empty() && Tok.getKind() == tok::r_paren)
 403       break;
 404
 405     // If this is not a variadic macro, and too many args were specified, emit
 406     // an error.
 407     if (!isVariadic && NumFixedArgsLeft == 0) {
 408       if (ArgTokens.size() != ArgTokenStart)
 409         ArgStartLoc = ArgTokens[ArgTokenStart].getLocation();
 410
 411       // Emit the diagnostic at the macro name in case there is a missing ).
 412       // Emitting it at the , could be far away from the macro name.
 413       Diag(ArgStartLoc, diag::err_too_many_args_in_macro_invoc);
 414       return 0;
 415     }
 416
 417     // Empty arguments are standard in C99 and C++0x, and are supported as an extension in
 418     // other modes.
 419     if (ArgTokens.size() == ArgTokenStart && !Features.C99 && !Features.CPlusPlus0x)
 420       Diag(Tok, diag::ext_empty_fnmacro_arg);
 421
 422     // Add a marker EOF token to the end of the token list for this argument.
 423     Token EOFTok;
 424     EOFTok.startToken();
 425     EOFTok.setKind(tok::eof);
 426     EOFTok.setLocation(Tok.getLocation());
 427     EOFTok.setLength(0);
 428     ArgTokens.push_back(EOFTok);
 429     ++NumActuals;
 430     assert(NumFixedArgsLeft != 0 && "Too many arguments parsed");
 431     --NumFixedArgsLeft;
 432   }
 433
 434   // Okay, we either found the r_paren.  Check to see if we parsed too few
 435   // arguments.
 436   unsigned MinArgsExpected = MI->getNumArgs();
 437
 438   // See MacroArgs instance var for description of this.
 439   bool isVarargsElided = false;
 440
 441   if (NumActuals < MinArgsExpected) {
 442     // There are several cases where too few arguments is ok, handle them now.
 443     if (NumActuals == 0 && MinArgsExpected == 1) {
 444       // #define A(X)  or  #define A(...)   ---> A()
 445
 446       // If there is exactly one argument, and that argument is missing,
 447       // then we have an empty "()" argument empty list.  This is fine, even if
 448       // the macro expects one argument (the argument is just empty).
 449       isVarargsElided = MI->isVariadic();
 450     } else if (MI->isVariadic() &&
 451                (NumActuals+1 == MinArgsExpected ||  // A(x, ...) -> A(X)
 452                 (NumActuals == 0 && MinArgsExpected == 2))) {// A(x,...) -> A()
 453       // Varargs where the named vararg parameter is missing: ok as extension.
 454       // #define A(x, ...)
 455       // A("blah")
 456       Diag(Tok, diag::ext_missing_varargs_arg);
 457
 458       // Remember this occurred, allowing us to elide the comma when used for
 459       // cases like:
 460       //   #define A(x, foo...) blah(a, ## foo)
 461       //   #define B(x, ...) blah(a, ## __VA_ARGS__)
 462       //   #define C(...) blah(a, ## __VA_ARGS__)
 463       //  A(x) B(x) C()
 464       isVarargsElided = true;
 465     } else {
 466       // Otherwise, emit the error.
 467       Diag(Tok, diag::err_too_few_args_in_macro_invoc);
 468       return 0;
 469     }
 470
 471     // Add a marker EOF token to the end of the token list for this argument.
 472     SourceLocation EndLoc = Tok.getLocation();
 473     Tok.startToken();
 474     Tok.setKind(tok::eof);
 475     Tok.setLocation(EndLoc);
 476     Tok.setLength(0);
 477     ArgTokens.push_back(Tok);
 478
 479     // If we expect two arguments, add both as empty.
 480     if (NumActuals == 0 && MinArgsExpected == 2)
 481       ArgTokens.push_back(Tok);
 482
 483   } else if (NumActuals > MinArgsExpected && !MI->isVariadic()) {
 484     // Emit the diagnostic at the macro name in case there is a missing ).
 485     // Emitting it at the , could be far away from the macro name.
 486     Diag(MacroName, diag::err_too_many_args_in_macro_invoc);
 487     return 0;
 488   }
 489
 490   return MacroArgs::create(MI, ArgTokens.data(), ArgTokens.size(),
 491                            isVarargsElided, *this);
 492 }
 493
 494 /// \brief Keeps macro expanded tokens for TokenLexers.
 495 //
 496 /// Works like a stack; a TokenLexer adds the macro expanded tokens that is
 497 /// going to lex in the cache and when it finishes the tokens are removed
 498 /// from the end of the cache.
 499 Token *Preprocessor::cacheMacroExpandedTokens(TokenLexer *tokLexer,
 500                                               llvm::ArrayRef<Token> tokens) {
 501   assert(tokLexer);
 502   if (tokens.empty())
 503     return 0;
 504
 505   size_t newIndex = MacroExpandedTokens.size();
 506   bool cacheNeedsToGrow = tokens.size() >
 507                       MacroExpandedTokens.capacity()-MacroExpandedTokens.size();
 508   MacroExpandedTokens.append(tokens.begin(), tokens.end());
 509
 510   if (cacheNeedsToGrow) {
 511     // Go through all the TokenLexers whose 'Tokens' pointer points in the
 512     // buffer and update the pointers to the (potential) new buffer array.
 513     for (unsigned i = 0, e = MacroExpandingLexersStack.size(); i != e; ++i) {
 514       TokenLexer *prevLexer;
 515       size_t tokIndex;
 516       llvm::tie(prevLexer, tokIndex) = MacroExpandingLexersStack[i];
 517       prevLexer->Tokens = MacroExpandedTokens.data() + tokIndex;
 518     }
 519   }
 520
 521   MacroExpandingLexersStack.push_back(std::make_pair(tokLexer, newIndex));
 522   return MacroExpandedTokens.data() + newIndex;
 523 }
 524
 525 void Preprocessor::removeCachedMacroExpandedTokensOfLastLexer() {
 526   assert(!MacroExpandingLexersStack.empty());
 527   size_t tokIndex = MacroExpandingLexersStack.back().second;
 528   assert(tokIndex < MacroExpandedTokens.size());
 529   // Pop the cached macro expanded tokens from the end.
 530   MacroExpandedTokens.resize(tokIndex);
 531   MacroExpandingLexersStack.pop_back();
 532 }
 533
 534 /// ComputeDATE_TIME - Compute the current time, enter it into the specified
 535 /// scratch buffer, then return DATELoc/TIMELoc locations with the position of
 536 /// the identifier tokens inserted.
 537 static void ComputeDATE_TIME(SourceLocation &DATELoc, SourceLocation &TIMELoc,
 538                              Preprocessor &PP) {
 539   time_t TT = time(0);
 540   struct tm *TM = localtime(&TT);
 541
 542   static const char * const Months[] = {
 543     "Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"
 544   };
 545
 546   char TmpBuffer[32];
 547 #ifdef LLVM_ON_WIN32
 548   sprintf(TmpBuffer, "\"%s %2d %4d\"", Months[TM->tm_mon], TM->tm_mday,
 549           TM->tm_year+1900);
 550 #else
 551   snprintf(TmpBuffer, sizeof(TmpBuffer), "\"%s %2d %4d\"", Months[TM->tm_mon], TM->tm_mday,
 552           TM->tm_year+1900);
 553 #endif
 554
 555   Token TmpTok;
 556   TmpTok.startToken();
 557   PP.CreateString(TmpBuffer, strlen(TmpBuffer), TmpTok);
 558   DATELoc = TmpTok.getLocation();
 559
 560 #ifdef LLVM_ON_WIN32
 561   sprintf(TmpBuffer, "\"%02d:%02d:%02d\"", TM->tm_hour, TM->tm_min, TM->tm_sec);
 562 #else
 563   snprintf(TmpBuffer, sizeof(TmpBuffer), "\"%02d:%02d:%02d\"", TM->tm_hour, TM->tm_min, TM->tm_sec);
 564 #endif
 565   PP.CreateString(TmpBuffer, strlen(TmpBuffer), TmpTok);
 566   TIMELoc = TmpTok.getLocation();
 567 }
 568
 569
 570 /// HasFeature - Return true if we recognize and implement the feature
 571 /// specified by the identifier as a standard language feature.
 572 static bool HasFeature(const Preprocessor &PP, const IdentifierInfo *II) {
 573   const LangOptions &LangOpts = PP.getLangOptions();
 574
 575   return llvm::StringSwitch<bool>(II->getName())
 576            .Case("attribute_analyzer_noreturn", true)
 577            .Case("attribute_availability", true)
 578            .Case("attribute_cf_returns_not_retained", true)
 579            .Case("attribute_cf_returns_retained", true)
 580            .Case("attribute_deprecated_with_message", true)
 581            .Case("attribute_ext_vector_type", true)
 582            .Case("attribute_ns_returns_not_retained", true)
 583            .Case("attribute_ns_returns_retained", true)
 584            .Case("attribute_ns_consumes_self", true)
 585            .Case("attribute_ns_consumed", true)
 586            .Case("attribute_cf_consumed", true)
 587            .Case("attribute_objc_ivar_unused", true)
 588            .Case("attribute_objc_method_family", true)
 589            .Case("attribute_overloadable", true)
 590            .Case("attribute_unavailable_with_message", true)
 591            .Case("blocks", LangOpts.Blocks)
 592            .Case("cxx_exceptions", LangOpts.Exceptions)
 593            .Case("cxx_rtti", LangOpts.RTTI)
 594            .Case("enumerator_attributes", true)
 595            // Objective-C features
 596            .Case("objc_arr", LangOpts.ObjCAutoRefCount) // FIXME: REMOVE?
 597            .Case("objc_arc", LangOpts.ObjCAutoRefCount)
 598            .Case("objc_arc_weak", LangOpts.ObjCAutoRefCount &&
 599                  LangOpts.ObjCRuntimeHasWeak)
 600            .Case("objc_nonfragile_abi", LangOpts.ObjCNonFragileABI)
 601            .Case("objc_weak_class", LangOpts.ObjCNonFragileABI)
 602            .Case("ownership_holds", true)
 603            .Case("ownership_returns", true)
 604            .Case("ownership_takes", true)
 605            // C1X features
 606            .Case("c_generic_selections", LangOpts.C1X)
 607            .Case("c_static_assert", LangOpts.C1X)
 608            // C++0x features
 609            .Case("cxx_access_control_sfinae", LangOpts.CPlusPlus0x)
 610            .Case("cxx_alias_templates", LangOpts.CPlusPlus0x)
 611            .Case("cxx_attributes", LangOpts.CPlusPlus0x)
 612            .Case("cxx_auto_type", LangOpts.CPlusPlus0x)
 613            .Case("cxx_decltype", LangOpts.CPlusPlus0x)
 614            .Case("cxx_default_function_template_args", LangOpts.CPlusPlus0x)
 615            .Case("cxx_delegating_constructors", LangOpts.CPlusPlus0x)
 616            .Case("cxx_deleted_functions", LangOpts.CPlusPlus0x)
 617            .Case("cxx_inline_namespaces", LangOpts.CPlusPlus0x)
 618          //.Case("cxx_lambdas", false)
 619            .Case("cxx_noexcept", LangOpts.CPlusPlus0x)
 620            .Case("cxx_nullptr", LangOpts.CPlusPlus0x)
 621            .Case("cxx_override_control", LangOpts.CPlusPlus0x)
 622            .Case("cxx_range_for", LangOpts.CPlusPlus0x)
 623            .Case("cxx_reference_qualified_functions", LangOpts.CPlusPlus0x)
 624            .Case("cxx_rvalue_references", LangOpts.CPlusPlus0x)
 625            .Case("cxx_strong_enums", LangOpts.CPlusPlus0x)
 626            .Case("cxx_static_assert", LangOpts.CPlusPlus0x)
 627            .Case("cxx_trailing_return", LangOpts.CPlusPlus0x)
 628            .Case("cxx_variadic_templates", LangOpts.CPlusPlus0x)
 629            // Type traits
 630            .Case("has_nothrow_assign", LangOpts.CPlusPlus)
 631            .Case("has_nothrow_copy", LangOpts.CPlusPlus)
 632            .Case("has_nothrow_constructor", LangOpts.CPlusPlus)
 633            .Case("has_trivial_assign", LangOpts.CPlusPlus)
 634            .Case("has_trivial_copy", LangOpts.CPlusPlus)
 635            .Case("has_trivial_constructor", LangOpts.CPlusPlus)
 636            .Case("has_trivial_destructor", LangOpts.CPlusPlus)
 637            .Case("has_virtual_destructor", LangOpts.CPlusPlus)
 638            .Case("is_abstract", LangOpts.CPlusPlus)
 639            .Case("is_base_of", LangOpts.CPlusPlus)
 640            .Case("is_class", LangOpts.CPlusPlus)
 641            .Case("is_convertible_to", LangOpts.CPlusPlus)
 642            .Case("is_empty", LangOpts.CPlusPlus)
 643            .Case("is_enum", LangOpts.CPlusPlus)
 644            .Case("is_literal", LangOpts.CPlusPlus)
 645            .Case("is_standard_layout", LangOpts.CPlusPlus)
 646            .Case("is_pod", LangOpts.CPlusPlus)
 647            .Case("is_polymorphic", LangOpts.CPlusPlus)
 648            .Case("is_trivial", LangOpts.CPlusPlus)
 649            .Case("is_trivially_copyable", LangOpts.CPlusPlus)
 650            .Case("is_union", LangOpts.CPlusPlus)
 651            .Case("tls", PP.getTargetInfo().isTLSSupported())
 652            .Default(false);
 653 }
 654
 655 /// HasExtension - Return true if we recognize and implement the feature
 656 /// specified by the identifier, either as an extension or a standard language
 657 /// feature.
 658 static bool HasExtension(const Preprocessor &PP, const IdentifierInfo *II) {
 659   if (HasFeature(PP, II))
 660     return true;
 661
 662   // If the use of an extension results in an error diagnostic, extensions are
 663   // effectively unavailable, so just return false here.
 664   if (PP.getDiagnostics().getExtensionHandlingBehavior()==Diagnostic::Ext_Error)
 665     return false;
 666
 667   const LangOptions &LangOpts = PP.getLangOptions();
 668
 669   // Because we inherit the feature list from HasFeature, this string switch
 670   // must be less restrictive than HasFeature's.
 671   return llvm::StringSwitch<bool>(II->getName())
 672            // C1X features supported by other languages as extensions.
 673            .Case("c_generic_selections", true)
 674            .Case("c_static_assert", true)
 675            // C++0x features supported by other languages as extensions.
 676            .Case("cxx_deleted_functions", LangOpts.CPlusPlus)
 677            .Case("cxx_inline_namespaces", LangOpts.CPlusPlus)
 678            .Case("cxx_override_control", LangOpts.CPlusPlus)
 679            .Case("cxx_reference_qualified_functions", LangOpts.CPlusPlus)
 680            .Case("cxx_rvalue_references", LangOpts.CPlusPlus)
 681            .Default(false);
 682 }
 683
 684 /// HasAttribute -  Return true if we recognize and implement the attribute
 685 /// specified by the given identifier.
 686 static bool HasAttribute(const IdentifierInfo *II) {
 687     return llvm::StringSwitch<bool>(II->getName())
 688 #include "clang/Lex/AttrSpellings.inc"
 689         .Default(false);
 690 }
 691
 692 /// EvaluateHasIncludeCommon - Process a '__has_include("path")'
 693 /// or '__has_include_next("path")' expression.
 694 /// Returns true if successful.
 695 static bool EvaluateHasIncludeCommon(Token &Tok,
 696                                      IdentifierInfo *II, Preprocessor &PP,
 697                                      const DirectoryLookup *LookupFrom) {
 698   SourceLocation LParenLoc;
 699
 700   // Get '('.
 701   PP.LexNonComment(Tok);
 702
 703   // Ensure we have a '('.
 704   if (Tok.isNot(tok::l_paren)) {
 705     PP.Diag(Tok.getLocation(), diag::err_pp_missing_lparen) << II->getName();
 706     return false;
 707   }
 708
 709   // Save '(' location for possible missing ')' message.
 710   LParenLoc = Tok.getLocation();
 711
 712   // Get the file name.
 713   PP.getCurrentLexer()->LexIncludeFilename(Tok);
 714
 715   // Reserve a buffer to get the spelling.
 716   llvm::SmallString<128> FilenameBuffer;
 717   llvm::StringRef Filename;
 718   SourceLocation EndLoc;
 719
 720   switch (Tok.getKind()) {
 721   case tok::eod:
 722     // If the token kind is EOD, the error has already been diagnosed.
 723     return false;
 724
 725   case tok::angle_string_literal:
 726   case tok::string_literal: {
 727     bool Invalid = false;
 728     Filename = PP.getSpelling(Tok, FilenameBuffer, &Invalid);
 729     if (Invalid)
 730       return false;
 731     break;
 732   }
 733
 734   case tok::less:
 735     // This could be a <foo/bar.h> file coming from a macro expansion.  In this
 736     // case, glue the tokens together into FilenameBuffer and interpret those.
 737     FilenameBuffer.push_back('<');
 738     if (PP.ConcatenateIncludeName(FilenameBuffer, EndLoc))
 739       return false;   // Found <eod> but no ">"?  Diagnostic already emitted.
 740     Filename = FilenameBuffer.str();
 741     break;
 742   default:
 743     PP.Diag(Tok.getLocation(), diag::err_pp_expects_filename);
 744     return false;
 745   }
 746
 747   bool isAngled = PP.GetIncludeFilenameSpelling(Tok.getLocation(), Filename);
 748   // If GetIncludeFilenameSpelling set the start ptr to null, there was an
 749   // error.
 750   if (Filename.empty())
 751     return false;
 752
 753   // Search include directories.
 754   const DirectoryLookup *CurDir;
 755   const FileEntry *File =
 756       PP.LookupFile(Filename, isAngled, LookupFrom, CurDir, NULL, NULL);
 757
 758   // Get the result value.  Result = true means the file exists.
 759   bool Result = File != 0;
 760
 761   // Get ')'.
 762   PP.LexNonComment(Tok);
 763
 764   // Ensure we have a trailing ).
 765   if (Tok.isNot(tok::r_paren)) {
 766     PP.Diag(Tok.getLocation(), diag::err_pp_missing_rparen) << II->getName();
 767     PP.Diag(LParenLoc, diag::note_matching) << "(";
 768     return false;
 769   }
 770
 771   return Result;
 772 }
 773
 774 /// EvaluateHasInclude - Process a '__has_include("path")' expression.
 775 /// Returns true if successful.
 776 static bool EvaluateHasInclude(Token &Tok, IdentifierInfo *II,
 777                                Preprocessor &PP) {
 778   return EvaluateHasIncludeCommon(Tok, II, PP, NULL);
 779 }
 780
 781 /// EvaluateHasIncludeNext - Process '__has_include_next("path")' expression.
 782 /// Returns true if successful.
 783 static bool EvaluateHasIncludeNext(Token &Tok,
 784                                    IdentifierInfo *II, Preprocessor &PP) {
 785   // __has_include_next is like __has_include, except that we start
 786   // searching after the current found directory.  If we can't do this,
 787   // issue a diagnostic.
 788   const DirectoryLookup *Lookup = PP.GetCurDirLookup();
 789   if (PP.isInPrimaryFile()) {
 790     Lookup = 0;
 791     PP.Diag(Tok, diag::pp_include_next_in_primary);
 792   } else if (Lookup == 0) {
 793     PP.Diag(Tok, diag::pp_include_next_absolute_path);
 794   } else {
 795     // Start looking up in the next directory.
 796     ++Lookup;
 797   }
 798
 799   return EvaluateHasIncludeCommon(Tok, II, PP, Lookup);
 800 }
 801
 802 /// ExpandBuiltinMacro - If an identifier token is read that is to be expanded
 803 /// as a builtin macro, handle it and return the next token as 'Tok'.
 804 void Preprocessor::ExpandBuiltinMacro(Token &Tok) {
 805   // Figure out which token this is.
 806   IdentifierInfo *II = Tok.getIdentifierInfo();
 807   assert(II && "Can't be a macro without id info!");
 808
 809   // If this is an _Pragma or Microsoft __pragma directive, expand it,
 810   // invoke the pragma handler, then lex the token after it.
 811   if (II == Ident_Pragma)
 812     return Handle_Pragma(Tok);
 813   else if (II == Ident__pragma) // in non-MS mode this is null
 814     return HandleMicrosoft__pragma(Tok);
 815
 816   ++NumBuiltinMacroExpanded;
 817
 818   llvm::SmallString<128> TmpBuffer;
 819   llvm::raw_svector_ostream OS(TmpBuffer);
 820
 821   // Set up the return result.
 822   Tok.setIdentifierInfo(0);
 823   Tok.clearFlag(Token::NeedsCleaning);
 824
 825   if (II == Ident__LINE__) {
 826     // C99 6.10.8: "__LINE__: The presumed line number (within the current
 827     // source file) of the current source line (an integer constant)".  This can
 828     // be affected by #line.
 829     SourceLocation Loc = Tok.getLocation();
 830
 831     // Advance to the location of the first _, this might not be the first byte
 832     // of the token if it starts with an escaped newline.
 833     Loc = AdvanceToTokenCharacter(Loc, 0);
 834
 835     // One wrinkle here is that GCC expands __LINE__ to location of the *end* of
 836     // a macro expansion.  This doesn't matter for object-like macros, but
 837     // can matter for a function-like macro that expands to contain __LINE__.
 838     // Skip down through expansion points until we find a file loc for the
 839     // end of the expansion history.
 840     Loc = SourceMgr.getInstantiationRange(Loc).second;
 841     PresumedLoc PLoc = SourceMgr.getPresumedLoc(Loc);
 842
 843     // __LINE__ expands to a simple numeric value.
 844     OS << (PLoc.isValid()? PLoc.getLine() : 1);
 845     Tok.setKind(tok::numeric_constant);
 846   } else if (II == Ident__FILE__ || II == Ident__BASE_FILE__) {
 847     // C99 6.10.8: "__FILE__: The presumed name of the current source file (a
 848     // character string literal)". This can be affected by #line.
 849     PresumedLoc PLoc = SourceMgr.getPresumedLoc(Tok.getLocation());
 850
 851     // __BASE_FILE__ is a GNU extension that returns the top of the presumed
 852     // #include stack instead of the current file.
 853     if (II == Ident__BASE_FILE__ && PLoc.isValid()) {
 854       SourceLocation NextLoc = PLoc.getIncludeLoc();
 855       while (NextLoc.isValid()) {
 856         PLoc = SourceMgr.getPresumedLoc(NextLoc);
 857         if (PLoc.isInvalid())
 858           break;
 859
 860         NextLoc = PLoc.getIncludeLoc();
 861       }
 862     }
 863
 864     // Escape this filename.  Turn '\' -> '\\' '"' -> '\"'
 865     llvm::SmallString<128> FN;
 866     if (PLoc.isValid()) {
 867       FN += PLoc.getFilename();
 868       Lexer::Stringify(FN);
 869       OS << '"' << FN.str() << '"';
 870     }
 871     Tok.setKind(tok::string_literal);
 872   } else if (II == Ident__DATE__) {
 873     if (!DATELoc.isValid())
 874       ComputeDATE_TIME(DATELoc, TIMELoc, *this);
 875     Tok.setKind(tok::string_literal);
 876     Tok.setLength(strlen("\"Mmm dd yyyy\""));
 877     Tok.setLocation(SourceMgr.createInstantiationLoc(DATELoc, Tok.getLocation(),
 878                                                      Tok.getLocation(),
 879                                                      Tok.getLength()));
 880     return;
 881   } else if (II == Ident__TIME__) {
 882     if (!TIMELoc.isValid())
 883       ComputeDATE_TIME(DATELoc, TIMELoc, *this);
 884     Tok.setKind(tok::string_literal);
 885     Tok.setLength(strlen("\"hh:mm:ss\""));
 886     Tok.setLocation(SourceMgr.createInstantiationLoc(TIMELoc, Tok.getLocation(),
 887                                                      Tok.getLocation(),
 888                                                      Tok.getLength()));
 889     return;
 890   } else if (II == Ident__INCLUDE_LEVEL__) {
 891     // Compute the presumed include depth of this token.  This can be affected
 892     // by GNU line markers.
 893     unsigned Depth = 0;
 894
 895     PresumedLoc PLoc = SourceMgr.getPresumedLoc(Tok.getLocation());
 896     if (PLoc.isValid()) {
 897       PLoc = SourceMgr.getPresumedLoc(PLoc.getIncludeLoc());
 898       for (; PLoc.isValid(); ++Depth)
 899         PLoc = SourceMgr.getPresumedLoc(PLoc.getIncludeLoc());
 900     }
 901
 902     // __INCLUDE_LEVEL__ expands to a simple numeric value.
 903     OS << Depth;
 904     Tok.setKind(tok::numeric_constant);
 905   } else if (II == Ident__TIMESTAMP__) {
 906     // MSVC, ICC, GCC, VisualAge C++ extension.  The generated string should be
 907     // of the form "Ddd Mmm dd hh::mm::ss yyyy", which is returned by asctime.
 908
 909     // Get the file that we are lexing out of.  If we're currently lexing from
 910     // a macro, dig into the include stack.
 911     const FileEntry *CurFile = 0;
 912     PreprocessorLexer *TheLexer = getCurrentFileLexer();
 913
 914     if (TheLexer)
 915       CurFile = SourceMgr.getFileEntryForID(TheLexer->getFileID());
 916
 917     const char *Result;
 918     if (CurFile) {
 919       time_t TT = CurFile->getModificationTime();
 920       struct tm *TM = localtime(&TT);
 921       Result = asctime(TM);
 922     } else {
 923       Result = "??? ??? ?? ??:??:?? ????\n";
 924     }
 925     // Surround the string with " and strip the trailing newline.
 926     OS << '"' << llvm::StringRef(Result, strlen(Result)-1) << '"';
 927     Tok.setKind(tok::string_literal);
 928   } else if (II == Ident__COUNTER__) {
 929     // __COUNTER__ expands to a simple numeric value.
 930     OS << CounterValue++;
 931     Tok.setKind(tok::numeric_constant);
 932   } else if (II == Ident__has_feature   ||
 933              II == Ident__has_extension ||
 934              II == Ident__has_builtin   ||
 935              II == Ident__has_attribute) {
 936     // The argument to these builtins should be a parenthesized identifier.
 937     SourceLocation StartLoc = Tok.getLocation();
 938
 939     bool IsValid = false;
 940     IdentifierInfo *FeatureII = 0;
 941
 942     // Read the '('.
 943     Lex(Tok);
 944     if (Tok.is(tok::l_paren)) {
 945       // Read the identifier
 946       Lex(Tok);
 947       if (Tok.is(tok::identifier)) {
 948         FeatureII = Tok.getIdentifierInfo();
 949
 950         // Read the ')'.
 951         Lex(Tok);
 952         if (Tok.is(tok::r_paren))
 953           IsValid = true;
 954       }
 955     }
 956
 957     bool Value = false;
 958     if (!IsValid)
 959       Diag(StartLoc, diag::err_feature_check_malformed);
 960     else if (II == Ident__has_builtin) {
 961       // Check for a builtin is trivial.
 962       Value = FeatureII->getBuiltinID() != 0;
 963     } else if (II == Ident__has_attribute)
 964       Value = HasAttribute(FeatureII);
 965     else if (II == Ident__has_extension)
 966       Value = HasExtension(*this, FeatureII);
 967     else {
 968       assert(II == Ident__has_feature && "Must be feature check");
 969       Value = HasFeature(*this, FeatureII);
 970     }
 971
 972     OS << (int)Value;
 973     Tok.setKind(tok::numeric_constant);
 974   } else if (II == Ident__has_include ||
 975              II == Ident__has_include_next) {
 976     // The argument to these two builtins should be a parenthesized
 977     // file name string literal using angle brackets (<>) or
 978     // double-quotes ("").
 979     bool Value;
 980     if (II == Ident__has_include)
 981       Value = EvaluateHasInclude(Tok, II, *this);
 982     else
 983       Value = EvaluateHasIncludeNext(Tok, II, *this);
 984     OS << (int)Value;
 985     Tok.setKind(tok::numeric_constant);
 986   } else {
 987     assert(0 && "Unknown identifier!");
 988   }
 989   CreateString(OS.str().data(), OS.str().size(), Tok, Tok.getLocation());
 990 }
 991
 992 void Preprocessor::markMacroAsUsed(MacroInfo *MI) {
 993   // If the 'used' status changed, and the macro requires 'unused' warning,
 994   // remove its SourceLocation from the warn-for-unused-macro locations.
 995   if (MI->isWarnIfUnused() && !MI->isUsed())
 996     WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());
 997   MI->setIsUsed(true);
 998 }