clang  9.0.0
PPCallbacks.h
Go to the documentation of this file.
1 //===--- PPCallbacks.h - Callbacks for Preprocessor actions -----*- C++ -*-===//
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 /// \file
10 /// Defines the PPCallbacks interface.
11 ///
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_CLANG_LEX_PPCALLBACKS_H
15 #define LLVM_CLANG_LEX_PPCALLBACKS_H
16 
20 #include "clang/Lex/ModuleLoader.h"
21 #include "clang/Lex/Pragma.h"
22 #include "llvm/ADT/StringRef.h"
23 
24 namespace clang {
25  class Token;
26  class IdentifierInfo;
27  class MacroDefinition;
28  class MacroDirective;
29  class MacroArgs;
30 
31 /// This interface provides a way to observe the actions of the
32 /// preprocessor as it does its thing.
33 ///
34 /// Clients can define their hooks here to implement preprocessor level tools.
35 class PPCallbacks {
36 public:
37  virtual ~PPCallbacks();
38 
41  };
42 
43  /// Callback invoked whenever a source file is entered or exited.
44  ///
45  /// \param Loc Indicates the new location.
46  /// \param PrevFID the file that was exited if \p Reason is ExitFile.
47  virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason,
49  FileID PrevFID = FileID()) {
50  }
51 
52  /// Callback invoked whenever a source file is skipped as the result
53  /// of header guard optimization.
54  ///
55  /// \param SkippedFile The file that is skipped instead of entering \#include
56  ///
57  /// \param FilenameTok The file name token in \#include "FileName" directive
58  /// or macro expanded file name token from \#include MACRO(PARAMS) directive.
59  /// Note that FilenameTok contains corresponding quotes/angles symbols.
60  virtual void FileSkipped(const FileEntry &SkippedFile,
61  const Token &FilenameTok,
62  SrcMgr::CharacteristicKind FileType) {
63  }
64 
65  /// Callback invoked whenever an inclusion directive results in a
66  /// file-not-found error.
67  ///
68  /// \param FileName The name of the file being included, as written in the
69  /// source code.
70  ///
71  /// \param RecoveryPath If this client indicates that it can recover from
72  /// this missing file, the client should set this as an additional header
73  /// search patch.
74  ///
75  /// \returns true to indicate that the preprocessor should attempt to recover
76  /// by adding \p RecoveryPath as a header search path.
77  virtual bool FileNotFound(StringRef FileName,
78  SmallVectorImpl<char> &RecoveryPath) {
79  return false;
80  }
81 
82  /// Callback invoked whenever an inclusion directive of
83  /// any kind (\c \#include, \c \#import, etc.) has been processed, regardless
84  /// of whether the inclusion will actually result in an inclusion.
85  ///
86  /// \param HashLoc The location of the '#' that starts the inclusion
87  /// directive.
88  ///
89  /// \param IncludeTok The token that indicates the kind of inclusion
90  /// directive, e.g., 'include' or 'import'.
91  ///
92  /// \param FileName The name of the file being included, as written in the
93  /// source code.
94  ///
95  /// \param IsAngled Whether the file name was enclosed in angle brackets;
96  /// otherwise, it was enclosed in quotes.
97  ///
98  /// \param FilenameRange The character range of the quotes or angle brackets
99  /// for the written file name.
100  ///
101  /// \param File The actual file that may be included by this inclusion
102  /// directive.
103  ///
104  /// \param SearchPath Contains the search path which was used to find the file
105  /// in the file system. If the file was found via an absolute include path,
106  /// SearchPath will be empty. For framework includes, the SearchPath and
107  /// RelativePath will be split up. For example, if an include of "Some/Some.h"
108  /// is found via the framework path
109  /// "path/to/Frameworks/Some.framework/Headers/Some.h", SearchPath will be
110  /// "path/to/Frameworks/Some.framework/Headers" and RelativePath will be
111  /// "Some.h".
112  ///
113  /// \param RelativePath The path relative to SearchPath, at which the include
114  /// file was found. This is equal to FileName except for framework includes.
115  ///
116  /// \param Imported The module, whenever an inclusion directive was
117  /// automatically turned into a module import or null otherwise.
118  ///
119  /// \param FileType The characteristic kind, indicates whether a file or
120  /// directory holds normal user code, system code, or system code which is
121  /// implicitly 'extern "C"' in C++ mode.
122  ///
123  virtual void InclusionDirective(SourceLocation HashLoc,
124  const Token &IncludeTok,
125  StringRef FileName,
126  bool IsAngled,
127  CharSourceRange FilenameRange,
128  const FileEntry *File,
129  StringRef SearchPath,
130  StringRef RelativePath,
131  const Module *Imported,
132  SrcMgr::CharacteristicKind FileType) {
133  }
134 
135  /// Callback invoked whenever a submodule was entered.
136  ///
137  /// \param M The submodule we have entered.
138  ///
139  /// \param ImportLoc The location of import directive token.
140  ///
141  /// \param ForPragma If entering from pragma directive.
142  ///
143  virtual void EnteredSubmodule(Module *M, SourceLocation ImportLoc,
144  bool ForPragma) { }
145 
146  /// Callback invoked whenever a submodule was left.
147  ///
148  /// \param M The submodule we have left.
149  ///
150  /// \param ImportLoc The location of import directive token.
151  ///
152  /// \param ForPragma If entering from pragma directive.
153  ///
154  virtual void LeftSubmodule(Module *M, SourceLocation ImportLoc,
155  bool ForPragma) { }
156 
157  /// Callback invoked whenever there was an explicit module-import
158  /// syntax.
159  ///
160  /// \param ImportLoc The location of import directive token.
161  ///
162  /// \param Path The identifiers (and their locations) of the module
163  /// "path", e.g., "std.vector" would be split into "std" and "vector".
164  ///
165  /// \param Imported The imported module; can be null if importing failed.
166  ///
167  virtual void moduleImport(SourceLocation ImportLoc,
168  ModuleIdPath Path,
169  const Module *Imported) {
170  }
171 
172  /// Callback invoked when the end of the main file is reached.
173  ///
174  /// No subsequent callbacks will be made.
175  virtual void EndOfMainFile() {
176  }
177 
178  /// Callback invoked when a \#ident or \#sccs directive is read.
179  /// \param Loc The location of the directive.
180  /// \param str The text of the directive.
181  ///
182  virtual void Ident(SourceLocation Loc, StringRef str) {
183  }
184 
185  /// Callback invoked when start reading any pragma directive.
186  virtual void PragmaDirective(SourceLocation Loc,
187  PragmaIntroducerKind Introducer) {
188  }
189 
190  /// Callback invoked when a \#pragma comment directive is read.
192  StringRef Str) {
193  }
194 
195  /// Callback invoked when a \#pragma detect_mismatch directive is
196  /// read.
197  virtual void PragmaDetectMismatch(SourceLocation Loc, StringRef Name,
198  StringRef Value) {
199  }
200 
201  /// Callback invoked when a \#pragma clang __debug directive is read.
202  /// \param Loc The location of the debug directive.
203  /// \param DebugType The identifier following __debug.
204  virtual void PragmaDebug(SourceLocation Loc, StringRef DebugType) {
205  }
206 
207  /// Determines the kind of \#pragma invoking a call to PragmaMessage.
209  /// \#pragma message has been invoked.
211 
212  /// \#pragma GCC warning has been invoked.
214 
215  /// \#pragma GCC error has been invoked.
217  };
218 
219  /// Callback invoked when a \#pragma message directive is read.
220  /// \param Loc The location of the message directive.
221  /// \param Namespace The namespace of the message directive.
222  /// \param Kind The type of the message directive.
223  /// \param Str The text of the message directive.
224  virtual void PragmaMessage(SourceLocation Loc, StringRef Namespace,
225  PragmaMessageKind Kind, StringRef Str) {
226  }
227 
228  /// Callback invoked when a \#pragma gcc diagnostic push directive
229  /// is read.
231  StringRef Namespace) {
232  }
233 
234  /// Callback invoked when a \#pragma gcc diagnostic pop directive
235  /// is read.
237  StringRef Namespace) {
238  }
239 
240  /// Callback invoked when a \#pragma gcc diagnostic directive is read.
241  virtual void PragmaDiagnostic(SourceLocation Loc, StringRef Namespace,
242  diag::Severity mapping, StringRef Str) {}
243 
244  /// Called when an OpenCL extension is either disabled or
245  /// enabled with a pragma.
246  virtual void PragmaOpenCLExtension(SourceLocation NameLoc,
247  const IdentifierInfo *Name,
248  SourceLocation StateLoc, unsigned State) {
249  }
250 
251  /// Callback invoked when a \#pragma warning directive is read.
252  virtual void PragmaWarning(SourceLocation Loc, StringRef WarningSpec,
253  ArrayRef<int> Ids) {
254  }
255 
256  /// Callback invoked when a \#pragma warning(push) directive is read.
257  virtual void PragmaWarningPush(SourceLocation Loc, int Level) {
258  }
259 
260  /// Callback invoked when a \#pragma warning(pop) directive is read.
261  virtual void PragmaWarningPop(SourceLocation Loc) {
262  }
263 
264  /// Callback invoked when a \#pragma execution_character_set(push) directive
265  /// is read.
266  virtual void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str) {}
267 
268  /// Callback invoked when a \#pragma execution_character_set(pop) directive
269  /// is read.
271 
272  /// Callback invoked when a \#pragma clang assume_nonnull begin directive
273  /// is read.
275 
276  /// Callback invoked when a \#pragma clang assume_nonnull end directive
277  /// is read.
279 
280  /// Called by Preprocessor::HandleMacroExpandedIdentifier when a
281  /// macro invocation is found.
282  virtual void MacroExpands(const Token &MacroNameTok,
283  const MacroDefinition &MD, SourceRange Range,
284  const MacroArgs *Args) {}
285 
286  /// Hook called whenever a macro definition is seen.
287  virtual void MacroDefined(const Token &MacroNameTok,
288  const MacroDirective *MD) {
289  }
290 
291  /// Hook called whenever a macro \#undef is seen.
292  /// \param MacroNameTok The active Token
293  /// \param MD A MacroDefinition for the named macro.
294  /// \param Undef New MacroDirective if the macro was defined, null otherwise.
295  ///
296  /// MD is released immediately following this callback.
297  virtual void MacroUndefined(const Token &MacroNameTok,
298  const MacroDefinition &MD,
299  const MacroDirective *Undef) {
300  }
301 
302  /// Hook called whenever the 'defined' operator is seen.
303  /// \param MD The MacroDirective if the name was a macro, null otherwise.
304  virtual void Defined(const Token &MacroNameTok, const MacroDefinition &MD,
305  SourceRange Range) {
306  }
307 
308  /// Hook called when a '__has_include' or '__has_include_next' directive is
309  /// read.
310  virtual void HasInclude(SourceLocation Loc, StringRef FileName, bool IsAngled,
311  const FileEntry *File,
312  SrcMgr::CharacteristicKind FileType) {}
313 
314  /// Hook called when a source range is skipped.
315  /// \param Range The SourceRange that was skipped. The range begins at the
316  /// \#if/\#else directive and ends after the \#endif/\#else directive.
317  /// \param EndifLoc The end location of the 'endif' token, which may precede
318  /// the range skipped by the directive (e.g excluding comments after an
319  /// 'endif').
320  virtual void SourceRangeSkipped(SourceRange Range, SourceLocation EndifLoc) {
321  }
322 
325  };
326 
327  /// Hook called whenever an \#if is seen.
328  /// \param Loc the source location of the directive.
329  /// \param ConditionRange The SourceRange of the expression being tested.
330  /// \param ConditionValue The evaluated value of the condition.
331  ///
332  // FIXME: better to pass in a list (or tree!) of Tokens.
333  virtual void If(SourceLocation Loc, SourceRange ConditionRange,
334  ConditionValueKind ConditionValue) {
335  }
336 
337  /// Hook called whenever an \#elif is seen.
338  /// \param Loc the source location of the directive.
339  /// \param ConditionRange The SourceRange of the expression being tested.
340  /// \param ConditionValue The evaluated value of the condition.
341  /// \param IfLoc the source location of the \#if/\#ifdef/\#ifndef directive.
342  // FIXME: better to pass in a list (or tree!) of Tokens.
343  virtual void Elif(SourceLocation Loc, SourceRange ConditionRange,
344  ConditionValueKind ConditionValue, SourceLocation IfLoc) {
345  }
346 
347  /// Hook called whenever an \#ifdef is seen.
348  /// \param Loc the source location of the directive.
349  /// \param MacroNameTok Information on the token being tested.
350  /// \param MD The MacroDefinition if the name was a macro, null otherwise.
351  virtual void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
352  const MacroDefinition &MD) {
353  }
354 
355  /// Hook called whenever an \#ifndef is seen.
356  /// \param Loc the source location of the directive.
357  /// \param MacroNameTok Information on the token being tested.
358  /// \param MD The MacroDefiniton if the name was a macro, null otherwise.
359  virtual void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
360  const MacroDefinition &MD) {
361  }
362 
363  /// Hook called whenever an \#else is seen.
364  /// \param Loc the source location of the directive.
365  /// \param IfLoc the source location of the \#if/\#ifdef/\#ifndef directive.
366  virtual void Else(SourceLocation Loc, SourceLocation IfLoc) {
367  }
368 
369  /// Hook called whenever an \#endif is seen.
370  /// \param Loc the source location of the directive.
371  /// \param IfLoc the source location of the \#if/\#ifdef/\#ifndef directive.
372  virtual void Endif(SourceLocation Loc, SourceLocation IfLoc) {
373  }
374 };
375 
376 /// Simple wrapper class for chaining callbacks.
378  virtual void anchor();
379  std::unique_ptr<PPCallbacks> First, Second;
380 
381 public:
382  PPChainedCallbacks(std::unique_ptr<PPCallbacks> _First,
383  std::unique_ptr<PPCallbacks> _Second)
384  : First(std::move(_First)), Second(std::move(_Second)) {}
385 
388  FileID PrevFID) override {
389  First->FileChanged(Loc, Reason, FileType, PrevFID);
390  Second->FileChanged(Loc, Reason, FileType, PrevFID);
391  }
392 
393  void FileSkipped(const FileEntry &SkippedFile,
394  const Token &FilenameTok,
395  SrcMgr::CharacteristicKind FileType) override {
396  First->FileSkipped(SkippedFile, FilenameTok, FileType);
397  Second->FileSkipped(SkippedFile, FilenameTok, FileType);
398  }
399 
400  bool FileNotFound(StringRef FileName,
401  SmallVectorImpl<char> &RecoveryPath) override {
402  return First->FileNotFound(FileName, RecoveryPath) ||
403  Second->FileNotFound(FileName, RecoveryPath);
404  }
405 
406  void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
407  StringRef FileName, bool IsAngled,
408  CharSourceRange FilenameRange, const FileEntry *File,
409  StringRef SearchPath, StringRef RelativePath,
410  const Module *Imported,
411  SrcMgr::CharacteristicKind FileType) override {
412  First->InclusionDirective(HashLoc, IncludeTok, FileName, IsAngled,
413  FilenameRange, File, SearchPath, RelativePath,
414  Imported, FileType);
415  Second->InclusionDirective(HashLoc, IncludeTok, FileName, IsAngled,
416  FilenameRange, File, SearchPath, RelativePath,
417  Imported, FileType);
418  }
419 
421  bool ForPragma) override {
422  First->EnteredSubmodule(M, ImportLoc, ForPragma);
423  Second->EnteredSubmodule(M, ImportLoc, ForPragma);
424  }
425 
426  void LeftSubmodule(Module *M, SourceLocation ImportLoc,
427  bool ForPragma) override {
428  First->LeftSubmodule(M, ImportLoc, ForPragma);
429  Second->LeftSubmodule(M, ImportLoc, ForPragma);
430  }
431 
433  const Module *Imported) override {
434  First->moduleImport(ImportLoc, Path, Imported);
435  Second->moduleImport(ImportLoc, Path, Imported);
436  }
437 
438  void EndOfMainFile() override {
439  First->EndOfMainFile();
440  Second->EndOfMainFile();
441  }
442 
443  void Ident(SourceLocation Loc, StringRef str) override {
444  First->Ident(Loc, str);
445  Second->Ident(Loc, str);
446  }
447 
449  PragmaIntroducerKind Introducer) override {
450  First->PragmaDirective(Loc, Introducer);
451  Second->PragmaDirective(Loc, Introducer);
452  }
453 
455  StringRef Str) override {
456  First->PragmaComment(Loc, Kind, Str);
457  Second->PragmaComment(Loc, Kind, Str);
458  }
459 
460  void PragmaDetectMismatch(SourceLocation Loc, StringRef Name,
461  StringRef Value) override {
462  First->PragmaDetectMismatch(Loc, Name, Value);
463  Second->PragmaDetectMismatch(Loc, Name, Value);
464  }
465 
466  void PragmaDebug(SourceLocation Loc, StringRef DebugType) override {
467  First->PragmaDebug(Loc, DebugType);
468  Second->PragmaDebug(Loc, DebugType);
469  }
470 
471  void PragmaMessage(SourceLocation Loc, StringRef Namespace,
472  PragmaMessageKind Kind, StringRef Str) override {
473  First->PragmaMessage(Loc, Namespace, Kind, Str);
474  Second->PragmaMessage(Loc, Namespace, Kind, Str);
475  }
476 
477  void PragmaDiagnosticPush(SourceLocation Loc, StringRef Namespace) override {
478  First->PragmaDiagnosticPush(Loc, Namespace);
479  Second->PragmaDiagnosticPush(Loc, Namespace);
480  }
481 
482  void PragmaDiagnosticPop(SourceLocation Loc, StringRef Namespace) override {
483  First->PragmaDiagnosticPop(Loc, Namespace);
484  Second->PragmaDiagnosticPop(Loc, Namespace);
485  }
486 
487  void PragmaDiagnostic(SourceLocation Loc, StringRef Namespace,
488  diag::Severity mapping, StringRef Str) override {
489  First->PragmaDiagnostic(Loc, Namespace, mapping, Str);
490  Second->PragmaDiagnostic(Loc, Namespace, mapping, Str);
491  }
492 
493  void HasInclude(SourceLocation Loc, StringRef FileName, bool IsAngled,
494  const FileEntry *File,
495  SrcMgr::CharacteristicKind FileType) override {
496  First->HasInclude(Loc, FileName, IsAngled, File, FileType);
497  Second->HasInclude(Loc, FileName, IsAngled, File, FileType);
498  }
499 
501  SourceLocation StateLoc, unsigned State) override {
502  First->PragmaOpenCLExtension(NameLoc, Name, StateLoc, State);
503  Second->PragmaOpenCLExtension(NameLoc, Name, StateLoc, State);
504  }
505 
506  void PragmaWarning(SourceLocation Loc, StringRef WarningSpec,
507  ArrayRef<int> Ids) override {
508  First->PragmaWarning(Loc, WarningSpec, Ids);
509  Second->PragmaWarning(Loc, WarningSpec, Ids);
510  }
511 
512  void PragmaWarningPush(SourceLocation Loc, int Level) override {
513  First->PragmaWarningPush(Loc, Level);
514  Second->PragmaWarningPush(Loc, Level);
515  }
516 
517  void PragmaWarningPop(SourceLocation Loc) override {
518  First->PragmaWarningPop(Loc);
519  Second->PragmaWarningPop(Loc);
520  }
521 
522  void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str) override {
523  First->PragmaExecCharsetPush(Loc, Str);
524  Second->PragmaExecCharsetPush(Loc, Str);
525  }
526 
528  First->PragmaExecCharsetPop(Loc);
529  Second->PragmaExecCharsetPop(Loc);
530  }
531 
533  First->PragmaAssumeNonNullBegin(Loc);
534  Second->PragmaAssumeNonNullBegin(Loc);
535  }
536 
538  First->PragmaAssumeNonNullEnd(Loc);
539  Second->PragmaAssumeNonNullEnd(Loc);
540  }
541 
542  void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
543  SourceRange Range, const MacroArgs *Args) override {
544  First->MacroExpands(MacroNameTok, MD, Range, Args);
545  Second->MacroExpands(MacroNameTok, MD, Range, Args);
546  }
547 
548  void MacroDefined(const Token &MacroNameTok,
549  const MacroDirective *MD) override {
550  First->MacroDefined(MacroNameTok, MD);
551  Second->MacroDefined(MacroNameTok, MD);
552  }
553 
554  void MacroUndefined(const Token &MacroNameTok,
555  const MacroDefinition &MD,
556  const MacroDirective *Undef) override {
557  First->MacroUndefined(MacroNameTok, MD, Undef);
558  Second->MacroUndefined(MacroNameTok, MD, Undef);
559  }
560 
561  void Defined(const Token &MacroNameTok, const MacroDefinition &MD,
562  SourceRange Range) override {
563  First->Defined(MacroNameTok, MD, Range);
564  Second->Defined(MacroNameTok, MD, Range);
565  }
566 
567  void SourceRangeSkipped(SourceRange Range, SourceLocation EndifLoc) override {
568  First->SourceRangeSkipped(Range, EndifLoc);
569  Second->SourceRangeSkipped(Range, EndifLoc);
570  }
571 
572  /// Hook called whenever an \#if is seen.
573  void If(SourceLocation Loc, SourceRange ConditionRange,
574  ConditionValueKind ConditionValue) override {
575  First->If(Loc, ConditionRange, ConditionValue);
576  Second->If(Loc, ConditionRange, ConditionValue);
577  }
578 
579  /// Hook called whenever an \#elif is seen.
580  void Elif(SourceLocation Loc, SourceRange ConditionRange,
581  ConditionValueKind ConditionValue, SourceLocation IfLoc) override {
582  First->Elif(Loc, ConditionRange, ConditionValue, IfLoc);
583  Second->Elif(Loc, ConditionRange, ConditionValue, IfLoc);
584  }
585 
586  /// Hook called whenever an \#ifdef is seen.
587  void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
588  const MacroDefinition &MD) override {
589  First->Ifdef(Loc, MacroNameTok, MD);
590  Second->Ifdef(Loc, MacroNameTok, MD);
591  }
592 
593  /// Hook called whenever an \#ifndef is seen.
594  void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
595  const MacroDefinition &MD) override {
596  First->Ifndef(Loc, MacroNameTok, MD);
597  Second->Ifndef(Loc, MacroNameTok, MD);
598  }
599 
600  /// Hook called whenever an \#else is seen.
601  void Else(SourceLocation Loc, SourceLocation IfLoc) override {
602  First->Else(Loc, IfLoc);
603  Second->Else(Loc, IfLoc);
604  }
605 
606  /// Hook called whenever an \#endif is seen.
607  void Endif(SourceLocation Loc, SourceLocation IfLoc) override {
608  First->Endif(Loc, IfLoc);
609  Second->Endif(Loc, IfLoc);
610  }
611 };
612 
613 } // end namespace clang
614 
615 #endif
void PragmaDiagnosticPush(SourceLocation Loc, StringRef Namespace) override
Callback invoked when a #pragma gcc diagnostic push directive is read.
Definition: PPCallbacks.h:477
virtual void Elif(SourceLocation Loc, SourceRange ConditionRange, ConditionValueKind ConditionValue, SourceLocation IfLoc)
Hook called whenever an #elif is seen.
Definition: PPCallbacks.h:343
virtual void PragmaDiagnosticPop(SourceLocation Loc, StringRef Namespace)
Callback invoked when a #pragma gcc diagnostic pop directive is read.
Definition: PPCallbacks.h:236
void MacroUndefined(const Token &MacroNameTok, const MacroDefinition &MD, const MacroDirective *Undef) override
Hook called whenever a macro #undef is seen.
Definition: PPCallbacks.h:554
#pragma GCC error has been invoked.
Definition: PPCallbacks.h:216
virtual void PragmaOpenCLExtension(SourceLocation NameLoc, const IdentifierInfo *Name, SourceLocation StateLoc, unsigned State)
Called when an OpenCL extension is either disabled or enabled with a pragma.
Definition: PPCallbacks.h:246
virtual void EndOfMainFile()
Callback invoked when the end of the main file is reached.
Definition: PPCallbacks.h:175
Defines the SourceManager interface.
void PragmaWarning(SourceLocation Loc, StringRef WarningSpec, ArrayRef< int > Ids) override
Callback invoked when a #pragma warning directive is read.
Definition: PPCallbacks.h:506
virtual void MacroUndefined(const Token &MacroNameTok, const MacroDefinition &MD, const MacroDirective *Undef)
Hook called whenever a macro #undef is seen.
Definition: PPCallbacks.h:297
A description of the current definition of a macro.
Definition: MacroInfo.h:564
void If(SourceLocation Loc, SourceRange ConditionRange, ConditionValueKind ConditionValue) override
Hook called whenever an #if is seen.
Definition: PPCallbacks.h:573
virtual void PragmaWarningPush(SourceLocation Loc, int Level)
Callback invoked when a #pragma warning(push) directive is read.
Definition: PPCallbacks.h:257
virtual void PragmaWarningPop(SourceLocation Loc)
Callback invoked when a #pragma warning(pop) directive is read.
Definition: PPCallbacks.h:261
void PragmaWarningPop(SourceLocation Loc) override
Callback invoked when a #pragma warning(pop) directive is read.
Definition: PPCallbacks.h:517
Severity
Enum values that allow the client to map NOTEs, WARNINGs, and EXTENSIONs to either Ignore (nothing)...
Definition: DiagnosticIDs.h:79
void Ifdef(SourceLocation Loc, const Token &MacroNameTok, const MacroDefinition &MD) override
Hook called whenever an #ifdef is seen.
Definition: PPCallbacks.h:587
CharacteristicKind
Indicates whether a file or directory holds normal user code, system code, or system code which is im...
Definition: SourceManager.h:77
This interface provides a way to observe the actions of the preprocessor as it does its thing...
Definition: PPCallbacks.h:35
virtual void MacroDefined(const Token &MacroNameTok, const MacroDirective *MD)
Hook called whenever a macro definition is seen.
Definition: PPCallbacks.h:287
virtual void Else(SourceLocation Loc, SourceLocation IfLoc)
Hook called whenever an #else is seen.
Definition: PPCallbacks.h:366
virtual void If(SourceLocation Loc, SourceRange ConditionRange, ConditionValueKind ConditionValue)
Hook called whenever an #if is seen.
Definition: PPCallbacks.h:333
One of these records is kept for each identifier that is lexed.
virtual void PragmaDebug(SourceLocation Loc, StringRef DebugType)
Callback invoked when a #pragma clang __debug directive is read.
Definition: PPCallbacks.h:204
LineState State
virtual void PragmaExecCharsetPop(SourceLocation Loc)
Callback invoked when a #pragma execution_character_set(pop) directive is read.
Definition: PPCallbacks.h:270
void EnteredSubmodule(Module *M, SourceLocation ImportLoc, bool ForPragma) override
Callback invoked whenever a submodule was entered.
Definition: PPCallbacks.h:420
Definition: Format.h:2274
Token - This structure provides full information about a lexed token.
Definition: Token.h:34
virtual void Endif(SourceLocation Loc, SourceLocation IfLoc)
Hook called whenever an #endif is seen.
Definition: PPCallbacks.h:372
Describes a module or submodule.
Definition: Module.h:64
PPChainedCallbacks(std::unique_ptr< PPCallbacks > _First, std::unique_ptr< PPCallbacks > _Second)
Definition: PPCallbacks.h:382
void LeftSubmodule(Module *M, SourceLocation ImportLoc, bool ForPragma) override
Callback invoked whenever a submodule was left.
Definition: PPCallbacks.h:426
void FileSkipped(const FileEntry &SkippedFile, const Token &FilenameTok, SrcMgr::CharacteristicKind FileType) override
Callback invoked whenever a source file is skipped as the result of header guard optimization.
Definition: PPCallbacks.h:393
virtual void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str)
Callback invoked when a #pragma execution_character_set(push) directive is read.
Definition: PPCallbacks.h:266
PragmaIntroducerKind
Describes how the pragma was introduced, e.g., with #pragma, _Pragma, or __pragma.
Definition: Pragma.h:32
virtual void Defined(const Token &MacroNameTok, const MacroDefinition &MD, SourceRange Range)
Hook called whenever the &#39;defined&#39; operator is seen.
Definition: PPCallbacks.h:304
void Ifndef(SourceLocation Loc, const Token &MacroNameTok, const MacroDefinition &MD) override
Hook called whenever an #ifndef is seen.
Definition: PPCallbacks.h:594
PragmaMessageKind
Determines the kind of #pragma invoking a call to PragmaMessage.
Definition: PPCallbacks.h:208
virtual void PragmaAssumeNonNullBegin(SourceLocation Loc)
Callback invoked when a #pragma clang assume_nonnull begin directive is read.
Definition: PPCallbacks.h:274
#pragma GCC warning has been invoked.
Definition: PPCallbacks.h:213
virtual void PragmaWarning(SourceLocation Loc, StringRef WarningSpec, ArrayRef< int > Ids)
Callback invoked when a #pragma warning directive is read.
Definition: PPCallbacks.h:252
bool FileNotFound(StringRef FileName, SmallVectorImpl< char > &RecoveryPath) override
Callback invoked whenever an inclusion directive results in a file-not-found error.
Definition: PPCallbacks.h:400
Represents a character-granular source range.
void Ident(SourceLocation Loc, StringRef str) override
Callback invoked when a #ident or #sccs directive is read.
Definition: PPCallbacks.h:443
void PragmaWarningPush(SourceLocation Loc, int Level) override
Callback invoked when a #pragma warning(push) directive is read.
Definition: PPCallbacks.h:512
void FileChanged(SourceLocation Loc, FileChangeReason Reason, SrcMgr::CharacteristicKind FileType, FileID PrevFID) override
Callback invoked whenever a source file is entered or exited.
Definition: PPCallbacks.h:386
MacroArgs - An instance of this class captures information about the formal arguments specified to a ...
Definition: MacroArgs.h:29
void Elif(SourceLocation Loc, SourceRange ConditionRange, ConditionValueKind ConditionValue, SourceLocation IfLoc) override
Hook called whenever an #elif is seen.
Definition: PPCallbacks.h:580
virtual void HasInclude(SourceLocation Loc, StringRef FileName, bool IsAngled, const FileEntry *File, SrcMgr::CharacteristicKind FileType)
Hook called when a &#39;__has_include&#39; or &#39;__has_include_next&#39; directive is read.
Definition: PPCallbacks.h:310
void PragmaAssumeNonNullBegin(SourceLocation Loc) override
Callback invoked when a #pragma clang assume_nonnull begin directive is read.
Definition: PPCallbacks.h:532
virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason, SrcMgr::CharacteristicKind FileType, FileID PrevFID=FileID())
Callback invoked whenever a source file is entered or exited.
Definition: PPCallbacks.h:47
void PragmaMessage(SourceLocation Loc, StringRef Namespace, PragmaMessageKind Kind, StringRef Str) override
Callback invoked when a #pragma message directive is read.
Definition: PPCallbacks.h:471
virtual void EnteredSubmodule(Module *M, SourceLocation ImportLoc, bool ForPragma)
Callback invoked whenever a submodule was entered.
Definition: PPCallbacks.h:143
virtual void PragmaComment(SourceLocation Loc, const IdentifierInfo *Kind, StringRef Str)
Callback invoked when a #pragma comment directive is read.
Definition: PPCallbacks.h:191
virtual void PragmaDirective(SourceLocation Loc, PragmaIntroducerKind Introducer)
Callback invoked when start reading any pragma directive.
Definition: PPCallbacks.h:186
Simple wrapper class for chaining callbacks.
Definition: PPCallbacks.h:377
virtual void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName, bool IsAngled, CharSourceRange FilenameRange, const FileEntry *File, StringRef SearchPath, StringRef RelativePath, const Module *Imported, SrcMgr::CharacteristicKind FileType)
Callback invoked whenever an inclusion directive of any kind (#include, #import, etc.) has been processed, regardless of whether the inclusion will actually result in an inclusion.
Definition: PPCallbacks.h:123
Encapsulates changes to the "macros namespace" (the location where the macro name became active...
Definition: MacroInfo.h:290
Kind
virtual void Ident(SourceLocation Loc, StringRef str)
Callback invoked when a #ident or #sccs directive is read.
Definition: PPCallbacks.h:182
Encodes a location in the source.
void moduleImport(SourceLocation ImportLoc, ModuleIdPath Path, const Module *Imported) override
Callback invoked whenever there was an explicit module-import syntax.
Definition: PPCallbacks.h:432
virtual void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD, SourceRange Range, const MacroArgs *Args)
Called by Preprocessor::HandleMacroExpandedIdentifier when a macro invocation is found.
Definition: PPCallbacks.h:282
#pragma message has been invoked.
Definition: PPCallbacks.h:210
void PragmaDebug(SourceLocation Loc, StringRef DebugType) override
Callback invoked when a #pragma clang __debug directive is read.
Definition: PPCallbacks.h:466
void PragmaAssumeNonNullEnd(SourceLocation Loc) override
Callback invoked when a #pragma clang assume_nonnull end directive is read.
Definition: PPCallbacks.h:537
Cached information about one file (either on disk or in the virtual file system). ...
Definition: FileManager.h:59
virtual void moduleImport(SourceLocation ImportLoc, ModuleIdPath Path, const Module *Imported)
Callback invoked whenever there was an explicit module-import syntax.
Definition: PPCallbacks.h:167
void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok, StringRef FileName, bool IsAngled, CharSourceRange FilenameRange, const FileEntry *File, StringRef SearchPath, StringRef RelativePath, const Module *Imported, SrcMgr::CharacteristicKind FileType) override
Callback invoked whenever an inclusion directive of any kind (#include, #import, etc.) has been processed, regardless of whether the inclusion will actually result in an inclusion.
Definition: PPCallbacks.h:406
virtual void Ifdef(SourceLocation Loc, const Token &MacroNameTok, const MacroDefinition &MD)
Hook called whenever an #ifdef is seen.
Definition: PPCallbacks.h:351
void PragmaDirective(SourceLocation Loc, PragmaIntroducerKind Introducer) override
Callback invoked when start reading any pragma directive.
Definition: PPCallbacks.h:448
void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD, SourceRange Range, const MacroArgs *Args) override
Called by Preprocessor::HandleMacroExpandedIdentifier when a macro invocation is found.
Definition: PPCallbacks.h:542
void HasInclude(SourceLocation Loc, StringRef FileName, bool IsAngled, const FileEntry *File, SrcMgr::CharacteristicKind FileType) override
Hook called when a &#39;__has_include&#39; or &#39;__has_include_next&#39; directive is read.
Definition: PPCallbacks.h:493
virtual void PragmaMessage(SourceLocation Loc, StringRef Namespace, PragmaMessageKind Kind, StringRef Str)
Callback invoked when a #pragma message directive is read.
Definition: PPCallbacks.h:224
void PragmaComment(SourceLocation Loc, const IdentifierInfo *Kind, StringRef Str) override
Callback invoked when a #pragma comment directive is read.
Definition: PPCallbacks.h:454
void PragmaDiagnostic(SourceLocation Loc, StringRef Namespace, diag::Severity mapping, StringRef Str) override
Callback invoked when a #pragma gcc diagnostic directive is read.
Definition: PPCallbacks.h:487
An opaque identifier used by SourceManager which refers to a source file (MemoryBuffer) along with it...
void Defined(const Token &MacroNameTok, const MacroDefinition &MD, SourceRange Range) override
Hook called whenever the &#39;defined&#39; operator is seen.
Definition: PPCallbacks.h:561
void MacroDefined(const Token &MacroNameTok, const MacroDirective *MD) override
Hook called whenever a macro definition is seen.
Definition: PPCallbacks.h:548
Dataflow Directional Tag Classes.
void PragmaDiagnosticPop(SourceLocation Loc, StringRef Namespace) override
Callback invoked when a #pragma gcc diagnostic pop directive is read.
Definition: PPCallbacks.h:482
void PragmaDetectMismatch(SourceLocation Loc, StringRef Name, StringRef Value) override
Callback invoked when a #pragma detect_mismatch directive is read.
Definition: PPCallbacks.h:460
virtual void LeftSubmodule(Module *M, SourceLocation ImportLoc, bool ForPragma)
Callback invoked whenever a submodule was left.
Definition: PPCallbacks.h:154
virtual void PragmaDetectMismatch(SourceLocation Loc, StringRef Name, StringRef Value)
Callback invoked when a #pragma detect_mismatch directive is read.
Definition: PPCallbacks.h:197
void PragmaOpenCLExtension(SourceLocation NameLoc, const IdentifierInfo *Name, SourceLocation StateLoc, unsigned State) override
Called when an OpenCL extension is either disabled or enabled with a pragma.
Definition: PPCallbacks.h:500
void EndOfMainFile() override
Callback invoked when the end of the main file is reached.
Definition: PPCallbacks.h:438
virtual bool FileNotFound(StringRef FileName, SmallVectorImpl< char > &RecoveryPath)
Callback invoked whenever an inclusion directive results in a file-not-found error.
Definition: PPCallbacks.h:77
virtual void Ifndef(SourceLocation Loc, const Token &MacroNameTok, const MacroDefinition &MD)
Hook called whenever an #ifndef is seen.
Definition: PPCallbacks.h:359
void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str) override
Callback invoked when a #pragma execution_character_set(push) directive is read.
Definition: PPCallbacks.h:522
virtual void PragmaAssumeNonNullEnd(SourceLocation Loc)
Callback invoked when a #pragma clang assume_nonnull end directive is read.
Definition: PPCallbacks.h:278
Defines the clang::SourceLocation class and associated facilities.
void Endif(SourceLocation Loc, SourceLocation IfLoc) override
Hook called whenever an #endif is seen.
Definition: PPCallbacks.h:607
void PragmaExecCharsetPop(SourceLocation Loc) override
Callback invoked when a #pragma execution_character_set(pop) directive is read.
Definition: PPCallbacks.h:527
virtual void PragmaDiagnosticPush(SourceLocation Loc, StringRef Namespace)
Callback invoked when a #pragma gcc diagnostic push directive is read.
Definition: PPCallbacks.h:230
Defines the Diagnostic IDs-related interfaces.
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:241
void SourceRangeSkipped(SourceRange Range, SourceLocation EndifLoc) override
Hook called when a source range is skipped.
Definition: PPCallbacks.h:567
A trivial tuple used to represent a source range.
void Else(SourceLocation Loc, SourceLocation IfLoc) override
Hook called whenever an #else is seen.
Definition: PPCallbacks.h:601
virtual void FileSkipped(const FileEntry &SkippedFile, const Token &FilenameTok, SrcMgr::CharacteristicKind FileType)
Callback invoked whenever a source file is skipped as the result of header guard optimization.
Definition: PPCallbacks.h:60
virtual void SourceRangeSkipped(SourceRange Range, SourceLocation EndifLoc)
Hook called when a source range is skipped.
Definition: PPCallbacks.h:320