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