Clang Project

clang_source_code/include/clang/Lex/PPCallbacks.h
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
17#include "clang/Basic/DiagnosticIDs.h"
18#include "clang/Basic/SourceLocation.h"
19#include "clang/Basic/SourceManager.h"
20#include "clang/Lex/ModuleLoader.h"
21#include "clang/Lex/Pragma.h"
22#include "llvm/ADT/StringRef.h"
23
24namespace 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.
35class PPCallbacks {
36public:
37  virtual ~PPCallbacks();
38
39  enum FileChangeReason {
40    EnterFile, ExitFile, SystemHeaderPragma, RenameFile
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,
48                           SrcMgr::CharacteristicKind FileType,
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 there was an explicit module-import
136  /// syntax.
137  ///
138  /// \param ImportLoc The location of import directive token.
139  ///
140  /// \param Path The identifiers (and their locations) of the module
141  /// "path", e.g., "std.vector" would be split into "std" and "vector".
142  ///
143  /// \param Imported The imported module; can be null if importing failed.
144  ///
145  virtual void moduleImport(SourceLocation ImportLoc,
146                            ModuleIdPath Path,
147                            const Module *Imported) {
148  }
149
150  /// Callback invoked when the end of the main file is reached.
151  ///
152  /// No subsequent callbacks will be made.
153  virtual void EndOfMainFile() {
154  }
155
156  /// Callback invoked when a \#ident or \#sccs directive is read.
157  /// \param Loc The location of the directive.
158  /// \param str The text of the directive.
159  ///
160  virtual void Ident(SourceLocation Loc, StringRef str) {
161  }
162
163  /// Callback invoked when start reading any pragma directive.
164  virtual void PragmaDirective(SourceLocation Loc,
165                               PragmaIntroducerKind Introducer) {
166  }
167
168  /// Callback invoked when a \#pragma comment directive is read.
169  virtual void PragmaComment(SourceLocation Loc, const IdentifierInfo *Kind,
170                             StringRef Str) {
171  }
172
173  /// Callback invoked when a \#pragma detect_mismatch directive is
174  /// read.
175  virtual void PragmaDetectMismatch(SourceLocation Loc, StringRef Name,
176                                    StringRef Value) {
177  }
178
179  /// Callback invoked when a \#pragma clang __debug directive is read.
180  /// \param Loc The location of the debug directive.
181  /// \param DebugType The identifier following __debug.
182  virtual void PragmaDebug(SourceLocation Loc, StringRef DebugType) {
183  }
184
185  /// Determines the kind of \#pragma invoking a call to PragmaMessage.
186  enum PragmaMessageKind {
187    /// \#pragma message has been invoked.
188    PMK_Message,
189
190    /// \#pragma GCC warning has been invoked.
191    PMK_Warning,
192
193    /// \#pragma GCC error has been invoked.
194    PMK_Error
195  };
196
197  /// Callback invoked when a \#pragma message directive is read.
198  /// \param Loc The location of the message directive.
199  /// \param Namespace The namespace of the message directive.
200  /// \param Kind The type of the message directive.
201  /// \param Str The text of the message directive.
202  virtual void PragmaMessage(SourceLocation Loc, StringRef Namespace,
203                             PragmaMessageKind Kind, StringRef Str) {
204  }
205
206  /// Callback invoked when a \#pragma gcc diagnostic push directive
207  /// is read.
208  virtual void PragmaDiagnosticPush(SourceLocation Loc,
209                                    StringRef Namespace) {
210  }
211
212  /// Callback invoked when a \#pragma gcc diagnostic pop directive
213  /// is read.
214  virtual void PragmaDiagnosticPop(SourceLocation Loc,
215                                   StringRef Namespace) {
216  }
217
218  /// Callback invoked when a \#pragma gcc diagnostic directive is read.
219  virtual void PragmaDiagnostic(SourceLocation Loc, StringRef Namespace,
220                                diag::Severity mapping, StringRef Str) {}
221
222  /// Called when an OpenCL extension is either disabled or
223  /// enabled with a pragma.
224  virtual void PragmaOpenCLExtension(SourceLocation NameLoc,
225                                     const IdentifierInfo *Name,
226                                     SourceLocation StateLoc, unsigned State) {
227  }
228
229  /// Callback invoked when a \#pragma warning directive is read.
230  virtual void PragmaWarning(SourceLocation Loc, StringRef WarningSpec,
231                             ArrayRef<int> Ids) {
232  }
233
234  /// Callback invoked when a \#pragma warning(push) directive is read.
235  virtual void PragmaWarningPush(SourceLocation Loc, int Level) {
236  }
237
238  /// Callback invoked when a \#pragma warning(pop) directive is read.
239  virtual void PragmaWarningPop(SourceLocation Loc) {
240  }
241
242  /// Callback invoked when a \#pragma execution_character_set(push) directive
243  /// is read.
244  virtual void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str) {}
245
246  /// Callback invoked when a \#pragma execution_character_set(pop) directive
247  /// is read.
248  virtual void PragmaExecCharsetPop(SourceLocation Loc) {}
249
250  /// Callback invoked when a \#pragma clang assume_nonnull begin directive
251  /// is read.
252  virtual void PragmaAssumeNonNullBegin(SourceLocation Loc) {}
253
254  /// Callback invoked when a \#pragma clang assume_nonnull end directive
255  /// is read.
256  virtual void PragmaAssumeNonNullEnd(SourceLocation Loc) {}
257
258  /// Called by Preprocessor::HandleMacroExpandedIdentifier when a
259  /// macro invocation is found.
260  virtual void MacroExpands(const Token &MacroNameTok,
261                            const MacroDefinition &MD, SourceRange Range,
262                            const MacroArgs *Args) {}
263
264  /// Hook called whenever a macro definition is seen.
265  virtual void MacroDefined(const Token &MacroNameTok,
266                            const MacroDirective *MD) {
267  }
268
269  /// Hook called whenever a macro \#undef is seen.
270  /// \param MacroNameTok The active Token
271  /// \param MD A MacroDefinition for the named macro.
272  /// \param Undef New MacroDirective if the macro was defined, null otherwise.
273  ///
274  /// MD is released immediately following this callback.
275  virtual void MacroUndefined(const Token &MacroNameTok,
276                              const MacroDefinition &MD,
277                              const MacroDirective *Undef) {
278  }
279
280  /// Hook called whenever the 'defined' operator is seen.
281  /// \param MD The MacroDirective if the name was a macro, null otherwise.
282  virtual void Defined(const Token &MacroNameTok, const MacroDefinition &MD,
283                       SourceRange Range) {
284  }
285
286  /// Hook called when a '__has_include' or '__has_include_next' directive is
287  /// read.
288  virtual void HasInclude(SourceLocation Loc, StringRef FileName, bool IsAngled,
289                          const FileEntry *File,
290                          SrcMgr::CharacteristicKind FileType) {}
291
292  /// Hook called when a source range is skipped.
293  /// \param Range The SourceRange that was skipped. The range begins at the
294  /// \#if/\#else directive and ends after the \#endif/\#else directive.
295  /// \param EndifLoc The end location of the 'endif' token, which may precede
296  /// the range skipped by the directive (e.g excluding comments after an
297  /// 'endif').
298  virtual void SourceRangeSkipped(SourceRange Range, SourceLocation EndifLoc) {
299  }
300
301  enum ConditionValueKind {
302    CVK_NotEvaluated, CVK_False, CVK_True
303  };
304
305  /// Hook called whenever an \#if is seen.
306  /// \param Loc the source location of the directive.
307  /// \param ConditionRange The SourceRange of the expression being tested.
308  /// \param ConditionValue The evaluated value of the condition.
309  ///
310  // FIXME: better to pass in a list (or tree!) of Tokens.
311  virtual void If(SourceLocation Loc, SourceRange ConditionRange,
312                  ConditionValueKind ConditionValue) {
313  }
314
315  /// Hook called whenever an \#elif is seen.
316  /// \param Loc the source location of the directive.
317  /// \param ConditionRange The SourceRange of the expression being tested.
318  /// \param ConditionValue The evaluated value of the condition.
319  /// \param IfLoc the source location of the \#if/\#ifdef/\#ifndef directive.
320  // FIXME: better to pass in a list (or tree!) of Tokens.
321  virtual void Elif(SourceLocation Loc, SourceRange ConditionRange,
322                    ConditionValueKind ConditionValue, SourceLocation IfLoc) {
323  }
324
325  /// Hook called whenever an \#ifdef is seen.
326  /// \param Loc the source location of the directive.
327  /// \param MacroNameTok Information on the token being tested.
328  /// \param MD The MacroDefinition if the name was a macro, null otherwise.
329  virtual void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
330                     const MacroDefinition &MD) {
331  }
332
333  /// Hook called whenever an \#ifndef is seen.
334  /// \param Loc the source location of the directive.
335  /// \param MacroNameTok Information on the token being tested.
336  /// \param MD The MacroDefiniton if the name was a macro, null otherwise.
337  virtual void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
338                      const MacroDefinition &MD) {
339  }
340
341  /// Hook called whenever an \#else is seen.
342  /// \param Loc the source location of the directive.
343  /// \param IfLoc the source location of the \#if/\#ifdef/\#ifndef directive.
344  virtual void Else(SourceLocation Loc, SourceLocation IfLoc) {
345  }
346
347  /// Hook called whenever an \#endif is seen.
348  /// \param Loc the source location of the directive.
349  /// \param IfLoc the source location of the \#if/\#ifdef/\#ifndef directive.
350  virtual void Endif(SourceLocation Loc, SourceLocation IfLoc) {
351  }
352};
353
354/// Simple wrapper class for chaining callbacks.
355class PPChainedCallbacks : public PPCallbacks {
356  virtual void anchor();
357  std::unique_ptr<PPCallbacks> First, Second;
358
359public:
360  PPChainedCallbacks(std::unique_ptr<PPCallbacks> _First,
361                     std::unique_ptr<PPCallbacks> _Second)
362    : First(std::move(_First)), Second(std::move(_Second)) {}
363
364  void FileChanged(SourceLocation Loc, FileChangeReason Reason,
365                   SrcMgr::CharacteristicKind FileType,
366                   FileID PrevFID) override {
367    First->FileChanged(Loc, Reason, FileType, PrevFID);
368    Second->FileChanged(Loc, Reason, FileType, PrevFID);
369  }
370
371  void FileSkipped(const FileEntry &SkippedFile,
372                   const Token &FilenameTok,
373                   SrcMgr::CharacteristicKind FileType) override {
374    First->FileSkipped(SkippedFile, FilenameTok, FileType);
375    Second->FileSkipped(SkippedFile, FilenameTok, FileType);
376  }
377
378  bool FileNotFound(StringRef FileName,
379                    SmallVectorImpl<char> &RecoveryPath) override {
380    return First->FileNotFound(FileName, RecoveryPath) ||
381           Second->FileNotFound(FileName, RecoveryPath);
382  }
383
384  void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
385                          StringRef FileName, bool IsAngled,
386                          CharSourceRange FilenameRange, const FileEntry *File,
387                          StringRef SearchPath, StringRef RelativePath,
388                          const Module *Imported,
389                          SrcMgr::CharacteristicKind FileType) override {
390    First->InclusionDirective(HashLoc, IncludeTok, FileName, IsAngled,
391                              FilenameRange, File, SearchPath, RelativePath,
392                              Imported, FileType);
393    Second->InclusionDirective(HashLoc, IncludeTok, FileName, IsAngled,
394                               FilenameRange, File, SearchPath, RelativePath,
395                               Imported, FileType);
396  }
397
398  void moduleImport(SourceLocation ImportLoc, ModuleIdPath Path,
399                    const Module *Imported) override {
400    First->moduleImport(ImportLoc, Path, Imported);
401    Second->moduleImport(ImportLoc, Path, Imported);
402  }
403
404  void EndOfMainFile() override {
405    First->EndOfMainFile();
406    Second->EndOfMainFile();
407  }
408
409  void Ident(SourceLocation Loc, StringRef str) override {
410    First->Ident(Loc, str);
411    Second->Ident(Loc, str);
412  }
413
414  void PragmaDirective(SourceLocation Loc,
415                       PragmaIntroducerKind Introducer) override {
416    First->PragmaDirective(Loc, Introducer);
417    Second->PragmaDirective(Loc, Introducer);
418  }
419
420  void PragmaComment(SourceLocation Loc, const IdentifierInfo *Kind,
421                     StringRef Str) override {
422    First->PragmaComment(Loc, Kind, Str);
423    Second->PragmaComment(Loc, Kind, Str);
424  }
425
426  void PragmaDetectMismatch(SourceLocation Loc, StringRef Name,
427                            StringRef Value) override {
428    First->PragmaDetectMismatch(Loc, Name, Value);
429    Second->PragmaDetectMismatch(Loc, Name, Value);
430  }
431
432  void PragmaDebug(SourceLocation Loc, StringRef DebugType) override {
433    First->PragmaDebug(Loc, DebugType);
434    Second->PragmaDebug(Loc, DebugType);
435  }
436
437  void PragmaMessage(SourceLocation Loc, StringRef Namespace,
438                     PragmaMessageKind Kind, StringRef Str) override {
439    First->PragmaMessage(Loc, Namespace, Kind, Str);
440    Second->PragmaMessage(Loc, Namespace, Kind, Str);
441  }
442
443  void PragmaDiagnosticPush(SourceLocation Loc, StringRef Namespace) override {
444    First->PragmaDiagnosticPush(Loc, Namespace);
445    Second->PragmaDiagnosticPush(Loc, Namespace);
446  }
447
448  void PragmaDiagnosticPop(SourceLocation Loc, StringRef Namespace) override {
449    First->PragmaDiagnosticPop(Loc, Namespace);
450    Second->PragmaDiagnosticPop(Loc, Namespace);
451  }
452
453  void PragmaDiagnostic(SourceLocation Loc, StringRef Namespace,
454                        diag::Severity mapping, StringRef Str) override {
455    First->PragmaDiagnostic(Loc, Namespace, mapping, Str);
456    Second->PragmaDiagnostic(Loc, Namespace, mapping, Str);
457  }
458
459  void HasInclude(SourceLocation Loc, StringRef FileName, bool IsAngled,
460                  const FileEntry *File,
461                  SrcMgr::CharacteristicKind FileType) override {
462    First->HasInclude(Loc, FileName, IsAngled, File, FileType);
463    Second->HasInclude(Loc, FileName, IsAngled, File, FileType);
464  }
465
466  void PragmaOpenCLExtension(SourceLocation NameLoc, const IdentifierInfo *Name,
467                             SourceLocation StateLoc, unsigned State) override {
468    First->PragmaOpenCLExtension(NameLoc, Name, StateLoc, State);
469    Second->PragmaOpenCLExtension(NameLoc, Name, StateLoc, State);
470  }
471
472  void PragmaWarning(SourceLocation Loc, StringRef WarningSpec,
473                     ArrayRef<int> Ids) override {
474    First->PragmaWarning(Loc, WarningSpec, Ids);
475    Second->PragmaWarning(Loc, WarningSpec, Ids);
476  }
477
478  void PragmaWarningPush(SourceLocation Loc, int Level) override {
479    First->PragmaWarningPush(Loc, Level);
480    Second->PragmaWarningPush(Loc, Level);
481  }
482
483  void PragmaWarningPop(SourceLocation Loc) override {
484    First->PragmaWarningPop(Loc);
485    Second->PragmaWarningPop(Loc);
486  }
487
488  void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str) override {
489    First->PragmaExecCharsetPush(Loc, Str);
490    Second->PragmaExecCharsetPush(Loc, Str);
491  }
492
493  void PragmaExecCharsetPop(SourceLocation Loc) override {
494    First->PragmaExecCharsetPop(Loc);
495    Second->PragmaExecCharsetPop(Loc);
496  }
497
498  void PragmaAssumeNonNullBegin(SourceLocation Loc) override {
499    First->PragmaAssumeNonNullBegin(Loc);
500    Second->PragmaAssumeNonNullBegin(Loc);
501  }
502
503  void PragmaAssumeNonNullEnd(SourceLocation Loc) override {
504    First->PragmaAssumeNonNullEnd(Loc);
505    Second->PragmaAssumeNonNullEnd(Loc);
506  }
507
508  void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
509                    SourceRange Range, const MacroArgs *Args) override {
510    First->MacroExpands(MacroNameTok, MD, Range, Args);
511    Second->MacroExpands(MacroNameTok, MD, Range, Args);
512  }
513
514  void MacroDefined(const Token &MacroNameTok,
515                    const MacroDirective *MD) override {
516    First->MacroDefined(MacroNameTok, MD);
517    Second->MacroDefined(MacroNameTok, MD);
518  }
519
520  void MacroUndefined(const Token &MacroNameTok,
521                      const MacroDefinition &MD,
522                      const MacroDirective *Undef) override {
523    First->MacroUndefined(MacroNameTok, MD, Undef);
524    Second->MacroUndefined(MacroNameTok, MD, Undef);
525  }
526
527  void Defined(const Token &MacroNameTok, const MacroDefinition &MD,
528               SourceRange Range) override {
529    First->Defined(MacroNameTok, MD, Range);
530    Second->Defined(MacroNameTok, MD, Range);
531  }
532
533  void SourceRangeSkipped(SourceRange Range, SourceLocation EndifLoc) override {
534    First->SourceRangeSkipped(Range, EndifLoc);
535    Second->SourceRangeSkipped(Range, EndifLoc);
536  }
537
538  /// Hook called whenever an \#if is seen.
539  void If(SourceLocation Loc, SourceRange ConditionRange,
540          ConditionValueKind ConditionValue) override {
541    First->If(Loc, ConditionRange, ConditionValue);
542    Second->If(Loc, ConditionRange, ConditionValue);
543  }
544
545  /// Hook called whenever an \#elif is seen.
546  void Elif(SourceLocation Loc, SourceRange ConditionRange,
547            ConditionValueKind ConditionValue, SourceLocation IfLoc) override {
548    First->Elif(Loc, ConditionRange, ConditionValue, IfLoc);
549    Second->Elif(Loc, ConditionRange, ConditionValue, IfLoc);
550  }
551
552  /// Hook called whenever an \#ifdef is seen.
553  void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
554             const MacroDefinition &MD) override {
555    First->Ifdef(Loc, MacroNameTok, MD);
556    Second->Ifdef(Loc, MacroNameTok, MD);
557  }
558
559  /// Hook called whenever an \#ifndef is seen.
560  void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
561              const MacroDefinition &MD) override {
562    First->Ifndef(Loc, MacroNameTok, MD);
563    Second->Ifndef(Loc, MacroNameTok, MD);
564  }
565
566  /// Hook called whenever an \#else is seen.
567  void Else(SourceLocation Loc, SourceLocation IfLoc) override {
568    First->Else(Loc, IfLoc);
569    Second->Else(Loc, IfLoc);
570  }
571
572  /// Hook called whenever an \#endif is seen.
573  void Endif(SourceLocation Loc, SourceLocation IfLoc) override {
574    First->Endif(Loc, IfLoc);
575    Second->Endif(Loc, IfLoc);
576  }
577};
578
579}  // end namespace clang
580
581#endif
582
clang::PPCallbacks::FileChangeReason
clang::PPCallbacks::FileChanged
clang::PPCallbacks::FileSkipped
clang::PPCallbacks::FileNotFound
clang::PPCallbacks::InclusionDirective
clang::PPCallbacks::moduleImport
clang::PPCallbacks::EndOfMainFile
clang::PPCallbacks::Ident
clang::PPCallbacks::PragmaDirective
clang::PPCallbacks::PragmaComment
clang::PPCallbacks::PragmaDetectMismatch
clang::PPCallbacks::PragmaDebug
clang::PPCallbacks::PragmaMessageKind
clang::PPCallbacks::PragmaMessage
clang::PPCallbacks::PragmaDiagnosticPush
clang::PPCallbacks::PragmaDiagnosticPop
clang::PPCallbacks::PragmaDiagnostic
clang::PPCallbacks::PragmaOpenCLExtension
clang::PPCallbacks::PragmaWarning
clang::PPCallbacks::PragmaWarningPush
clang::PPCallbacks::PragmaWarningPop
clang::PPCallbacks::PragmaExecCharsetPush
clang::PPCallbacks::PragmaExecCharsetPop
clang::PPCallbacks::PragmaAssumeNonNullBegin
clang::PPCallbacks::PragmaAssumeNonNullEnd
clang::PPCallbacks::MacroExpands
clang::PPCallbacks::MacroDefined
clang::PPCallbacks::MacroUndefined
clang::PPCallbacks::Defined
clang::PPCallbacks::HasInclude
clang::PPCallbacks::SourceRangeSkipped
clang::PPCallbacks::ConditionValueKind
clang::PPCallbacks::If
clang::PPCallbacks::Elif
clang::PPCallbacks::Ifdef
clang::PPCallbacks::Ifndef
clang::PPCallbacks::Else
clang::PPCallbacks::Endif
clang::PPChainedCallbacks::anchor
clang::PPChainedCallbacks::First
clang::PPChainedCallbacks::Second
clang::PPChainedCallbacks::FileChanged
clang::PPChainedCallbacks::FileSkipped
clang::PPChainedCallbacks::FileNotFound
clang::PPChainedCallbacks::InclusionDirective
clang::PPChainedCallbacks::moduleImport
clang::PPChainedCallbacks::EndOfMainFile
clang::PPChainedCallbacks::Ident
clang::PPChainedCallbacks::PragmaDirective
clang::PPChainedCallbacks::PragmaComment
clang::PPChainedCallbacks::PragmaDetectMismatch
clang::PPChainedCallbacks::PragmaDebug
clang::PPChainedCallbacks::PragmaMessage
clang::PPChainedCallbacks::PragmaDiagnosticPush
clang::PPChainedCallbacks::PragmaDiagnosticPop
clang::PPChainedCallbacks::PragmaDiagnostic
clang::PPChainedCallbacks::HasInclude
clang::PPChainedCallbacks::PragmaOpenCLExtension
clang::PPChainedCallbacks::PragmaWarning
clang::PPChainedCallbacks::PragmaWarningPush
clang::PPChainedCallbacks::PragmaWarningPop
clang::PPChainedCallbacks::PragmaExecCharsetPush
clang::PPChainedCallbacks::PragmaExecCharsetPop
clang::PPChainedCallbacks::PragmaAssumeNonNullBegin
clang::PPChainedCallbacks::PragmaAssumeNonNullEnd
clang::PPChainedCallbacks::MacroExpands
clang::PPChainedCallbacks::MacroDefined
clang::PPChainedCallbacks::MacroUndefined
clang::PPChainedCallbacks::Defined
clang::PPChainedCallbacks::SourceRangeSkipped
clang::PPChainedCallbacks::If
clang::PPChainedCallbacks::Elif
clang::PPChainedCallbacks::Ifdef
clang::PPChainedCallbacks::Ifndef
clang::PPChainedCallbacks::Else
clang::PPChainedCallbacks::Endif
CodeThinker, Enjoy your reading code