clang 20.0.0git
Pragma.cpp
Go to the documentation of this file.
1//===- Pragma.cpp - Pragma registration and handling ----------------------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file implements the PragmaHandler/PragmaTable interfaces and implements
10// pragma related methods of the Preprocessor class.
11//
12//===----------------------------------------------------------------------===//
13
14#include "clang/Lex/Pragma.h"
19#include "clang/Basic/LLVM.h"
21#include "clang/Basic/Module.h"
27#include "clang/Lex/Lexer.h"
29#include "clang/Lex/MacroInfo.h"
35#include "clang/Lex/Token.h"
37#include "llvm/ADT/ArrayRef.h"
38#include "llvm/ADT/DenseMap.h"
39#include "llvm/ADT/STLExtras.h"
40#include "llvm/ADT/SmallString.h"
41#include "llvm/ADT/SmallVector.h"
42#include "llvm/ADT/StringRef.h"
43#include "llvm/Support/Compiler.h"
44#include "llvm/Support/ErrorHandling.h"
45#include "llvm/Support/Timer.h"
46#include <algorithm>
47#include <cassert>
48#include <cstddef>
49#include <cstdint>
50#include <limits>
51#include <optional>
52#include <string>
53#include <utility>
54#include <vector>
55
56using namespace clang;
57
58// Out-of-line destructor to provide a home for the class.
60
61//===----------------------------------------------------------------------===//
62// EmptyPragmaHandler Implementation.
63//===----------------------------------------------------------------------===//
64
66
68 PragmaIntroducer Introducer,
69 Token &FirstToken) {}
70
71//===----------------------------------------------------------------------===//
72// PragmaNamespace Implementation.
73//===----------------------------------------------------------------------===//
74
75/// FindHandler - Check to see if there is already a handler for the
76/// specified name. If not, return the handler for the null identifier if it
77/// exists, otherwise return null. If IgnoreNull is true (the default) then
78/// the null handler isn't returned on failure to match.
80 bool IgnoreNull) const {
81 auto I = Handlers.find(Name);
82 if (I != Handlers.end())
83 return I->getValue().get();
84 if (IgnoreNull)
85 return nullptr;
86 I = Handlers.find(StringRef());
87 if (I != Handlers.end())
88 return I->getValue().get();
89 return nullptr;
90}
91
93 assert(!Handlers.count(Handler->getName()) &&
94 "A handler with this name is already registered in this namespace");
95 Handlers[Handler->getName()].reset(Handler);
96}
97
99 auto I = Handlers.find(Handler->getName());
100 assert(I != Handlers.end() &&
101 "Handler not registered in this namespace");
102 // Release ownership back to the caller.
103 I->getValue().release();
104 Handlers.erase(I);
105}
106
108 PragmaIntroducer Introducer, Token &Tok) {
109 // Read the 'namespace' that the directive is in, e.g. STDC. Do not macro
110 // expand it, the user can have a STDC #define, that should not affect this.
111 PP.LexUnexpandedToken(Tok);
112
113 // Get the handler for this token. If there is no handler, ignore the pragma.
114 PragmaHandler *Handler
116 : StringRef(),
117 /*IgnoreNull=*/false);
118 if (!Handler) {
119 PP.Diag(Tok, diag::warn_pragma_ignored);
120 return;
121 }
122
123 // Otherwise, pass it down.
124 Handler->HandlePragma(PP, Introducer, Tok);
125}
126
127//===----------------------------------------------------------------------===//
128// Preprocessor Pragma Directive Handling.
129//===----------------------------------------------------------------------===//
130
131namespace {
132// TokenCollector provides the option to collect tokens that were "read"
133// and return them to the stream to be read later.
134// Currently used when reading _Pragma/__pragma directives.
135struct TokenCollector {
136 Preprocessor &Self;
137 bool Collect;
139 Token &Tok;
140
141 void lex() {
142 if (Collect)
143 Tokens.push_back(Tok);
144 Self.Lex(Tok);
145 }
146
147 void revert() {
148 assert(Collect && "did not collect tokens");
149 assert(!Tokens.empty() && "collected unexpected number of tokens");
150
151 // Push the ( "string" ) tokens into the token stream.
152 auto Toks = std::make_unique<Token[]>(Tokens.size());
153 std::copy(Tokens.begin() + 1, Tokens.end(), Toks.get());
154 Toks[Tokens.size() - 1] = Tok;
155 Self.EnterTokenStream(std::move(Toks), Tokens.size(),
156 /*DisableMacroExpansion*/ true,
157 /*IsReinject*/ true);
158
159 // ... and return the pragma token unchanged.
160 Tok = *Tokens.begin();
161 }
162};
163} // namespace
164
165/// HandlePragmaDirective - The "\#pragma" directive has been parsed. Lex the
166/// rest of the pragma, passing it to the registered pragma handlers.
167void Preprocessor::HandlePragmaDirective(PragmaIntroducer Introducer) {
168 if (Callbacks)
169 Callbacks->PragmaDirective(Introducer.Loc, Introducer.Kind);
170
171 if (!PragmasEnabled)
172 return;
173
174 ++NumPragma;
175
176 // Invoke the first level of pragma handlers which reads the namespace id.
177 Token Tok;
178 PragmaHandlers->HandlePragma(*this, Introducer, Tok);
179
180 // If the pragma handler didn't read the rest of the line, consume it now.
181 if ((CurTokenLexer && CurTokenLexer->isParsingPreprocessorDirective())
182 || (CurPPLexer && CurPPLexer->ParsingPreprocessorDirective))
184}
185
186/// Handle_Pragma - Read a _Pragma directive, slice it up, process it, then
187/// return the first token after the directive. The _Pragma token has just
188/// been read into 'Tok'.
189void Preprocessor::Handle_Pragma(Token &Tok) {
190 // C11 6.10.3.4/3:
191 // all pragma unary operator expressions within [a completely
192 // macro-replaced preprocessing token sequence] are [...] processed [after
193 // rescanning is complete]
194 //
195 // This means that we execute _Pragma operators in two cases:
196 //
197 // 1) on token sequences that would otherwise be produced as the output of
198 // phase 4 of preprocessing, and
199 // 2) on token sequences formed as the macro-replaced token sequence of a
200 // macro argument
201 //
202 // Case #2 appears to be a wording bug: only _Pragmas that would survive to
203 // the end of phase 4 should actually be executed. Discussion on the WG14
204 // mailing list suggests that a _Pragma operator is notionally checked early,
205 // but only pragmas that survive to the end of phase 4 should be executed.
206 //
207 // In Case #2, we check the syntax now, but then put the tokens back into the
208 // token stream for later consumption.
209
210 TokenCollector Toks = {*this, InMacroArgPreExpansion, {}, Tok};
211
212 // Remember the pragma token location.
213 SourceLocation PragmaLoc = Tok.getLocation();
214
215 // Read the '('.
216 Toks.lex();
217 if (Tok.isNot(tok::l_paren)) {
218 Diag(PragmaLoc, diag::err__Pragma_malformed);
219 return;
220 }
221
222 // Read the '"..."'.
223 Toks.lex();
224 if (!tok::isStringLiteral(Tok.getKind())) {
225 Diag(PragmaLoc, diag::err__Pragma_malformed);
226 // Skip bad tokens, and the ')', if present.
227 if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::eof))
228 Lex(Tok);
229 while (Tok.isNot(tok::r_paren) &&
230 !Tok.isAtStartOfLine() &&
231 Tok.isNot(tok::eof))
232 Lex(Tok);
233 if (Tok.is(tok::r_paren))
234 Lex(Tok);
235 return;
236 }
237
238 if (Tok.hasUDSuffix()) {
239 Diag(Tok, diag::err_invalid_string_udl);
240 // Skip this token, and the ')', if present.
241 Lex(Tok);
242 if (Tok.is(tok::r_paren))
243 Lex(Tok);
244 return;
245 }
246
247 // Remember the string.
248 Token StrTok = Tok;
249
250 // Read the ')'.
251 Toks.lex();
252 if (Tok.isNot(tok::r_paren)) {
253 Diag(PragmaLoc, diag::err__Pragma_malformed);
254 return;
255 }
256
257 // If we're expanding a macro argument, put the tokens back.
258 if (InMacroArgPreExpansion) {
259 Toks.revert();
260 return;
261 }
262
263 SourceLocation RParenLoc = Tok.getLocation();
264 bool Invalid = false;
265 SmallString<64> StrVal;
266 StrVal.resize(StrTok.getLength());
267 StringRef StrValRef = getSpelling(StrTok, StrVal, &Invalid);
268 if (Invalid) {
269 Diag(PragmaLoc, diag::err__Pragma_malformed);
270 return;
271 }
272
273 assert(StrValRef.size() <= StrVal.size());
274
275 // If the token was spelled somewhere else, copy it.
276 if (StrValRef.begin() != StrVal.begin())
277 StrVal.assign(StrValRef);
278 // Truncate if necessary.
279 else if (StrValRef.size() != StrVal.size())
280 StrVal.resize(StrValRef.size());
281
282 // The _Pragma is lexically sound. Destringize according to C11 6.10.9.1.
283 prepare_PragmaString(StrVal);
284
285 // Plop the string (including the newline and trailing null) into a buffer
286 // where we can lex it.
287 Token TmpTok;
288 TmpTok.startToken();
289 CreateString(StrVal, TmpTok);
290 SourceLocation TokLoc = TmpTok.getLocation();
291
292 // Make and enter a lexer object so that we lex and expand the tokens just
293 // like any others.
294 Lexer *TL = Lexer::Create_PragmaLexer(TokLoc, PragmaLoc, RParenLoc,
295 StrVal.size(), *this);
296
297 EnterSourceFileWithLexer(TL, nullptr);
298
299 // With everything set up, lex this as a #pragma directive.
300 HandlePragmaDirective({PIK__Pragma, PragmaLoc});
301
302 // Finally, return whatever came after the pragma directive.
303 return Lex(Tok);
304}
305
307 if (StrVal[0] == 'L' || StrVal[0] == 'U' ||
308 (StrVal[0] == 'u' && StrVal[1] != '8'))
309 StrVal.erase(StrVal.begin());
310 else if (StrVal[0] == 'u')
311 StrVal.erase(StrVal.begin(), StrVal.begin() + 2);
312
313 if (StrVal[0] == 'R') {
314 // FIXME: C++11 does not specify how to handle raw-string-literals here.
315 // We strip off the 'R', the quotes, the d-char-sequences, and the parens.
316 assert(StrVal[1] == '"' && StrVal[StrVal.size() - 1] == '"' &&
317 "Invalid raw string token!");
318
319 // Measure the length of the d-char-sequence.
320 unsigned NumDChars = 0;
321 while (StrVal[2 + NumDChars] != '(') {
322 assert(NumDChars < (StrVal.size() - 5) / 2 &&
323 "Invalid raw string token!");
324 ++NumDChars;
325 }
326 assert(StrVal[StrVal.size() - 2 - NumDChars] == ')');
327
328 // Remove 'R " d-char-sequence' and 'd-char-sequence "'. We'll replace the
329 // parens below.
330 StrVal.erase(StrVal.begin(), StrVal.begin() + 2 + NumDChars);
331 StrVal.erase(StrVal.end() - 1 - NumDChars, StrVal.end());
332 } else {
333 assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' &&
334 "Invalid string token!");
335
336 // Remove escaped quotes and escapes.
337 unsigned ResultPos = 1;
338 for (size_t i = 1, e = StrVal.size() - 1; i != e; ++i) {
339 // Skip escapes. \\ -> '\' and \" -> '"'.
340 if (StrVal[i] == '\\' && i + 1 < e &&
341 (StrVal[i + 1] == '\\' || StrVal[i + 1] == '"'))
342 ++i;
343 StrVal[ResultPos++] = StrVal[i];
344 }
345 StrVal.erase(StrVal.begin() + ResultPos, StrVal.end() - 1);
346 }
347
348 // Remove the front quote, replacing it with a space, so that the pragma
349 // contents appear to have a space before them.
350 StrVal[0] = ' ';
351
352 // Replace the terminating quote with a \n.
353 StrVal[StrVal.size() - 1] = '\n';
354}
355
356/// HandleMicrosoft__pragma - Like Handle_Pragma except the pragma text
357/// is not enclosed within a string literal.
358void Preprocessor::HandleMicrosoft__pragma(Token &Tok) {
359 // During macro pre-expansion, check the syntax now but put the tokens back
360 // into the token stream for later consumption. Same as Handle_Pragma.
361 TokenCollector Toks = {*this, InMacroArgPreExpansion, {}, Tok};
362
363 // Remember the pragma token location.
364 SourceLocation PragmaLoc = Tok.getLocation();
365
366 // Read the '('.
367 Toks.lex();
368 if (Tok.isNot(tok::l_paren)) {
369 Diag(PragmaLoc, diag::err__Pragma_malformed);
370 return;
371 }
372
373 // Get the tokens enclosed within the __pragma(), as well as the final ')'.
374 SmallVector<Token, 32> PragmaToks;
375 int NumParens = 0;
376 Toks.lex();
377 while (Tok.isNot(tok::eof)) {
378 PragmaToks.push_back(Tok);
379 if (Tok.is(tok::l_paren))
380 NumParens++;
381 else if (Tok.is(tok::r_paren) && NumParens-- == 0)
382 break;
383 Toks.lex();
384 }
385
386 if (Tok.is(tok::eof)) {
387 Diag(PragmaLoc, diag::err_unterminated___pragma);
388 return;
389 }
390
391 // If we're expanding a macro argument, put the tokens back.
392 if (InMacroArgPreExpansion) {
393 Toks.revert();
394 return;
395 }
396
397 PragmaToks.front().setFlag(Token::LeadingSpace);
398
399 // Replace the ')' with an EOD to mark the end of the pragma.
400 PragmaToks.back().setKind(tok::eod);
401
402 Token *TokArray = new Token[PragmaToks.size()];
403 std::copy(PragmaToks.begin(), PragmaToks.end(), TokArray);
404
405 // Push the tokens onto the stack.
406 EnterTokenStream(TokArray, PragmaToks.size(), true, true,
407 /*IsReinject*/ false);
408
409 // With everything set up, lex this as a #pragma directive.
410 HandlePragmaDirective({PIK___pragma, PragmaLoc});
411
412 // Finally, return whatever came after the pragma directive.
413 return Lex(Tok);
414}
415
416/// HandlePragmaOnce - Handle \#pragma once. OnceTok is the 'once'.
418 // Don't honor the 'once' when handling the primary source file, unless
419 // this is a prefix to a TU, which indicates we're generating a PCH file, or
420 // when the main file is a header (e.g. when -xc-header is provided on the
421 // commandline).
422 if (isInPrimaryFile() && TUKind != TU_Prefix && !getLangOpts().IsHeaderFile) {
423 Diag(OnceTok, diag::pp_pragma_once_in_main_file);
424 return;
425 }
426
427 // Get the current file lexer we're looking at. Ignore _Pragma 'files' etc.
428 // Mark the file as a once-only file now.
429 HeaderInfo.MarkFileIncludeOnce(*getCurrentFileLexer()->getFileEntry());
430}
431
433 assert(CurPPLexer && "No current lexer?");
434
435 SmallString<64> Buffer;
436 CurLexer->ReadToEndOfLine(&Buffer);
437 if (Callbacks)
438 Callbacks->PragmaMark(MarkTok.getLocation(), Buffer);
439}
440
441/// HandlePragmaPoison - Handle \#pragma GCC poison. PoisonTok is the 'poison'.
443 Token Tok;
444
445 while (true) {
446 // Read the next token to poison. While doing this, pretend that we are
447 // skipping while reading the identifier to poison.
448 // This avoids errors on code like:
449 // #pragma GCC poison X
450 // #pragma GCC poison X
451 if (CurPPLexer) CurPPLexer->LexingRawMode = true;
453 if (CurPPLexer) CurPPLexer->LexingRawMode = false;
454
455 // If we reached the end of line, we're done.
456 if (Tok.is(tok::eod)) return;
457
458 // Can only poison identifiers.
459 if (Tok.isNot(tok::raw_identifier)) {
460 Diag(Tok, diag::err_pp_invalid_poison);
461 return;
462 }
463
464 // Look up the identifier info for the token. We disabled identifier lookup
465 // by saying we're skipping contents, so we need to do this manually.
467
468 // Already poisoned.
469 if (II->isPoisoned()) continue;
470
471 // If this is a macro identifier, emit a warning.
472 if (isMacroDefined(II))
473 Diag(Tok, diag::pp_poisoning_existing_macro);
474
475 // Finally, poison it!
476 II->setIsPoisoned();
477 if (II->isFromAST())
479 }
480}
481
482/// HandlePragmaSystemHeader - Implement \#pragma GCC system_header. We know
483/// that the whole directive has been parsed.
485 if (isInPrimaryFile()) {
486 Diag(SysHeaderTok, diag::pp_pragma_sysheader_in_main_file);
487 return;
488 }
489
490 // Get the current file lexer we're looking at. Ignore _Pragma 'files' etc.
492
493 // Mark the file as a system header.
494 HeaderInfo.MarkFileSystemHeader(*TheLexer->getFileEntry());
495
496 PresumedLoc PLoc = SourceMgr.getPresumedLoc(SysHeaderTok.getLocation());
497 if (PLoc.isInvalid())
498 return;
499
500 unsigned FilenameID = SourceMgr.getLineTableFilenameID(PLoc.getFilename());
501
502 // Notify the client, if desired, that we are in a new source file.
503 if (Callbacks)
504 Callbacks->FileChanged(SysHeaderTok.getLocation(),
506
507 // Emit a line marker. This will change any source locations from this point
508 // forward to realize they are in a system header.
509 // Create a line note with this information.
510 SourceMgr.AddLineNote(SysHeaderTok.getLocation(), PLoc.getLine() + 1,
511 FilenameID, /*IsEntry=*/false, /*IsExit=*/false,
513}
514
515/// HandlePragmaDependency - Handle \#pragma GCC dependency "foo" blah.
517 Token FilenameTok;
518 if (LexHeaderName(FilenameTok, /*AllowConcatenation*/false))
519 return;
520
521 // If the next token wasn't a header-name, diagnose the error.
522 if (FilenameTok.isNot(tok::header_name)) {
523 Diag(FilenameTok.getLocation(), diag::err_pp_expects_filename);
524 return;
525 }
526
527 // Reserve a buffer to get the spelling.
528 SmallString<128> FilenameBuffer;
529 bool Invalid = false;
530 StringRef Filename = getSpelling(FilenameTok, FilenameBuffer, &Invalid);
531 if (Invalid)
532 return;
533
534 bool isAngled =
536 // If GetIncludeFilenameSpelling set the start ptr to null, there was an
537 // error.
538 if (Filename.empty())
539 return;
540
541 // Search include directories for this file.
543 LookupFile(FilenameTok.getLocation(), Filename, isAngled, nullptr,
544 nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
545 if (!File) {
546 if (!SuppressIncludeNotFoundError)
547 Diag(FilenameTok, diag::err_pp_file_not_found) << Filename;
548 return;
549 }
550
552
553 // If this file is older than the file it depends on, emit a diagnostic.
554 if (CurFile && CurFile->getModificationTime() < File->getModificationTime()) {
555 // Lex tokens at the end of the message and include them in the message.
556 std::string Message;
557 Lex(DependencyTok);
558 while (DependencyTok.isNot(tok::eod)) {
559 Message += getSpelling(DependencyTok) + " ";
560 Lex(DependencyTok);
561 }
562
563 // Remove the trailing ' ' if present.
564 if (!Message.empty())
565 Message.erase(Message.end()-1);
566 Diag(FilenameTok, diag::pp_out_of_date_dependency) << Message;
567 }
568}
569
570/// ParsePragmaPushOrPopMacro - Handle parsing of pragma push_macro/pop_macro.
571/// Return the IdentifierInfo* associated with the macro to push or pop.
573 // Remember the pragma token location.
574 Token PragmaTok = Tok;
575
576 // Read the '('.
577 Lex(Tok);
578 if (Tok.isNot(tok::l_paren)) {
579 Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
580 << getSpelling(PragmaTok);
581 return nullptr;
582 }
583
584 // Read the macro name string.
585 Lex(Tok);
586 if (Tok.isNot(tok::string_literal)) {
587 Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
588 << getSpelling(PragmaTok);
589 return nullptr;
590 }
591
592 if (Tok.hasUDSuffix()) {
593 Diag(Tok, diag::err_invalid_string_udl);
594 return nullptr;
595 }
596
597 // Remember the macro string.
598 std::string StrVal = getSpelling(Tok);
599
600 // Read the ')'.
601 Lex(Tok);
602 if (Tok.isNot(tok::r_paren)) {
603 Diag(PragmaTok.getLocation(), diag::err_pragma_push_pop_macro_malformed)
604 << getSpelling(PragmaTok);
605 return nullptr;
606 }
607
608 assert(StrVal[0] == '"' && StrVal[StrVal.size()-1] == '"' &&
609 "Invalid string token!");
610
611 // Create a Token from the string.
612 Token MacroTok;
613 MacroTok.startToken();
614 MacroTok.setKind(tok::raw_identifier);
615 CreateString(StringRef(&StrVal[1], StrVal.size() - 2), MacroTok);
616
617 // Get the IdentifierInfo of MacroToPushTok.
618 return LookUpIdentifierInfo(MacroTok);
619}
620
621/// Handle \#pragma push_macro.
622///
623/// The syntax is:
624/// \code
625/// #pragma push_macro("macro")
626/// \endcode
628 // Parse the pragma directive and get the macro IdentifierInfo*.
629 IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PushMacroTok);
630 if (!IdentInfo) return;
631
632 // Get the MacroInfo associated with IdentInfo.
633 MacroInfo *MI = getMacroInfo(IdentInfo);
634
635 if (MI) {
636 // Allow the original MacroInfo to be redefined later.
638 }
639
640 // Push the cloned MacroInfo so we can retrieve it later.
641 PragmaPushMacroInfo[IdentInfo].push_back(MI);
642}
643
644/// Handle \#pragma pop_macro.
645///
646/// The syntax is:
647/// \code
648/// #pragma pop_macro("macro")
649/// \endcode
651 SourceLocation MessageLoc = PopMacroTok.getLocation();
652
653 // Parse the pragma directive and get the macro IdentifierInfo*.
654 IdentifierInfo *IdentInfo = ParsePragmaPushOrPopMacro(PopMacroTok);
655 if (!IdentInfo) return;
656
657 // Find the vector<MacroInfo*> associated with the macro.
658 llvm::DenseMap<IdentifierInfo *, std::vector<MacroInfo *>>::iterator iter =
659 PragmaPushMacroInfo.find(IdentInfo);
660 if (iter != PragmaPushMacroInfo.end()) {
661 // Forget the MacroInfo currently associated with IdentInfo.
662 if (MacroInfo *MI = getMacroInfo(IdentInfo)) {
663 if (MI->isWarnIfUnused())
664 WarnUnusedMacroLocs.erase(MI->getDefinitionLoc());
665 appendMacroDirective(IdentInfo, AllocateUndefMacroDirective(MessageLoc));
666 }
667
668 // Get the MacroInfo we want to reinstall.
669 MacroInfo *MacroToReInstall = iter->second.back();
670
671 if (MacroToReInstall)
672 // Reinstall the previously pushed macro.
673 appendDefMacroDirective(IdentInfo, MacroToReInstall, MessageLoc);
674
675 // Pop PragmaPushMacroInfo stack.
676 iter->second.pop_back();
677 if (iter->second.empty())
678 PragmaPushMacroInfo.erase(iter);
679 } else {
680 Diag(MessageLoc, diag::warn_pragma_pop_macro_no_push)
681 << IdentInfo->getName();
682 }
683}
684
686 // We will either get a quoted filename or a bracketed filename, and we
687 // have to track which we got. The first filename is the source name,
688 // and the second name is the mapped filename. If the first is quoted,
689 // the second must be as well (cannot mix and match quotes and brackets).
690
691 // Get the open paren
692 Lex(Tok);
693 if (Tok.isNot(tok::l_paren)) {
694 Diag(Tok, diag::warn_pragma_include_alias_expected) << "(";
695 return;
696 }
697
698 // We expect either a quoted string literal, or a bracketed name
699 Token SourceFilenameTok;
700 if (LexHeaderName(SourceFilenameTok))
701 return;
702
703 StringRef SourceFileName;
704 SmallString<128> FileNameBuffer;
705 if (SourceFilenameTok.is(tok::header_name)) {
706 SourceFileName = getSpelling(SourceFilenameTok, FileNameBuffer);
707 } else {
708 Diag(Tok, diag::warn_pragma_include_alias_expected_filename);
709 return;
710 }
711 FileNameBuffer.clear();
712
713 // Now we expect a comma, followed by another include name
714 Lex(Tok);
715 if (Tok.isNot(tok::comma)) {
716 Diag(Tok, diag::warn_pragma_include_alias_expected) << ",";
717 return;
718 }
719
720 Token ReplaceFilenameTok;
721 if (LexHeaderName(ReplaceFilenameTok))
722 return;
723
724 StringRef ReplaceFileName;
725 if (ReplaceFilenameTok.is(tok::header_name)) {
726 ReplaceFileName = getSpelling(ReplaceFilenameTok, FileNameBuffer);
727 } else {
728 Diag(Tok, diag::warn_pragma_include_alias_expected_filename);
729 return;
730 }
731
732 // Finally, we expect the closing paren
733 Lex(Tok);
734 if (Tok.isNot(tok::r_paren)) {
735 Diag(Tok, diag::warn_pragma_include_alias_expected) << ")";
736 return;
737 }
738
739 // Now that we have the source and target filenames, we need to make sure
740 // they're both of the same type (angled vs non-angled)
741 StringRef OriginalSource = SourceFileName;
742
743 bool SourceIsAngled =
744 GetIncludeFilenameSpelling(SourceFilenameTok.getLocation(),
745 SourceFileName);
746 bool ReplaceIsAngled =
747 GetIncludeFilenameSpelling(ReplaceFilenameTok.getLocation(),
748 ReplaceFileName);
749 if (!SourceFileName.empty() && !ReplaceFileName.empty() &&
750 (SourceIsAngled != ReplaceIsAngled)) {
751 unsigned int DiagID;
752 if (SourceIsAngled)
753 DiagID = diag::warn_pragma_include_alias_mismatch_angle;
754 else
755 DiagID = diag::warn_pragma_include_alias_mismatch_quote;
756
757 Diag(SourceFilenameTok.getLocation(), DiagID)
758 << SourceFileName
759 << ReplaceFileName;
760
761 return;
762 }
763
764 // Now we can let the include handler know about this mapping
765 getHeaderSearchInfo().AddIncludeAlias(OriginalSource, ReplaceFileName);
766}
767
768// Lex a component of a module name: either an identifier or a string literal;
769// for components that can be expressed both ways, the two forms are equivalent.
771 Preprocessor &PP, Token &Tok,
772 std::pair<IdentifierInfo *, SourceLocation> &ModuleNameComponent,
773 bool First) {
774 PP.LexUnexpandedToken(Tok);
775 if (Tok.is(tok::string_literal) && !Tok.hasUDSuffix()) {
776 StringLiteralParser Literal(Tok, PP);
777 if (Literal.hadError)
778 return true;
779 ModuleNameComponent = std::make_pair(
780 PP.getIdentifierInfo(Literal.GetString()), Tok.getLocation());
781 } else if (!Tok.isAnnotation() && Tok.getIdentifierInfo()) {
782 ModuleNameComponent =
783 std::make_pair(Tok.getIdentifierInfo(), Tok.getLocation());
784 } else {
785 PP.Diag(Tok.getLocation(), diag::err_pp_expected_module_name) << First;
786 return true;
787 }
788 return false;
789}
790
791static bool LexModuleName(
792 Preprocessor &PP, Token &Tok,
793 llvm::SmallVectorImpl<std::pair<IdentifierInfo *, SourceLocation>>
794 &ModuleName) {
795 while (true) {
796 std::pair<IdentifierInfo*, SourceLocation> NameComponent;
797 if (LexModuleNameComponent(PP, Tok, NameComponent, ModuleName.empty()))
798 return true;
799 ModuleName.push_back(NameComponent);
800
801 PP.LexUnexpandedToken(Tok);
802 if (Tok.isNot(tok::period))
803 return false;
804 }
805}
806
809
810 std::pair<IdentifierInfo *, SourceLocation> ModuleNameLoc;
811 if (LexModuleNameComponent(*this, Tok, ModuleNameLoc, true))
812 return;
813 IdentifierInfo *ModuleName = ModuleNameLoc.first;
814
816 if (Tok.isNot(tok::eod)) {
817 Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
819 }
820
821 CurLexer->LexingRawMode = true;
822
823 auto TryConsumeIdentifier = [&](StringRef Ident) -> bool {
824 if (Tok.getKind() != tok::raw_identifier ||
825 Tok.getRawIdentifier() != Ident)
826 return false;
827 CurLexer->Lex(Tok);
828 return true;
829 };
830
831 // Scan forward looking for the end of the module.
832 const char *Start = CurLexer->getBufferLocation();
833 const char *End = nullptr;
834 unsigned NestingLevel = 1;
835 while (true) {
836 End = CurLexer->getBufferLocation();
837 CurLexer->Lex(Tok);
838
839 if (Tok.is(tok::eof)) {
840 Diag(Loc, diag::err_pp_module_build_missing_end);
841 break;
842 }
843
844 if (Tok.isNot(tok::hash) || !Tok.isAtStartOfLine()) {
845 // Token was part of module; keep going.
846 continue;
847 }
848
849 // We hit something directive-shaped; check to see if this is the end
850 // of the module build.
851 CurLexer->ParsingPreprocessorDirective = true;
852 CurLexer->Lex(Tok);
853 if (TryConsumeIdentifier("pragma") && TryConsumeIdentifier("clang") &&
854 TryConsumeIdentifier("module")) {
855 if (TryConsumeIdentifier("build"))
856 // #pragma clang module build -> entering a nested module build.
857 ++NestingLevel;
858 else if (TryConsumeIdentifier("endbuild")) {
859 // #pragma clang module endbuild -> leaving a module build.
860 if (--NestingLevel == 0)
861 break;
862 }
863 // We should either be looking at the EOD or more of the current directive
864 // preceding the EOD. Either way we can ignore this token and keep going.
865 assert(Tok.getKind() != tok::eof && "missing EOD before EOF");
866 }
867 }
868
869 CurLexer->LexingRawMode = false;
870
871 // Load the extracted text as a preprocessed module.
872 assert(CurLexer->getBuffer().begin() <= Start &&
873 Start <= CurLexer->getBuffer().end() &&
874 CurLexer->getBuffer().begin() <= End &&
875 End <= CurLexer->getBuffer().end() &&
876 "module source range not contained within same file buffer");
877 TheModuleLoader.createModuleFromSource(Loc, ModuleName->getName(),
878 StringRef(Start, End - Start));
879}
880
882 Lex(Tok);
883 if (Tok.is(tok::l_paren)) {
884 Diag(Tok.getLocation(), diag::warn_pp_hdrstop_filename_ignored);
885
886 std::string FileName;
887 if (!LexStringLiteral(Tok, FileName, "pragma hdrstop", false))
888 return;
889
890 if (Tok.isNot(tok::r_paren)) {
891 Diag(Tok, diag::err_expected) << tok::r_paren;
892 return;
893 }
894 Lex(Tok);
895 }
896 if (Tok.isNot(tok::eod))
897 Diag(Tok.getLocation(), diag::ext_pp_extra_tokens_at_eol)
898 << "pragma hdrstop";
899
901 SourceMgr.isInMainFile(Tok.getLocation())) {
902 assert(CurLexer && "no lexer for #pragma hdrstop processing");
903 Token &Result = Tok;
904 Result.startToken();
905 CurLexer->FormTokenWithChars(Result, CurLexer->BufferEnd, tok::eof);
906 CurLexer->cutOffLexing();
907 }
909 SkippingUntilPragmaHdrStop = false;
910}
911
912/// AddPragmaHandler - Add the specified pragma handler to the preprocessor.
913/// If 'Namespace' is non-null, then it is a token required to exist on the
914/// pragma line before the pragma string starts, e.g. "STDC" or "GCC".
915void Preprocessor::AddPragmaHandler(StringRef Namespace,
916 PragmaHandler *Handler) {
917 PragmaNamespace *InsertNS = PragmaHandlers.get();
918
919 // If this is specified to be in a namespace, step down into it.
920 if (!Namespace.empty()) {
921 // If there is already a pragma handler with the name of this namespace,
922 // we either have an error (directive with the same name as a namespace) or
923 // we already have the namespace to insert into.
924 if (PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace)) {
925 InsertNS = Existing->getIfNamespace();
926 assert(InsertNS != nullptr && "Cannot have a pragma namespace and pragma"
927 " handler with the same name!");
928 } else {
929 // Otherwise, this namespace doesn't exist yet, create and insert the
930 // handler for it.
931 InsertNS = new PragmaNamespace(Namespace);
932 PragmaHandlers->AddPragma(InsertNS);
933 }
934 }
935
936 // Check to make sure we don't already have a pragma for this identifier.
937 assert(!InsertNS->FindHandler(Handler->getName()) &&
938 "Pragma handler already exists for this identifier!");
939 InsertNS->AddPragma(Handler);
940}
941
942/// RemovePragmaHandler - Remove the specific pragma handler from the
943/// preprocessor. If \arg Namespace is non-null, then it should be the
944/// namespace that \arg Handler was added to. It is an error to remove
945/// a handler that has not been registered.
946void Preprocessor::RemovePragmaHandler(StringRef Namespace,
947 PragmaHandler *Handler) {
948 PragmaNamespace *NS = PragmaHandlers.get();
949
950 // If this is specified to be in a namespace, step down into it.
951 if (!Namespace.empty()) {
952 PragmaHandler *Existing = PragmaHandlers->FindHandler(Namespace);
953 assert(Existing && "Namespace containing handler does not exist!");
954
955 NS = Existing->getIfNamespace();
956 assert(NS && "Invalid namespace, registered as a regular pragma handler!");
957 }
958
959 NS->RemovePragmaHandler(Handler);
960
961 // If this is a non-default namespace and it is now empty, remove it.
962 if (NS != PragmaHandlers.get() && NS->IsEmpty()) {
963 PragmaHandlers->RemovePragmaHandler(NS);
964 delete NS;
965 }
966}
967
969 Token Tok;
971
972 if (Tok.isNot(tok::identifier)) {
973 Diag(Tok, diag::ext_on_off_switch_syntax);
974 return true;
975 }
977 if (II->isStr("ON"))
979 else if (II->isStr("OFF"))
981 else if (II->isStr("DEFAULT"))
983 else {
984 Diag(Tok, diag::ext_on_off_switch_syntax);
985 return true;
986 }
987
988 // Verify that this is followed by EOD.
990 if (Tok.isNot(tok::eod))
991 Diag(Tok, diag::ext_pragma_syntax_eod);
992 return false;
993}
994
995namespace {
996
997/// PragmaOnceHandler - "\#pragma once" marks the file as atomically included.
998struct PragmaOnceHandler : public PragmaHandler {
999 PragmaOnceHandler() : PragmaHandler("once") {}
1000
1001 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1002 Token &OnceTok) override {
1003 PP.CheckEndOfDirective("pragma once");
1004 PP.HandlePragmaOnce(OnceTok);
1005 }
1006};
1007
1008/// PragmaMarkHandler - "\#pragma mark ..." is ignored by the compiler, and the
1009/// rest of the line is not lexed.
1010struct PragmaMarkHandler : public PragmaHandler {
1011 PragmaMarkHandler() : PragmaHandler("mark") {}
1012
1013 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1014 Token &MarkTok) override {
1015 PP.HandlePragmaMark(MarkTok);
1016 }
1017};
1018
1019/// PragmaPoisonHandler - "\#pragma poison x" marks x as not usable.
1020struct PragmaPoisonHandler : public PragmaHandler {
1021 PragmaPoisonHandler() : PragmaHandler("poison") {}
1022
1023 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1024 Token &PoisonTok) override {
1025 PP.HandlePragmaPoison();
1026 }
1027};
1028
1029/// PragmaSystemHeaderHandler - "\#pragma system_header" marks the current file
1030/// as a system header, which silences warnings in it.
1031struct PragmaSystemHeaderHandler : public PragmaHandler {
1032 PragmaSystemHeaderHandler() : PragmaHandler("system_header") {}
1033
1034 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1035 Token &SHToken) override {
1036 PP.HandlePragmaSystemHeader(SHToken);
1037 PP.CheckEndOfDirective("pragma");
1038 }
1039};
1040
1041struct PragmaDependencyHandler : public PragmaHandler {
1042 PragmaDependencyHandler() : PragmaHandler("dependency") {}
1043
1044 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1045 Token &DepToken) override {
1046 PP.HandlePragmaDependency(DepToken);
1047 }
1048};
1049
1050struct PragmaDebugHandler : public PragmaHandler {
1051 PragmaDebugHandler() : PragmaHandler("__debug") {}
1052
1053 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1054 Token &DebugToken) override {
1055 Token Tok;
1056 PP.LexUnexpandedToken(Tok);
1057 if (Tok.isNot(tok::identifier)) {
1058 PP.Diag(Tok, diag::warn_pragma_debug_missing_command);
1059 return;
1060 }
1062
1063 if (II->isStr("assert")) {
1065 llvm_unreachable("This is an assertion!");
1066 } else if (II->isStr("crash")) {
1067 llvm::Timer T("crash", "pragma crash");
1068 llvm::TimeRegion R(&T);
1070 LLVM_BUILTIN_TRAP;
1071 } else if (II->isStr("parser_crash")) {
1073 Token Crasher;
1074 Crasher.startToken();
1075 Crasher.setKind(tok::annot_pragma_parser_crash);
1077 PP.EnterToken(Crasher, /*IsReinject*/ false);
1078 }
1079 } else if (II->isStr("dump")) {
1080 Token DumpAnnot;
1081 DumpAnnot.startToken();
1082 DumpAnnot.setKind(tok::annot_pragma_dump);
1083 DumpAnnot.setAnnotationRange(SourceRange(Tok.getLocation()));
1084 PP.EnterToken(DumpAnnot, /*IsReinject*/false);
1085 } else if (II->isStr("diag_mapping")) {
1086 Token DiagName;
1087 PP.LexUnexpandedToken(DiagName);
1088 if (DiagName.is(tok::eod))
1089 PP.getDiagnostics().dump();
1090 else if (DiagName.is(tok::string_literal) && !DiagName.hasUDSuffix()) {
1091 StringLiteralParser Literal(DiagName, PP,
1092 StringLiteralEvalMethod::Unevaluated);
1093 if (Literal.hadError)
1094 return;
1095 PP.getDiagnostics().dump(Literal.GetString());
1096 } else {
1097 PP.Diag(DiagName, diag::warn_pragma_debug_missing_argument)
1098 << II->getName();
1099 }
1100 } else if (II->isStr("llvm_fatal_error")) {
1102 llvm::report_fatal_error("#pragma clang __debug llvm_fatal_error");
1103 } else if (II->isStr("llvm_unreachable")) {
1105 llvm_unreachable("#pragma clang __debug llvm_unreachable");
1106 } else if (II->isStr("macro")) {
1107 Token MacroName;
1108 PP.LexUnexpandedToken(MacroName);
1109 auto *MacroII = MacroName.getIdentifierInfo();
1110 if (MacroII)
1111 PP.dumpMacroInfo(MacroII);
1112 else
1113 PP.Diag(MacroName, diag::warn_pragma_debug_missing_argument)
1114 << II->getName();
1115 } else if (II->isStr("module_map")) {
1117 ModuleName;
1118 if (LexModuleName(PP, Tok, ModuleName))
1119 return;
1121 Module *M = nullptr;
1122 for (auto IIAndLoc : ModuleName) {
1123 M = MM.lookupModuleQualified(IIAndLoc.first->getName(), M);
1124 if (!M) {
1125 PP.Diag(IIAndLoc.second, diag::warn_pragma_debug_unknown_module)
1126 << IIAndLoc.first;
1127 return;
1128 }
1129 }
1130 M->dump();
1131 } else if (II->isStr("overflow_stack")) {
1133 DebugOverflowStack();
1134 } else if (II->isStr("captured")) {
1135 HandleCaptured(PP);
1136 } else if (II->isStr("modules")) {
1137 struct ModuleVisitor {
1138 Preprocessor &PP;
1139 void visit(Module *M, bool VisibleOnly) {
1140 SourceLocation ImportLoc = PP.getModuleImportLoc(M);
1141 if (!VisibleOnly || ImportLoc.isValid()) {
1142 llvm::errs() << M->getFullModuleName() << " ";
1143 if (ImportLoc.isValid()) {
1144 llvm::errs() << M << " visible ";
1145 ImportLoc.print(llvm::errs(), PP.getSourceManager());
1146 }
1147 llvm::errs() << "\n";
1148 }
1149 for (Module *Sub : M->submodules()) {
1150 if (!VisibleOnly || ImportLoc.isInvalid() || Sub->IsExplicit)
1151 visit(Sub, VisibleOnly);
1152 }
1153 }
1154 void visitAll(bool VisibleOnly) {
1155 for (auto &NameAndMod :
1157 visit(NameAndMod.second, VisibleOnly);
1158 }
1159 } Visitor{PP};
1160
1161 Token Kind;
1163 auto *DumpII = Kind.getIdentifierInfo();
1164 if (!DumpII) {
1165 PP.Diag(Kind, diag::warn_pragma_debug_missing_argument)
1166 << II->getName();
1167 } else if (DumpII->isStr("all")) {
1168 Visitor.visitAll(false);
1169 } else if (DumpII->isStr("visible")) {
1170 Visitor.visitAll(true);
1171 } else if (DumpII->isStr("building")) {
1172 for (auto &Building : PP.getBuildingSubmodules()) {
1173 llvm::errs() << "in " << Building.M->getFullModuleName();
1174 if (Building.ImportLoc.isValid()) {
1175 llvm::errs() << " imported ";
1176 if (Building.IsPragma)
1177 llvm::errs() << "via pragma ";
1178 llvm::errs() << "at ";
1179 Building.ImportLoc.print(llvm::errs(), PP.getSourceManager());
1180 llvm::errs() << "\n";
1181 }
1182 }
1183 } else {
1184 PP.Diag(Tok, diag::warn_pragma_debug_unexpected_command)
1185 << DumpII->getName();
1186 }
1187 } else if (II->isStr("sloc_usage")) {
1188 // An optional integer literal argument specifies the number of files to
1189 // specifically report information about.
1190 std::optional<unsigned> MaxNotes;
1191 Token ArgToken;
1192 PP.Lex(ArgToken);
1194 if (ArgToken.is(tok::numeric_constant) &&
1195 PP.parseSimpleIntegerLiteral(ArgToken, Value)) {
1196 MaxNotes = Value;
1197 } else if (ArgToken.isNot(tok::eod)) {
1198 PP.Diag(ArgToken, diag::warn_pragma_debug_unexpected_argument);
1199 }
1200
1201 PP.Diag(Tok, diag::remark_sloc_usage);
1203 MaxNotes);
1204 } else {
1205 PP.Diag(Tok, diag::warn_pragma_debug_unexpected_command)
1206 << II->getName();
1207 }
1208
1209 PPCallbacks *Callbacks = PP.getPPCallbacks();
1210 if (Callbacks)
1211 Callbacks->PragmaDebug(Tok.getLocation(), II->getName());
1212 }
1213
1214 void HandleCaptured(Preprocessor &PP) {
1215 Token Tok;
1216 PP.LexUnexpandedToken(Tok);
1217
1218 if (Tok.isNot(tok::eod)) {
1219 PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol)
1220 << "pragma clang __debug captured";
1221 return;
1222 }
1223
1224 SourceLocation NameLoc = Tok.getLocation();
1226 PP.getPreprocessorAllocator().Allocate<Token>(1), 1);
1227 Toks[0].startToken();
1228 Toks[0].setKind(tok::annot_pragma_captured);
1229 Toks[0].setLocation(NameLoc);
1230
1231 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
1232 /*IsReinject=*/false);
1233 }
1234
1235// Disable MSVC warning about runtime stack overflow.
1236#ifdef _MSC_VER
1237 #pragma warning(disable : 4717)
1238#endif
1239 static void DebugOverflowStack(void (*P)() = nullptr) {
1240 void (*volatile Self)(void(*P)()) = DebugOverflowStack;
1241 Self(reinterpret_cast<void(*)()>(Self));
1242 }
1243#ifdef _MSC_VER
1244 #pragma warning(default : 4717)
1245#endif
1246};
1247
1248struct PragmaUnsafeBufferUsageHandler : public PragmaHandler {
1249 PragmaUnsafeBufferUsageHandler() : PragmaHandler("unsafe_buffer_usage") {}
1250 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1251 Token &FirstToken) override {
1252 Token Tok;
1253
1254 PP.LexUnexpandedToken(Tok);
1255 if (Tok.isNot(tok::identifier)) {
1256 PP.Diag(Tok, diag::err_pp_pragma_unsafe_buffer_usage_syntax);
1257 return;
1258 }
1259
1262
1263 if (II->isStr("begin")) {
1265 PP.Diag(Loc, diag::err_pp_double_begin_pragma_unsafe_buffer_usage);
1266 } else if (II->isStr("end")) {
1268 PP.Diag(Loc, diag::err_pp_unmatched_end_begin_pragma_unsafe_buffer_usage);
1269 } else
1270 PP.Diag(Tok, diag::err_pp_pragma_unsafe_buffer_usage_syntax);
1271 }
1272};
1273
1274/// PragmaDiagnosticHandler - e.g. '\#pragma GCC diagnostic ignored "-Wformat"'
1275struct PragmaDiagnosticHandler : public PragmaHandler {
1276private:
1277 const char *Namespace;
1278
1279public:
1280 explicit PragmaDiagnosticHandler(const char *NS)
1281 : PragmaHandler("diagnostic"), Namespace(NS) {}
1282
1283 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1284 Token &DiagToken) override {
1285 SourceLocation DiagLoc = DiagToken.getLocation();
1286 Token Tok;
1287 PP.LexUnexpandedToken(Tok);
1288 if (Tok.isNot(tok::identifier)) {
1289 PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
1290 return;
1291 }
1293 PPCallbacks *Callbacks = PP.getPPCallbacks();
1294
1295 // Get the next token, which is either an EOD or a string literal. We lex
1296 // it now so that we can early return if the previous token was push or pop.
1297 PP.LexUnexpandedToken(Tok);
1298
1299 if (II->isStr("pop")) {
1300 if (!PP.getDiagnostics().popMappings(DiagLoc))
1301 PP.Diag(Tok, diag::warn_pragma_diagnostic_cannot_pop);
1302 else if (Callbacks)
1303 Callbacks->PragmaDiagnosticPop(DiagLoc, Namespace);
1304
1305 if (Tok.isNot(tok::eod))
1306 PP.Diag(Tok.getLocation(), diag::warn_pragma_diagnostic_invalid_token);
1307 return;
1308 } else if (II->isStr("push")) {
1309 PP.getDiagnostics().pushMappings(DiagLoc);
1310 if (Callbacks)
1311 Callbacks->PragmaDiagnosticPush(DiagLoc, Namespace);
1312
1313 if (Tok.isNot(tok::eod))
1314 PP.Diag(Tok.getLocation(), diag::warn_pragma_diagnostic_invalid_token);
1315 return;
1316 }
1317
1318 diag::Severity SV = llvm::StringSwitch<diag::Severity>(II->getName())
1319 .Case("ignored", diag::Severity::Ignored)
1320 .Case("warning", diag::Severity::Warning)
1321 .Case("error", diag::Severity::Error)
1322 .Case("fatal", diag::Severity::Fatal)
1323 .Default(diag::Severity());
1324
1325 if (SV == diag::Severity()) {
1326 PP.Diag(Tok, diag::warn_pragma_diagnostic_invalid);
1327 return;
1328 }
1329
1330 // At this point, we expect a string literal.
1331 SourceLocation StringLoc = Tok.getLocation();
1332 std::string WarningName;
1333 if (!PP.FinishLexStringLiteral(Tok, WarningName, "pragma diagnostic",
1334 /*AllowMacroExpansion=*/false))
1335 return;
1336
1337 if (Tok.isNot(tok::eod)) {
1338 PP.Diag(Tok.getLocation(), diag::warn_pragma_diagnostic_invalid_token);
1339 return;
1340 }
1341
1342 if (WarningName.size() < 3 || WarningName[0] != '-' ||
1343 (WarningName[1] != 'W' && WarningName[1] != 'R')) {
1344 PP.Diag(StringLoc, diag::warn_pragma_diagnostic_invalid_option);
1345 return;
1346 }
1347
1348 diag::Flavor Flavor = WarningName[1] == 'W' ? diag::Flavor::WarningOrError
1349 : diag::Flavor::Remark;
1350 StringRef Group = StringRef(WarningName).substr(2);
1351 bool unknownDiag = false;
1352 if (Group == "everything") {
1353 // Special handling for pragma clang diagnostic ... "-Weverything".
1354 // There is no formal group named "everything", so there has to be a
1355 // special case for it.
1356 PP.getDiagnostics().setSeverityForAll(Flavor, SV, DiagLoc);
1357 } else
1358 unknownDiag = PP.getDiagnostics().setSeverityForGroup(Flavor, Group, SV,
1359 DiagLoc);
1360 if (unknownDiag)
1361 PP.Diag(StringLoc, diag::warn_pragma_diagnostic_unknown_warning)
1362 << WarningName;
1363 else if (Callbacks)
1364 Callbacks->PragmaDiagnostic(DiagLoc, Namespace, SV, WarningName);
1365 }
1366};
1367
1368/// "\#pragma hdrstop [<header-name-string>]"
1369struct PragmaHdrstopHandler : public PragmaHandler {
1370 PragmaHdrstopHandler() : PragmaHandler("hdrstop") {}
1371 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1372 Token &DepToken) override {
1373 PP.HandlePragmaHdrstop(DepToken);
1374 }
1375};
1376
1377/// "\#pragma warning(...)". MSVC's diagnostics do not map cleanly to clang's
1378/// diagnostics, so we don't really implement this pragma. We parse it and
1379/// ignore it to avoid -Wunknown-pragma warnings.
1380struct PragmaWarningHandler : public PragmaHandler {
1381 PragmaWarningHandler() : PragmaHandler("warning") {}
1382
1383 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1384 Token &Tok) override {
1385 // Parse things like:
1386 // warning(push, 1)
1387 // warning(pop)
1388 // warning(disable : 1 2 3 ; error : 4 5 6 ; suppress : 7 8 9)
1389 SourceLocation DiagLoc = Tok.getLocation();
1390 PPCallbacks *Callbacks = PP.getPPCallbacks();
1391
1392 PP.Lex(Tok);
1393 if (Tok.isNot(tok::l_paren)) {
1394 PP.Diag(Tok, diag::warn_pragma_warning_expected) << "(";
1395 return;
1396 }
1397
1398 PP.Lex(Tok);
1400
1401 if (II && II->isStr("push")) {
1402 // #pragma warning( push[ ,n ] )
1403 int Level = -1;
1404 PP.Lex(Tok);
1405 if (Tok.is(tok::comma)) {
1406 PP.Lex(Tok);
1408 if (Tok.is(tok::numeric_constant) &&
1410 Level = int(Value);
1411 if (Level < 0 || Level > 4) {
1412 PP.Diag(Tok, diag::warn_pragma_warning_push_level);
1413 return;
1414 }
1415 }
1416 PP.getDiagnostics().pushMappings(DiagLoc);
1417 if (Callbacks)
1418 Callbacks->PragmaWarningPush(DiagLoc, Level);
1419 } else if (II && II->isStr("pop")) {
1420 // #pragma warning( pop )
1421 PP.Lex(Tok);
1422 if (!PP.getDiagnostics().popMappings(DiagLoc))
1423 PP.Diag(Tok, diag::warn_pragma_diagnostic_cannot_pop);
1424 else if (Callbacks)
1425 Callbacks->PragmaWarningPop(DiagLoc);
1426 } else {
1427 // #pragma warning( warning-specifier : warning-number-list
1428 // [; warning-specifier : warning-number-list...] )
1429 while (true) {
1430 II = Tok.getIdentifierInfo();
1431 if (!II && !Tok.is(tok::numeric_constant)) {
1432 PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid);
1433 return;
1434 }
1435
1436 // Figure out which warning specifier this is.
1437 bool SpecifierValid;
1439 if (II) {
1440 int SpecifierInt = llvm::StringSwitch<int>(II->getName())
1441 .Case("default", PPCallbacks::PWS_Default)
1442 .Case("disable", PPCallbacks::PWS_Disable)
1443 .Case("error", PPCallbacks::PWS_Error)
1444 .Case("once", PPCallbacks::PWS_Once)
1445 .Case("suppress", PPCallbacks::PWS_Suppress)
1446 .Default(-1);
1447 SpecifierValid = SpecifierInt != -1;
1448 if (SpecifierValid)
1449 Specifier =
1450 static_cast<PPCallbacks::PragmaWarningSpecifier>(SpecifierInt);
1451
1452 // If we read a correct specifier, snatch next token (that should be
1453 // ":", checked later).
1454 if (SpecifierValid)
1455 PP.Lex(Tok);
1456 } else {
1457 // Token is a numeric constant. It should be either 1, 2, 3 or 4.
1459 if (PP.parseSimpleIntegerLiteral(Tok, Value)) {
1460 if ((SpecifierValid = (Value >= 1) && (Value <= 4)))
1463 } else
1464 SpecifierValid = false;
1465 // Next token already snatched by parseSimpleIntegerLiteral.
1466 }
1467
1468 if (!SpecifierValid) {
1469 PP.Diag(Tok, diag::warn_pragma_warning_spec_invalid);
1470 return;
1471 }
1472 if (Tok.isNot(tok::colon)) {
1473 PP.Diag(Tok, diag::warn_pragma_warning_expected) << ":";
1474 return;
1475 }
1476
1477 // Collect the warning ids.
1479 PP.Lex(Tok);
1480 while (Tok.is(tok::numeric_constant)) {
1482 if (!PP.parseSimpleIntegerLiteral(Tok, Value) || Value == 0 ||
1483 Value > INT_MAX) {
1484 PP.Diag(Tok, diag::warn_pragma_warning_expected_number);
1485 return;
1486 }
1487 Ids.push_back(int(Value));
1488 }
1489
1490 // Only act on disable for now.
1493 SV = diag::Severity::Ignored;
1494 if (SV != diag::Severity())
1495 for (int Id : Ids) {
1496 if (auto Group = diagGroupFromCLWarningID(Id)) {
1497 bool unknownDiag = PP.getDiagnostics().setSeverityForGroup(
1498 diag::Flavor::WarningOrError, *Group, SV, DiagLoc);
1499 assert(!unknownDiag &&
1500 "wd table should only contain known diags");
1501 (void)unknownDiag;
1502 }
1503 }
1504
1505 if (Callbacks)
1506 Callbacks->PragmaWarning(DiagLoc, Specifier, Ids);
1507
1508 // Parse the next specifier if there is a semicolon.
1509 if (Tok.isNot(tok::semi))
1510 break;
1511 PP.Lex(Tok);
1512 }
1513 }
1514
1515 if (Tok.isNot(tok::r_paren)) {
1516 PP.Diag(Tok, diag::warn_pragma_warning_expected) << ")";
1517 return;
1518 }
1519
1520 PP.Lex(Tok);
1521 if (Tok.isNot(tok::eod))
1522 PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma warning";
1523 }
1524};
1525
1526/// "\#pragma execution_character_set(...)". MSVC supports this pragma only
1527/// for "UTF-8". We parse it and ignore it if UTF-8 is provided and warn
1528/// otherwise to avoid -Wunknown-pragma warnings.
1529struct PragmaExecCharsetHandler : public PragmaHandler {
1530 PragmaExecCharsetHandler() : PragmaHandler("execution_character_set") {}
1531
1532 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1533 Token &Tok) override {
1534 // Parse things like:
1535 // execution_character_set(push, "UTF-8")
1536 // execution_character_set(pop)
1537 SourceLocation DiagLoc = Tok.getLocation();
1538 PPCallbacks *Callbacks = PP.getPPCallbacks();
1539
1540 PP.Lex(Tok);
1541 if (Tok.isNot(tok::l_paren)) {
1542 PP.Diag(Tok, diag::warn_pragma_exec_charset_expected) << "(";
1543 return;
1544 }
1545
1546 PP.Lex(Tok);
1548
1549 if (II && II->isStr("push")) {
1550 // #pragma execution_character_set( push[ , string ] )
1551 PP.Lex(Tok);
1552 if (Tok.is(tok::comma)) {
1553 PP.Lex(Tok);
1554
1555 std::string ExecCharset;
1556 if (!PP.FinishLexStringLiteral(Tok, ExecCharset,
1557 "pragma execution_character_set",
1558 /*AllowMacroExpansion=*/false))
1559 return;
1560
1561 // MSVC supports either of these, but nothing else.
1562 if (ExecCharset != "UTF-8" && ExecCharset != "utf-8") {
1563 PP.Diag(Tok, diag::warn_pragma_exec_charset_push_invalid) << ExecCharset;
1564 return;
1565 }
1566 }
1567 if (Callbacks)
1568 Callbacks->PragmaExecCharsetPush(DiagLoc, "UTF-8");
1569 } else if (II && II->isStr("pop")) {
1570 // #pragma execution_character_set( pop )
1571 PP.Lex(Tok);
1572 if (Callbacks)
1573 Callbacks->PragmaExecCharsetPop(DiagLoc);
1574 } else {
1575 PP.Diag(Tok, diag::warn_pragma_exec_charset_spec_invalid);
1576 return;
1577 }
1578
1579 if (Tok.isNot(tok::r_paren)) {
1580 PP.Diag(Tok, diag::warn_pragma_exec_charset_expected) << ")";
1581 return;
1582 }
1583
1584 PP.Lex(Tok);
1585 if (Tok.isNot(tok::eod))
1586 PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma execution_character_set";
1587 }
1588};
1589
1590/// PragmaIncludeAliasHandler - "\#pragma include_alias("...")".
1591struct PragmaIncludeAliasHandler : public PragmaHandler {
1592 PragmaIncludeAliasHandler() : PragmaHandler("include_alias") {}
1593
1594 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1595 Token &IncludeAliasTok) override {
1596 PP.HandlePragmaIncludeAlias(IncludeAliasTok);
1597 }
1598};
1599
1600/// PragmaMessageHandler - Handle the microsoft and gcc \#pragma message
1601/// extension. The syntax is:
1602/// \code
1603/// #pragma message(string)
1604/// \endcode
1605/// OR, in GCC mode:
1606/// \code
1607/// #pragma message string
1608/// \endcode
1609/// string is a string, which is fully macro expanded, and permits string
1610/// concatenation, embedded escape characters, etc... See MSDN for more details.
1611/// Also handles \#pragma GCC warning and \#pragma GCC error which take the same
1612/// form as \#pragma message.
1613struct PragmaMessageHandler : public PragmaHandler {
1614private:
1616 const StringRef Namespace;
1617
1618 static const char* PragmaKind(PPCallbacks::PragmaMessageKind Kind,
1619 bool PragmaNameOnly = false) {
1620 switch (Kind) {
1622 return PragmaNameOnly ? "message" : "pragma message";
1624 return PragmaNameOnly ? "warning" : "pragma warning";
1626 return PragmaNameOnly ? "error" : "pragma error";
1627 }
1628 llvm_unreachable("Unknown PragmaMessageKind!");
1629 }
1630
1631public:
1632 PragmaMessageHandler(PPCallbacks::PragmaMessageKind Kind,
1633 StringRef Namespace = StringRef())
1634 : PragmaHandler(PragmaKind(Kind, true)), Kind(Kind),
1636
1637 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1638 Token &Tok) override {
1639 SourceLocation MessageLoc = Tok.getLocation();
1640 PP.Lex(Tok);
1641 bool ExpectClosingParen = false;
1642 switch (Tok.getKind()) {
1643 case tok::l_paren:
1644 // We have a MSVC style pragma message.
1645 ExpectClosingParen = true;
1646 // Read the string.
1647 PP.Lex(Tok);
1648 break;
1649 case tok::string_literal:
1650 // We have a GCC style pragma message, and we just read the string.
1651 break;
1652 default:
1653 PP.Diag(MessageLoc, diag::err_pragma_message_malformed) << Kind;
1654 return;
1655 }
1656
1657 std::string MessageString;
1658 if (!PP.FinishLexStringLiteral(Tok, MessageString, PragmaKind(Kind),
1659 /*AllowMacroExpansion=*/true))
1660 return;
1661
1662 if (ExpectClosingParen) {
1663 if (Tok.isNot(tok::r_paren)) {
1664 PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind;
1665 return;
1666 }
1667 PP.Lex(Tok); // eat the r_paren.
1668 }
1669
1670 if (Tok.isNot(tok::eod)) {
1671 PP.Diag(Tok.getLocation(), diag::err_pragma_message_malformed) << Kind;
1672 return;
1673 }
1674
1675 // Output the message.
1676 PP.Diag(MessageLoc, (Kind == PPCallbacks::PMK_Error)
1677 ? diag::err_pragma_message
1678 : diag::warn_pragma_message) << MessageString;
1679
1680 // If the pragma is lexically sound, notify any interested PPCallbacks.
1681 if (PPCallbacks *Callbacks = PP.getPPCallbacks())
1682 Callbacks->PragmaMessage(MessageLoc, Namespace, Kind, MessageString);
1683 }
1684};
1685
1686/// Handle the clang \#pragma module import extension. The syntax is:
1687/// \code
1688/// #pragma clang module import some.module.name
1689/// \endcode
1690struct PragmaModuleImportHandler : public PragmaHandler {
1691 PragmaModuleImportHandler() : PragmaHandler("import") {}
1692
1693 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1694 Token &Tok) override {
1695 SourceLocation ImportLoc = Tok.getLocation();
1696
1697 // Read the module name.
1699 ModuleName;
1700 if (LexModuleName(PP, Tok, ModuleName))
1701 return;
1702
1703 if (Tok.isNot(tok::eod))
1704 PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1705
1706 // If we have a non-empty module path, load the named module.
1707 Module *Imported =
1708 PP.getModuleLoader().loadModule(ImportLoc, ModuleName, Module::Hidden,
1709 /*IsInclusionDirective=*/false);
1710 if (!Imported)
1711 return;
1712
1713 PP.makeModuleVisible(Imported, ImportLoc);
1714 PP.EnterAnnotationToken(SourceRange(ImportLoc, ModuleName.back().second),
1715 tok::annot_module_include, Imported);
1716 if (auto *CB = PP.getPPCallbacks())
1717 CB->moduleImport(ImportLoc, ModuleName, Imported);
1718 }
1719};
1720
1721/// Handle the clang \#pragma module begin extension. The syntax is:
1722/// \code
1723/// #pragma clang module begin some.module.name
1724/// ...
1725/// #pragma clang module end
1726/// \endcode
1727struct PragmaModuleBeginHandler : public PragmaHandler {
1728 PragmaModuleBeginHandler() : PragmaHandler("begin") {}
1729
1730 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1731 Token &Tok) override {
1732 SourceLocation BeginLoc = Tok.getLocation();
1733
1734 // Read the module name.
1736 ModuleName;
1737 if (LexModuleName(PP, Tok, ModuleName))
1738 return;
1739
1740 if (Tok.isNot(tok::eod))
1741 PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1742
1743 // We can only enter submodules of the current module.
1744 StringRef Current = PP.getLangOpts().CurrentModule;
1745 if (ModuleName.front().first->getName() != Current) {
1746 PP.Diag(ModuleName.front().second, diag::err_pp_module_begin_wrong_module)
1747 << ModuleName.front().first << (ModuleName.size() > 1)
1748 << Current.empty() << Current;
1749 return;
1750 }
1751
1752 // Find the module we're entering. We require that a module map for it
1753 // be loaded or implicitly loadable.
1754 auto &HSI = PP.getHeaderSearchInfo();
1755 Module *M = HSI.lookupModule(Current, ModuleName.front().second);
1756 if (!M) {
1757 PP.Diag(ModuleName.front().second,
1758 diag::err_pp_module_begin_no_module_map) << Current;
1759 return;
1760 }
1761 for (unsigned I = 1; I != ModuleName.size(); ++I) {
1762 auto *NewM = M->findOrInferSubmodule(ModuleName[I].first->getName());
1763 if (!NewM) {
1764 PP.Diag(ModuleName[I].second, diag::err_pp_module_begin_no_submodule)
1765 << M->getFullModuleName() << ModuleName[I].first;
1766 return;
1767 }
1768 M = NewM;
1769 }
1770
1771 // If the module isn't available, it doesn't make sense to enter it.
1773 PP.getLangOpts(), PP.getTargetInfo(), *M, PP.getDiagnostics())) {
1774 PP.Diag(BeginLoc, diag::note_pp_module_begin_here)
1775 << M->getTopLevelModuleName();
1776 return;
1777 }
1778
1779 // Enter the scope of the submodule.
1780 PP.EnterSubmodule(M, BeginLoc, /*ForPragma*/true);
1781 PP.EnterAnnotationToken(SourceRange(BeginLoc, ModuleName.back().second),
1782 tok::annot_module_begin, M);
1783 }
1784};
1785
1786/// Handle the clang \#pragma module end extension.
1787struct PragmaModuleEndHandler : public PragmaHandler {
1788 PragmaModuleEndHandler() : PragmaHandler("end") {}
1789
1790 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1791 Token &Tok) override {
1793
1794 PP.LexUnexpandedToken(Tok);
1795 if (Tok.isNot(tok::eod))
1796 PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1797
1798 Module *M = PP.LeaveSubmodule(/*ForPragma*/true);
1799 if (M)
1800 PP.EnterAnnotationToken(SourceRange(Loc), tok::annot_module_end, M);
1801 else
1802 PP.Diag(Loc, diag::err_pp_module_end_without_module_begin);
1803 }
1804};
1805
1806/// Handle the clang \#pragma module build extension.
1807struct PragmaModuleBuildHandler : public PragmaHandler {
1808 PragmaModuleBuildHandler() : PragmaHandler("build") {}
1809
1810 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1811 Token &Tok) override {
1813 }
1814};
1815
1816/// Handle the clang \#pragma module load extension.
1817struct PragmaModuleLoadHandler : public PragmaHandler {
1818 PragmaModuleLoadHandler() : PragmaHandler("load") {}
1819
1820 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1821 Token &Tok) override {
1823
1824 // Read the module name.
1826 ModuleName;
1827 if (LexModuleName(PP, Tok, ModuleName))
1828 return;
1829
1830 if (Tok.isNot(tok::eod))
1831 PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1832
1833 // Load the module, don't make it visible.
1834 PP.getModuleLoader().loadModule(Loc, ModuleName, Module::Hidden,
1835 /*IsInclusionDirective=*/false);
1836 }
1837};
1838
1839/// PragmaPushMacroHandler - "\#pragma push_macro" saves the value of the
1840/// macro on the top of the stack.
1841struct PragmaPushMacroHandler : public PragmaHandler {
1842 PragmaPushMacroHandler() : PragmaHandler("push_macro") {}
1843
1844 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1845 Token &PushMacroTok) override {
1846 PP.HandlePragmaPushMacro(PushMacroTok);
1847 }
1848};
1849
1850/// PragmaPopMacroHandler - "\#pragma pop_macro" sets the value of the
1851/// macro to the value on the top of the stack.
1852struct PragmaPopMacroHandler : public PragmaHandler {
1853 PragmaPopMacroHandler() : PragmaHandler("pop_macro") {}
1854
1855 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1856 Token &PopMacroTok) override {
1857 PP.HandlePragmaPopMacro(PopMacroTok);
1858 }
1859};
1860
1861/// PragmaARCCFCodeAuditedHandler -
1862/// \#pragma clang arc_cf_code_audited begin/end
1863struct PragmaARCCFCodeAuditedHandler : public PragmaHandler {
1864 PragmaARCCFCodeAuditedHandler() : PragmaHandler("arc_cf_code_audited") {}
1865
1866 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1867 Token &NameTok) override {
1868 SourceLocation Loc = NameTok.getLocation();
1869 bool IsBegin;
1870
1871 Token Tok;
1872
1873 // Lex the 'begin' or 'end'.
1874 PP.LexUnexpandedToken(Tok);
1875 const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo();
1876 if (BeginEnd && BeginEnd->isStr("begin")) {
1877 IsBegin = true;
1878 } else if (BeginEnd && BeginEnd->isStr("end")) {
1879 IsBegin = false;
1880 } else {
1881 PP.Diag(Tok.getLocation(), diag::err_pp_arc_cf_code_audited_syntax);
1882 return;
1883 }
1884
1885 // Verify that this is followed by EOD.
1886 PP.LexUnexpandedToken(Tok);
1887 if (Tok.isNot(tok::eod))
1888 PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1889
1890 // The start location of the active audit.
1891 SourceLocation BeginLoc = PP.getPragmaARCCFCodeAuditedInfo().second;
1892
1893 // The start location we want after processing this.
1894 SourceLocation NewLoc;
1895
1896 if (IsBegin) {
1897 // Complain about attempts to re-enter an audit.
1898 if (BeginLoc.isValid()) {
1899 PP.Diag(Loc, diag::err_pp_double_begin_of_arc_cf_code_audited);
1900 PP.Diag(BeginLoc, diag::note_pragma_entered_here);
1901 }
1902 NewLoc = Loc;
1903 } else {
1904 // Complain about attempts to leave an audit that doesn't exist.
1905 if (!BeginLoc.isValid()) {
1906 PP.Diag(Loc, diag::err_pp_unmatched_end_of_arc_cf_code_audited);
1907 return;
1908 }
1909 NewLoc = SourceLocation();
1910 }
1911
1913 }
1914};
1915
1916/// PragmaAssumeNonNullHandler -
1917/// \#pragma clang assume_nonnull begin/end
1918struct PragmaAssumeNonNullHandler : public PragmaHandler {
1919 PragmaAssumeNonNullHandler() : PragmaHandler("assume_nonnull") {}
1920
1921 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1922 Token &NameTok) override {
1923 SourceLocation Loc = NameTok.getLocation();
1924 bool IsBegin;
1925
1926 Token Tok;
1927
1928 // Lex the 'begin' or 'end'.
1929 PP.LexUnexpandedToken(Tok);
1930 const IdentifierInfo *BeginEnd = Tok.getIdentifierInfo();
1931 if (BeginEnd && BeginEnd->isStr("begin")) {
1932 IsBegin = true;
1933 } else if (BeginEnd && BeginEnd->isStr("end")) {
1934 IsBegin = false;
1935 } else {
1936 PP.Diag(Tok.getLocation(), diag::err_pp_assume_nonnull_syntax);
1937 return;
1938 }
1939
1940 // Verify that this is followed by EOD.
1941 PP.LexUnexpandedToken(Tok);
1942 if (Tok.isNot(tok::eod))
1943 PP.Diag(Tok, diag::ext_pp_extra_tokens_at_eol) << "pragma";
1944
1945 // The start location of the active audit.
1947
1948 // The start location we want after processing this.
1949 SourceLocation NewLoc;
1950 PPCallbacks *Callbacks = PP.getPPCallbacks();
1951
1952 if (IsBegin) {
1953 // Complain about attempts to re-enter an audit.
1954 if (BeginLoc.isValid()) {
1955 PP.Diag(Loc, diag::err_pp_double_begin_of_assume_nonnull);
1956 PP.Diag(BeginLoc, diag::note_pragma_entered_here);
1957 }
1958 NewLoc = Loc;
1959 if (Callbacks)
1960 Callbacks->PragmaAssumeNonNullBegin(NewLoc);
1961 } else {
1962 // Complain about attempts to leave an audit that doesn't exist.
1963 if (!BeginLoc.isValid()) {
1964 PP.Diag(Loc, diag::err_pp_unmatched_end_of_assume_nonnull);
1965 return;
1966 }
1967 NewLoc = SourceLocation();
1968 if (Callbacks)
1969 Callbacks->PragmaAssumeNonNullEnd(NewLoc);
1970 }
1971
1972 PP.setPragmaAssumeNonNullLoc(NewLoc);
1973 }
1974};
1975
1976/// Handle "\#pragma region [...]"
1977///
1978/// The syntax is
1979/// \code
1980/// #pragma region [optional name]
1981/// #pragma endregion [optional comment]
1982/// \endcode
1983///
1984/// \note This is
1985/// <a href="http://msdn.microsoft.com/en-us/library/b6xkz944(v=vs.80).aspx">editor-only</a>
1986/// pragma, just skipped by compiler.
1987struct PragmaRegionHandler : public PragmaHandler {
1988 PragmaRegionHandler(const char *pragma) : PragmaHandler(pragma) {}
1989
1990 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
1991 Token &NameTok) override {
1992 // #pragma region: endregion matches can be verified
1993 // __pragma(region): no sense, but ignored by msvc
1994 // _Pragma is not valid for MSVC, but there isn't any point
1995 // to handle a _Pragma differently.
1996 }
1997};
1998
1999/// "\#pragma managed"
2000/// "\#pragma managed(...)"
2001/// "\#pragma unmanaged"
2002/// MSVC ignores this pragma when not compiling using /clr, which clang doesn't
2003/// support. We parse it and ignore it to avoid -Wunknown-pragma warnings.
2004struct PragmaManagedHandler : public EmptyPragmaHandler {
2005 PragmaManagedHandler(const char *pragma) : EmptyPragmaHandler(pragma) {}
2006};
2007
2008/// This handles parsing pragmas that take a macro name and optional message
2009static IdentifierInfo *HandleMacroAnnotationPragma(Preprocessor &PP, Token &Tok,
2010 const char *Pragma,
2011 std::string &MessageString) {
2012 PP.Lex(Tok);
2013 if (Tok.isNot(tok::l_paren)) {
2014 PP.Diag(Tok, diag::err_expected) << "(";
2015 return nullptr;
2016 }
2017
2018 PP.LexUnexpandedToken(Tok);
2019 if (!Tok.is(tok::identifier)) {
2020 PP.Diag(Tok, diag::err_expected) << tok::identifier;
2021 return nullptr;
2022 }
2024
2025 if (!II->hasMacroDefinition()) {
2026 PP.Diag(Tok, diag::err_pp_visibility_non_macro) << II;
2027 return nullptr;
2028 }
2029
2030 PP.Lex(Tok);
2031 if (Tok.is(tok::comma)) {
2032 PP.Lex(Tok);
2033 if (!PP.FinishLexStringLiteral(Tok, MessageString, Pragma,
2034 /*AllowMacroExpansion=*/true))
2035 return nullptr;
2036 }
2037
2038 if (Tok.isNot(tok::r_paren)) {
2039 PP.Diag(Tok, diag::err_expected) << ")";
2040 return nullptr;
2041 }
2042 return II;
2043}
2044
2045/// "\#pragma clang deprecated(...)"
2046///
2047/// The syntax is
2048/// \code
2049/// #pragma clang deprecate(MACRO_NAME [, Message])
2050/// \endcode
2051struct PragmaDeprecatedHandler : public PragmaHandler {
2052 PragmaDeprecatedHandler() : PragmaHandler("deprecated") {}
2053
2054 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
2055 Token &Tok) override {
2056 std::string MessageString;
2057
2058 if (IdentifierInfo *II = HandleMacroAnnotationPragma(
2059 PP, Tok, "#pragma clang deprecated", MessageString)) {
2060 II->setIsDeprecatedMacro(true);
2061 PP.addMacroDeprecationMsg(II, std::move(MessageString),
2062 Tok.getLocation());
2063 }
2064 }
2065};
2066
2067/// "\#pragma clang restrict_expansion(...)"
2068///
2069/// The syntax is
2070/// \code
2071/// #pragma clang restrict_expansion(MACRO_NAME [, Message])
2072/// \endcode
2073struct PragmaRestrictExpansionHandler : public PragmaHandler {
2074 PragmaRestrictExpansionHandler() : PragmaHandler("restrict_expansion") {}
2075
2076 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
2077 Token &Tok) override {
2078 std::string MessageString;
2079
2080 if (IdentifierInfo *II = HandleMacroAnnotationPragma(
2081 PP, Tok, "#pragma clang restrict_expansion", MessageString)) {
2082 II->setIsRestrictExpansion(true);
2083 PP.addRestrictExpansionMsg(II, std::move(MessageString),
2084 Tok.getLocation());
2085 }
2086 }
2087};
2088
2089/// "\#pragma clang final(...)"
2090///
2091/// The syntax is
2092/// \code
2093/// #pragma clang final(MACRO_NAME)
2094/// \endcode
2095struct PragmaFinalHandler : public PragmaHandler {
2096 PragmaFinalHandler() : PragmaHandler("final") {}
2097
2098 void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
2099 Token &Tok) override {
2100 PP.Lex(Tok);
2101 if (Tok.isNot(tok::l_paren)) {
2102 PP.Diag(Tok, diag::err_expected) << "(";
2103 return;
2104 }
2105
2106 PP.LexUnexpandedToken(Tok);
2107 if (!Tok.is(tok::identifier)) {
2108 PP.Diag(Tok, diag::err_expected) << tok::identifier;
2109 return;
2110 }
2112
2113 if (!II->hasMacroDefinition()) {
2114 PP.Diag(Tok, diag::err_pp_visibility_non_macro) << II;
2115 return;
2116 }
2117
2118 PP.Lex(Tok);
2119 if (Tok.isNot(tok::r_paren)) {
2120 PP.Diag(Tok, diag::err_expected) << ")";
2121 return;
2122 }
2123 II->setIsFinal(true);
2124 PP.addFinalLoc(II, Tok.getLocation());
2125 }
2126};
2127
2128} // namespace
2129
2130/// RegisterBuiltinPragmas - Install the standard preprocessor pragmas:
2131/// \#pragma GCC poison/system_header/dependency and \#pragma once.
2132void Preprocessor::RegisterBuiltinPragmas() {
2133 AddPragmaHandler(new PragmaOnceHandler());
2134 AddPragmaHandler(new PragmaMarkHandler());
2135 AddPragmaHandler(new PragmaPushMacroHandler());
2136 AddPragmaHandler(new PragmaPopMacroHandler());
2137 AddPragmaHandler(new PragmaMessageHandler(PPCallbacks::PMK_Message));
2138
2139 // #pragma GCC ...
2140 AddPragmaHandler("GCC", new PragmaPoisonHandler());
2141 AddPragmaHandler("GCC", new PragmaSystemHeaderHandler());
2142 AddPragmaHandler("GCC", new PragmaDependencyHandler());
2143 AddPragmaHandler("GCC", new PragmaDiagnosticHandler("GCC"));
2144 AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Warning,
2145 "GCC"));
2146 AddPragmaHandler("GCC", new PragmaMessageHandler(PPCallbacks::PMK_Error,
2147 "GCC"));
2148 // #pragma clang ...
2149 AddPragmaHandler("clang", new PragmaPoisonHandler());
2150 AddPragmaHandler("clang", new PragmaSystemHeaderHandler());
2151 AddPragmaHandler("clang", new PragmaDebugHandler());
2152 AddPragmaHandler("clang", new PragmaDependencyHandler());
2153 AddPragmaHandler("clang", new PragmaDiagnosticHandler("clang"));
2154 AddPragmaHandler("clang", new PragmaARCCFCodeAuditedHandler());
2155 AddPragmaHandler("clang", new PragmaAssumeNonNullHandler());
2156 AddPragmaHandler("clang", new PragmaDeprecatedHandler());
2157 AddPragmaHandler("clang", new PragmaRestrictExpansionHandler());
2158 AddPragmaHandler("clang", new PragmaFinalHandler());
2159
2160 // #pragma clang module ...
2161 auto *ModuleHandler = new PragmaNamespace("module");
2162 AddPragmaHandler("clang", ModuleHandler);
2163 ModuleHandler->AddPragma(new PragmaModuleImportHandler());
2164 ModuleHandler->AddPragma(new PragmaModuleBeginHandler());
2165 ModuleHandler->AddPragma(new PragmaModuleEndHandler());
2166 ModuleHandler->AddPragma(new PragmaModuleBuildHandler());
2167 ModuleHandler->AddPragma(new PragmaModuleLoadHandler());
2168
2169 // Safe Buffers pragmas
2170 AddPragmaHandler("clang", new PragmaUnsafeBufferUsageHandler);
2171
2172 // Add region pragmas.
2173 AddPragmaHandler(new PragmaRegionHandler("region"));
2174 AddPragmaHandler(new PragmaRegionHandler("endregion"));
2175
2176 // MS extensions.
2177 if (LangOpts.MicrosoftExt) {
2178 AddPragmaHandler(new PragmaWarningHandler());
2179 AddPragmaHandler(new PragmaExecCharsetHandler());
2180 AddPragmaHandler(new PragmaIncludeAliasHandler());
2181 AddPragmaHandler(new PragmaHdrstopHandler());
2182 AddPragmaHandler(new PragmaSystemHeaderHandler());
2183 AddPragmaHandler(new PragmaManagedHandler("managed"));
2184 AddPragmaHandler(new PragmaManagedHandler("unmanaged"));
2185 }
2186
2187 // Pragmas added by plugins
2188 for (const PragmaHandlerRegistry::entry &handler :
2189 PragmaHandlerRegistry::entries()) {
2190 AddPragmaHandler(handler.instantiate().release());
2191 }
2192}
2193
2194/// Ignore all pragmas, useful for modes such as -Eonly which would otherwise
2195/// warn about those pragmas being unknown.
2198 // Also ignore all pragmas in all namespaces created
2199 // in Preprocessor::RegisterBuiltinPragmas().
2201 AddPragmaHandler("clang", new EmptyPragmaHandler());
2202}
StringRef P
Defines the Diagnostic-related interfaces.
enum clang::sema::@1658::IndirectLocalPathEntry::EntryKind Kind
Defines the clang::FileManager interface and associated types.
StringRef Filename
Definition: Format.cpp:3001
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified.
Defines the clang::LangOptions interface.
Defines the clang::MacroInfo and clang::MacroDirective classes.
Defines the clang::Module class, which describes a module in the source code.
Defines the PPCallbacks interface.
static bool LexModuleName(Preprocessor &PP, Token &Tok, llvm::SmallVectorImpl< std::pair< IdentifierInfo *, SourceLocation > > &ModuleName)
Definition: Pragma.cpp:791
static bool LexModuleNameComponent(Preprocessor &PP, Token &Tok, std::pair< IdentifierInfo *, SourceLocation > &ModuleNameComponent, bool First)
Definition: Pragma.cpp:770
Defines the PreprocessorLexer interface.
Defines the clang::Preprocessor interface.
uint32_t Id
Definition: SemaARM.cpp:1143
SourceLocation Loc
Definition: SemaObjC.cpp:758
Defines the clang::SourceLocation class and associated facilities.
Defines the SourceManager interface.
Defines the clang::TokenKind enum and support functions.
const NestedNameSpecifier * Specifier
__device__ int
void setSeverityForAll(diag::Flavor Flavor, diag::Severity Map, SourceLocation Loc=SourceLocation())
Add the specified mapping to all diagnostics of the specified flavor.
Definition: Diagnostic.cpp:486
LLVM_DUMP_METHOD void dump() const
Definition: Diagnostic.cpp:88
void pushMappings(SourceLocation Loc)
Copies the current DiagMappings and pushes the new copy onto the top of the stack.
Definition: Diagnostic.cpp:102
bool setSeverityForGroup(diag::Flavor Flavor, StringRef Group, diag::Severity Map, SourceLocation Loc=SourceLocation())
Change an entire diagnostic group (e.g.
Definition: Diagnostic.cpp:402
bool popMappings(SourceLocation Loc)
Pops the current DiagMappings off the top of the stack, causing the new top of the stack to be the ac...
Definition: Diagnostic.cpp:106
EmptyPragmaHandler - A pragma handler which takes no action, which can be used to ignore particular p...
Definition: Pragma.h:84
void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstToken) override
Definition: Pragma.cpp:67
EmptyPragmaHandler(StringRef Name=StringRef())
Definition: Pragma.cpp:65
time_t getModificationTime() const
Definition: FileEntry.h:348
void MarkFileIncludeOnce(FileEntryRef File)
Mark the specified file as a "once only" file due to #pragma once.
Definition: HeaderSearch.h:559
void MarkFileSystemHeader(FileEntryRef File)
Mark the specified file as a system header, e.g.
Definition: HeaderSearch.h:565
ModuleMap & getModuleMap()
Retrieve the module map.
Definition: HeaderSearch.h:833
void AddIncludeAlias(StringRef Source, StringRef Dest)
Map the source include name to the dest include name.
Definition: HeaderSearch.h:414
One of these records is kept for each identifier that is lexed.
void setIsRestrictExpansion(bool Val)
void setIsDeprecatedMacro(bool Val)
void setIsPoisoned(bool Value=true)
setIsPoisoned - Mark this identifier as poisoned.
void setIsFinal(bool Val)
bool hasMacroDefinition() const
Return true if this identifier is #defined to some other value.
bool isFromAST() const
Return true if the identifier in its current state was loaded from an AST file.
bool isPoisoned() const
Return true if this token has been poisoned.
bool isStr(const char(&Str)[StrLen]) const
Return true if this is the identifier for the specified string.
void setChangedSinceDeserialization()
Note that this identifier has changed since it was loaded from an AST file.
StringRef getName() const
Return the actual identifier string.
std::string CurrentModule
The name of the current module, of which the main source file is a part.
Definition: LangOptions.h:516
Lexer - This provides a simple interface that turns a text buffer into a stream of tokens.
Definition: Lexer.h:78
static Lexer * Create_PragmaLexer(SourceLocation SpellingLoc, SourceLocation ExpansionLocStart, SourceLocation ExpansionLocEnd, unsigned TokLen, Preprocessor &PP)
Create_PragmaLexer: Lexer constructor - Create a new lexer object for _Pragma expansion.
Definition: Lexer.cpp:243
Encapsulates the data about a macro definition (e.g.
Definition: MacroInfo.h:39
void setIsAllowRedefinitionsWithoutWarning(bool Val)
Set the value of the IsAllowRedefinitionsWithoutWarning flag.
Definition: MacroInfo.h:157
virtual ModuleLoadResult loadModule(SourceLocation ImportLoc, ModuleIdPath Path, Module::NameVisibilityKind Visibility, bool IsInclusionDirective)=0
Attempt to load the given module.
virtual void createModuleFromSource(SourceLocation Loc, StringRef ModuleName, StringRef Source)=0
Attempt to create the given module from the specified source buffer.
Module * lookupModuleQualified(StringRef Name, Module *Context) const
Retrieve a module with the given name within the given context, using direct (qualified) name lookup.
Definition: ModuleMap.cpp:844
llvm::iterator_range< module_iterator > modules() const
Definition: ModuleMap.h:739
Describes a module or submodule.
Definition: Module.h:105
StringRef getTopLevelModuleName() const
Retrieve the name of the top-level module.
Definition: Module.h:676
Module * findOrInferSubmodule(StringRef Name)
Definition: Module.cpp:365
llvm::iterator_range< submodule_iterator > submodules()
Definition: Module.h:783
void dump() const
Dump the contents of this module to the given output stream.
std::string getFullModuleName(bool AllowStringLiterals=false) const
Retrieve the full name of this module, including the path from its top-level module.
Definition: Module.cpp:244
This interface provides a way to observe the actions of the preprocessor as it does its thing.
Definition: PPCallbacks.h:36
virtual void PragmaExecCharsetPop(SourceLocation Loc)
Callback invoked when a #pragma execution_character_set(pop) directive is read.
Definition: PPCallbacks.h:327
virtual void PragmaDiagnosticPush(SourceLocation Loc, StringRef Namespace)
Callback invoked when a #pragma gcc diagnostic push directive is read.
Definition: PPCallbacks.h:276
virtual void PragmaWarning(SourceLocation Loc, PragmaWarningSpecifier WarningSpec, ArrayRef< int > Ids)
Definition: PPCallbacks.h:309
virtual void PragmaDebug(SourceLocation Loc, StringRef DebugType)
Callback invoked when a #pragma clang __debug directive is read.
Definition: PPCallbacks.h:250
virtual void PragmaDiagnostic(SourceLocation Loc, StringRef Namespace, diag::Severity mapping, StringRef Str)
Callback invoked when a #pragma gcc diagnostic directive is read.
Definition: PPCallbacks.h:287
PragmaWarningSpecifier
Callback invoked when a #pragma warning directive is read.
Definition: PPCallbacks.h:298
virtual void PragmaAssumeNonNullEnd(SourceLocation Loc)
Callback invoked when a #pragma clang assume_nonnull end directive is read.
Definition: PPCallbacks.h:335
virtual void PragmaAssumeNonNullBegin(SourceLocation Loc)
Callback invoked when a #pragma clang assume_nonnull begin directive is read.
Definition: PPCallbacks.h:331
virtual void PragmaMessage(SourceLocation Loc, StringRef Namespace, PragmaMessageKind Kind, StringRef Str)
Callback invoked when a #pragma message directive is read.
Definition: PPCallbacks.h:270
virtual void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str)
Callback invoked when a #pragma execution_character_set(push) directive is read.
Definition: PPCallbacks.h:323
virtual void PragmaDiagnosticPop(SourceLocation Loc, StringRef Namespace)
Callback invoked when a #pragma gcc diagnostic pop directive is read.
Definition: PPCallbacks.h:282
virtual void PragmaWarningPop(SourceLocation Loc)
Callback invoked when a #pragma warning(pop) directive is read.
Definition: PPCallbacks.h:318
PragmaMessageKind
Determines the kind of #pragma invoking a call to PragmaMessage.
Definition: PPCallbacks.h:254
@ PMK_Warning
#pragma GCC warning has been invoked.
Definition: PPCallbacks.h:259
@ PMK_Error
#pragma GCC error has been invoked.
Definition: PPCallbacks.h:262
@ PMK_Message
#pragma message has been invoked.
Definition: PPCallbacks.h:256
virtual void PragmaWarningPush(SourceLocation Loc, int Level)
Callback invoked when a #pragma warning(push) directive is read.
Definition: PPCallbacks.h:314
PragmaHandler - Instances of this interface defined to handle the various pragmas that the language f...
Definition: Pragma.h:65
StringRef getName() const
Definition: Pragma.h:73
virtual ~PragmaHandler()
virtual void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &FirstToken)=0
virtual PragmaNamespace * getIfNamespace()
getIfNamespace - If this is a namespace, return it.
Definition: Pragma.h:79
PragmaNamespace - This PragmaHandler subdivides the namespace of pragmas, allowing hierarchical pragm...
Definition: Pragma.h:96
void AddPragma(PragmaHandler *Handler)
AddPragma - Add a pragma to this namespace.
Definition: Pragma.cpp:92
PragmaHandler * FindHandler(StringRef Name, bool IgnoreNull=true) const
FindHandler - Check to see if there is already a handler for the specified name.
Definition: Pragma.cpp:79
void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer, Token &Tok) override
Definition: Pragma.cpp:107
void RemovePragmaHandler(PragmaHandler *Handler)
RemovePragmaHandler - Remove the given handler from the namespace.
Definition: Pragma.cpp:98
PragmaNamespace * getIfNamespace() override
getIfNamespace - If this is a namespace, return it.
Definition: Pragma.h:123
bool IsEmpty() const
Definition: Pragma.h:118
bool LexingRawMode
True if in raw mode.
bool ParsingPreprocessorDirective
True when parsing #XXX; turns '\n' into a tok::eod token.
OptionalFileEntryRef getFileEntry() const
getFileEntry - Return the FileEntry corresponding to this FileID.
bool DisablePragmaDebugCrash
Prevents intended crashes when using #pragma clang __debug. For testing.
Engages in a tight little dance with the lexer to efficiently preprocess tokens.
Definition: Preprocessor.h:137
void HandlePragmaPushMacro(Token &Tok)
Handle #pragma push_macro.
Definition: Pragma.cpp:627
bool FinishLexStringLiteral(Token &Result, std::string &String, const char *DiagnosticTag, bool AllowMacroExpansion)
Complete the lexing of a string literal where the first token has already been lexed (see LexStringLi...
void HandlePragmaPoison()
HandlePragmaPoison - Handle #pragma GCC poison. PoisonTok is the 'poison'.
Definition: Pragma.cpp:442
void dumpMacroInfo(const IdentifierInfo *II)
std::pair< IdentifierInfo *, SourceLocation > getPragmaARCCFCodeAuditedInfo() const
The location of the currently-active #pragma clang arc_cf_code_audited begin.
void HandlePragmaSystemHeader(Token &SysHeaderTok)
HandlePragmaSystemHeader - Implement #pragma GCC system_header.
Definition: Pragma.cpp:484
void setPragmaARCCFCodeAuditedInfo(IdentifierInfo *Ident, SourceLocation Loc)
Set the location of the currently-active #pragma clang arc_cf_code_audited begin.
void HandlePragmaModuleBuild(Token &Tok)
Definition: Pragma.cpp:807
void EnterToken(const Token &Tok, bool IsReinject)
Enters a token in the token stream to be lexed next.
void IgnorePragmas()
Install empty handlers for all pragmas (making them ignored).
Definition: Pragma.cpp:2196
PPCallbacks * getPPCallbacks() const
const MacroInfo * getMacroInfo(const IdentifierInfo *II) const
ArrayRef< BuildingSubmoduleInfo > getBuildingSubmodules() const
Get the list of submodules that we're currently building.
SourceLocation getModuleImportLoc(Module *M) const
void setPragmaAssumeNonNullLoc(SourceLocation Loc)
Set the location of the currently-active #pragma clang assume_nonnull begin.
bool isInPrimaryFile() const
Return true if we're in the top-level file, not in a #include.
void CreateString(StringRef Str, Token &Tok, SourceLocation ExpansionLocStart=SourceLocation(), SourceLocation ExpansionLocEnd=SourceLocation())
Plop the specified string into a scratch buffer and set the specified token's location and length to ...
void EnterSubmodule(Module *M, SourceLocation ImportLoc, bool ForPragma)
void addMacroDeprecationMsg(const IdentifierInfo *II, std::string Msg, SourceLocation AnnotationLoc)
void addRestrictExpansionMsg(const IdentifierInfo *II, std::string Msg, SourceLocation AnnotationLoc)
IdentifierInfo * LookUpIdentifierInfo(Token &Identifier) const
Given a tok::raw_identifier token, look up the identifier information for the token and install it in...
void addFinalLoc(const IdentifierInfo *II, SourceLocation AnnotationLoc)
void makeModuleVisible(Module *M, SourceLocation Loc)
void Lex(Token &Result)
Lex the next token for this preprocessor.
const TranslationUnitKind TUKind
The kind of translation unit we are processing.
Definition: Preprocessor.h:295
ModuleLoader & getModuleLoader() const
Retrieve the module loader associated with this preprocessor.
SourceRange DiscardUntilEndOfDirective()
Read and discard all tokens remaining on the current line until the tok::eod token is found.
bool LexOnOffSwitch(tok::OnOffSwitch &Result)
Lex an on-off-switch (C99 6.10.6p2) and verify that it is followed by EOD.
Definition: Pragma.cpp:968
void HandlePragmaDependency(Token &DependencyTok)
HandlePragmaDependency - Handle #pragma GCC dependency "foo" blah.
Definition: Pragma.cpp:516
SourceLocation CheckEndOfDirective(const char *DirType, bool EnableMacros=false)
Ensure that the next token is a tok::eod token.
bool enterOrExitSafeBufferOptOutRegion(bool isEnter, const SourceLocation &Loc)
Alter the state of whether this PP currently is in a "-Wunsafe-buffer-usage" opt-out region.
IdentifierInfo * getIdentifierInfo(StringRef Name) const
Return information about the specified preprocessor identifier token.
SourceManager & getSourceManager() const
void HandlePragmaOnce(Token &OnceTok)
HandlePragmaOnce - Handle #pragma once. OnceTok is the 'once'.
Definition: Pragma.cpp:417
bool isMacroDefined(StringRef Id)
static bool checkModuleIsAvailable(const LangOptions &LangOpts, const TargetInfo &TargetInfo, const Module &M, DiagnosticsEngine &Diags)
Check that the given module is available, producing a diagnostic if not.
SourceLocation getPragmaAssumeNonNullLoc() const
The location of the currently-active #pragma clang assume_nonnull begin.
const TargetInfo & getTargetInfo() const
bool LexHeaderName(Token &Result, bool AllowMacroExpansion=true)
Lex a token, forming a header-name token if possible.
PreprocessorOptions & getPreprocessorOpts() const
Retrieve the preprocessor options used to initialize this preprocessor.
bool parseSimpleIntegerLiteral(Token &Tok, uint64_t &Value)
Parses a simple integer literal to get its numeric value.
void LexUnexpandedToken(Token &Result)
Just like Lex, but disables macro expansion of identifier tokens.
bool creatingPCHWithPragmaHdrStop()
True if creating a PCH with a #pragma hdrstop.
void AddPragmaHandler(StringRef Namespace, PragmaHandler *Handler)
Add the specified pragma handler to this preprocessor.
Definition: Pragma.cpp:915
llvm::BumpPtrAllocator & getPreprocessorAllocator()
StringRef getSpelling(SourceLocation loc, SmallVectorImpl< char > &buffer, bool *invalid=nullptr) const
Return the 'spelling' of the token at the given location; does not go up to the spelling location or ...
bool GetIncludeFilenameSpelling(SourceLocation Loc, StringRef &Buffer)
Turn the specified lexer token into a fully checked and spelled filename, e.g.
PreprocessorLexer * getCurrentFileLexer() const
Return the current file lexer being lexed from.
HeaderSearch & getHeaderSearchInfo() const
void HandlePragmaPopMacro(Token &Tok)
Handle #pragma pop_macro.
Definition: Pragma.cpp:650
Module * LeaveSubmodule(bool ForPragma)
void EnterAnnotationToken(SourceRange Range, tok::TokenKind Kind, void *AnnotationVal)
Enter an annotation token into the token stream.
OptionalFileEntryRef LookupFile(SourceLocation FilenameLoc, StringRef Filename, bool isAngled, ConstSearchDirIterator FromDir, const FileEntry *FromFile, ConstSearchDirIterator *CurDir, SmallVectorImpl< char > *SearchPath, SmallVectorImpl< char > *RelativePath, ModuleMap::KnownHeader *SuggestedModule, bool *IsMapped, bool *IsFrameworkFound, bool SkipCache=false, bool OpenFile=true, bool CacheFailures=true)
Given a "foo" or <foo> reference, look up the indicated file.
const LangOptions & getLangOpts() const
IdentifierInfo * ParsePragmaPushOrPopMacro(Token &Tok)
ParsePragmaPushOrPopMacro - Handle parsing of pragma push_macro/pop_macro.
Definition: Pragma.cpp:572
bool usingPCHWithPragmaHdrStop()
True if using a PCH with a #pragma hdrstop.
DefMacroDirective * appendDefMacroDirective(IdentifierInfo *II, MacroInfo *MI, SourceLocation Loc)
void HandlePragmaMark(Token &MarkTok)
Definition: Pragma.cpp:432
void HandlePragmaHdrstop(Token &Tok)
Definition: Pragma.cpp:881
DiagnosticsEngine & getDiagnostics() const
void RemovePragmaHandler(StringRef Namespace, PragmaHandler *Handler)
Remove the specific pragma handler from this preprocessor.
Definition: Pragma.cpp:946
void HandlePragmaIncludeAlias(Token &Tok)
Definition: Pragma.cpp:685
DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) const
Forwarding function for diagnostics.
bool LexStringLiteral(Token &Result, std::string &String, const char *DiagnosticTag, bool AllowMacroExpansion)
Lex a string literal, which may be the concatenation of multiple string literals and may even come fr...
void appendMacroDirective(IdentifierInfo *II, MacroDirective *MD)
Add a directive to the macro directive history for this identifier.
Represents an unpacked "presumed" location which can be presented to the user.
const char * getFilename() const
Return the presumed filename of this location.
unsigned getLine() const
Return the presumed line number of this location.
bool isInvalid() const
Return true if this object is invalid or uninitialized.
Encodes a location in the source.
bool isValid() const
Return true if this is a valid SourceLocation object.
void print(raw_ostream &OS, const SourceManager &SM) const
void noteSLocAddressSpaceUsage(DiagnosticsEngine &Diag, std::optional< unsigned > MaxNotes=32) const
bool isInMainFile(SourceLocation Loc) const
Returns whether the PresumedLoc for a given SourceLocation is in the main file.
void AddLineNote(SourceLocation Loc, unsigned LineNo, int FilenameID, bool IsFileEntry, bool IsFileExit, SrcMgr::CharacteristicKind FileKind)
Add a line note to the line table for the FileID and offset specified by Loc.
PresumedLoc getPresumedLoc(SourceLocation Loc, bool UseLineDirectives=true) const
Returns the "presumed" location of a SourceLocation specifies.
unsigned getLineTableFilenameID(StringRef Str)
Return the uniqued ID for the specified filename.
A trivial tuple used to represent a source range.
StringLiteralParser - This decodes string escape characters and performs wide string analysis and Tra...
Token - This structure provides full information about a lexed token.
Definition: Token.h:36
IdentifierInfo * getIdentifierInfo() const
Definition: Token.h:187
SourceLocation getLocation() const
Return a source location identifier for the specified offset in the current file.
Definition: Token.h:132
unsigned getLength() const
Definition: Token.h:135
void setKind(tok::TokenKind K)
Definition: Token.h:95
bool is(tok::TokenKind K) const
is/isNot - Predicates to check if this token is a specific kind, as in "if (Tok.is(tok::l_brace)) {....
Definition: Token.h:99
tok::TokenKind getKind() const
Definition: Token.h:94
bool isAtStartOfLine() const
isAtStartOfLine - Return true if this token is at the start of a line.
Definition: Token.h:276
@ LeadingSpace
Definition: Token.h:77
bool isNot(tok::TokenKind K) const
Definition: Token.h:100
bool isAnnotation() const
Return true if this is any of tok::annot_* kind tokens.
Definition: Token.h:121
bool hasUDSuffix() const
Return true if this token is a string or character literal which has a ud-suffix.
Definition: Token.h:303
void setAnnotationRange(SourceRange R)
Definition: Token.h:169
void startToken()
Reset all flags to cleared.
Definition: Token.h:177
StringRef getRawIdentifier() const
getRawIdentifier - For a raw identifier token (i.e., an identifier lexed in raw mode),...
Definition: Token.h:213
#define INT_MAX
Definition: limits.h:50
uint32_t Literal
Literals are represented as positive integers.
Definition: CNFFormula.h:35
Severity
Enum values that allow the client to map NOTEs, WARNINGs, and EXTENSIONs to either Ignore (nothing),...
Definition: DiagnosticIDs.h:85
Flavor
Flavors of diagnostics we can emit.
Definition: DiagnosticIDs.h:96
bool Sub(InterpState &S, CodePtr OpPC)
Definition: Interp.h:389
bool isStringLiteral(TokenKind K)
Return true if this is a C or C++ string-literal (or C++11 user-defined-string-literal) token.
Definition: TokenKinds.h:89
OnOffSwitch
Defines the possible values of an on-off-switch (C99 6.10.6p2).
Definition: TokenKinds.h:56
The JSON file list parser is used to communicate input to InstallAPI.
std::optional< diag::Group > diagGroupFromCLWarningID(unsigned)
For cl.exe warning IDs that cleany map to clang diagnostic groups, returns the corresponding group.
Definition: CLWarnings.cpp:20
@ Result
The result type of a method or function.
@ TU_Prefix
The translation unit is a prefix to a translation unit, and is not complete.
Definition: LangOptions.h:1043
@ PIK__Pragma
The pragma was introduced via the C99 _Pragma(string-literal).
Definition: Pragma.h:41
@ PIK___pragma
The pragma was introduced via the Microsoft __pragma(token-string).
Definition: Pragma.h:47
void prepare_PragmaString(SmallVectorImpl< char > &StrVal)
Destringize a _Pragma("") string according to C11 6.10.9.1: "The string literal is destringized by de...
Definition: Pragma.cpp:306
const FunctionProtoType * T
unsigned long uint64_t
#define true
Definition: stdbool.h:25
Describes how and where the pragma was introduced.
Definition: Pragma.h:51
SourceLocation Loc
Definition: Pragma.h:53
PragmaIntroducerKind Kind
Definition: Pragma.h:52