clang-tools  10.0.0git
PPCallbacksTracker.h
Go to the documentation of this file.
1 //===--- PPCallbacksTracker.h - Preprocessor tracking -----------*- 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 /// Classes and definitions for preprocessor tracking.
11 ///
12 /// The core definition is the PPCallbacksTracker class, derived from Clang's
13 /// PPCallbacks class from the Lex library, which overrides all the callbacks
14 /// and collects information about each callback call, saving it in a
15 /// data structure built up of CallbackCall and Argument objects, which
16 /// record the preprocessor callback name and arguments in high-level string
17 /// form for later inspection.
18 ///
19 //===----------------------------------------------------------------------===//
20 
21 #ifndef PPTRACE_PPCALLBACKSTRACKER_H
22 #define PPTRACE_PPCALLBACKSTRACKER_H
23 
24 #include "clang/Lex/PPCallbacks.h"
25 #include "clang/Lex/Preprocessor.h"
26 #include "clang/Basic/SourceManager.h"
27 #include "llvm/ADT/ArrayRef.h"
28 #include "llvm/ADT/SmallSet.h"
29 #include "llvm/ADT/StringMap.h"
30 #include "llvm/ADT/StringRef.h"
31 #include "llvm/Support/GlobPattern.h"
32 #include <string>
33 #include <vector>
34 
35 namespace clang {
36 namespace pp_trace {
37 
38 // This struct represents one callback function argument by name and value.
39 struct Argument {
40  std::string Name;
41  std::string Value;
42 };
43 
44 /// This class represents one callback call by name and an array
45 /// of arguments.
46 class CallbackCall {
47 public:
48  CallbackCall(llvm::StringRef Name) : Name(Name) {}
49  CallbackCall() = default;
50 
51  std::string Name;
52  std::vector<Argument> Arguments;
53 };
54 
55 using FilterType = std::vector<std::pair<llvm::GlobPattern, bool>>;
56 
57 /// This class overrides the PPCallbacks class for tracking preprocessor
58 /// activity by means of its callback functions.
59 ///
60 /// This object is given a vector for storing the trace information, built up
61 /// of CallbackCall and subordinate Argument objects for representing the
62 /// callback calls and their arguments. It's a reference so the vector can
63 /// exist beyond the lifetime of this object, because it's deleted by the
64 /// preprocessor automatically in its destructor.
65 ///
66 /// This class supports a mechanism for inhibiting trace output for
67 /// specific callbacks by name, for the purpose of eliminating output for
68 /// callbacks of no interest that might clutter the output.
69 ///
70 /// Following the constructor and destructor function declarations, the
71 /// overidden callback functions are defined. The remaining functions are
72 /// helpers for recording the trace data, to reduce the coupling between it
73 /// and the recorded data structure.
75 public:
76  /// Note that all of the arguments are references, and owned
77  /// by the caller.
78  /// \param Filters - List of (Glob,Enabled) pairs used to filter callbacks.
79  /// \param CallbackCalls - Trace buffer.
80  /// \param PP - The preprocessor. Needed for getting some argument strings.
81  PPCallbacksTracker(const FilterType &Filters,
82  std::vector<CallbackCall> &CallbackCalls,
83  Preprocessor &PP);
84 
85  ~PPCallbacksTracker() override;
86 
87  // Overidden callback functions.
88 
89  void FileChanged(SourceLocation Loc, PPCallbacks::FileChangeReason Reason,
90  SrcMgr::CharacteristicKind FileType,
91  FileID PrevFID = FileID()) override;
92  void FileSkipped(const FileEntryRef &SkippedFile, const Token &FilenameTok,
93  SrcMgr::CharacteristicKind FileType) override;
94  bool FileNotFound(llvm::StringRef FileName,
95  llvm::SmallVectorImpl<char> &RecoveryPath) override;
96  void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok,
97  llvm::StringRef FileName, bool IsAngled,
98  CharSourceRange FilenameRange, const FileEntry *File,
99  llvm::StringRef SearchPath,
100  llvm::StringRef RelativePath, const Module *Imported,
101  SrcMgr::CharacteristicKind FileType) override;
102  void moduleImport(SourceLocation ImportLoc, ModuleIdPath Path,
103  const Module *Imported) override;
104  void EndOfMainFile() override;
105  void Ident(SourceLocation Loc, llvm::StringRef str) override;
106  void PragmaDirective(SourceLocation Loc,
107  PragmaIntroducerKind Introducer) override;
108  void PragmaComment(SourceLocation Loc, const IdentifierInfo *Kind,
109  llvm::StringRef Str) override;
110  void PragmaDetectMismatch(SourceLocation Loc, llvm::StringRef Name,
111  llvm::StringRef Value) override;
112  void PragmaDebug(SourceLocation Loc, llvm::StringRef DebugType) override;
113  void PragmaMessage(SourceLocation Loc, llvm::StringRef Namespace,
114  PPCallbacks::PragmaMessageKind Kind,
115  llvm::StringRef Str) override;
116  void PragmaDiagnosticPush(SourceLocation Loc,
117  llvm::StringRef Namespace) override;
118  void PragmaDiagnosticPop(SourceLocation Loc,
119  llvm::StringRef Namespace) override;
120  void PragmaDiagnostic(SourceLocation Loc, llvm::StringRef Namespace,
121  diag::Severity mapping, llvm::StringRef Str) override;
122  void PragmaOpenCLExtension(SourceLocation NameLoc, const IdentifierInfo *Name,
123  SourceLocation StateLoc, unsigned State) override;
124  void PragmaWarning(SourceLocation Loc, llvm::StringRef WarningSpec,
125  llvm::ArrayRef<int> Ids) override;
126  void PragmaWarningPush(SourceLocation Loc, int Level) override;
127  void PragmaWarningPop(SourceLocation Loc) override;
128  void PragmaExecCharsetPush(SourceLocation Loc, StringRef Str) override;
129  void PragmaExecCharsetPop(SourceLocation Loc) override;
130  void MacroExpands(const Token &MacroNameTok, const MacroDefinition &MD,
131  SourceRange Range, const MacroArgs *Args) override;
132  void MacroDefined(const Token &MacroNameTok,
133  const MacroDirective *MD) override;
134  void MacroUndefined(const Token &MacroNameTok, const MacroDefinition &MD,
135  const MacroDirective *Undef) override;
136  void Defined(const Token &MacroNameTok, const MacroDefinition &MD,
137  SourceRange Range) override;
138  void SourceRangeSkipped(SourceRange Range, SourceLocation EndifLoc) override;
139  void If(SourceLocation Loc, SourceRange ConditionRange,
140  ConditionValueKind ConditionValue) override;
141  void Elif(SourceLocation Loc, SourceRange ConditionRange,
142  ConditionValueKind ConditionValue, SourceLocation IfLoc) override;
143  void Ifdef(SourceLocation Loc, const Token &MacroNameTok,
144  const MacroDefinition &MD) override;
145  void Ifndef(SourceLocation Loc, const Token &MacroNameTok,
146  const MacroDefinition &MD) override;
147  void Else(SourceLocation Loc, SourceLocation IfLoc) override;
148  void Endif(SourceLocation Loc, SourceLocation IfLoc) override;
149 
150  // Helper functions.
151 
152  /// Start a new callback.
153  void beginCallback(const char *Name);
154 
155  /// Append a string to the top trace item.
156  void append(const char *Str);
157 
158  /// Append a bool argument to the top trace item.
159  void appendArgument(const char *Name, bool Value);
160 
161  /// Append an int argument to the top trace item.
162  void appendArgument(const char *Name, int Value);
163 
164  /// Append a string argument to the top trace item.
165  void appendArgument(const char *Name, const char *Value);
166 
167  /// Append a string reference object argument to the top trace item.
168  void appendArgument(const char *Name, llvm::StringRef Value);
169 
170  /// Append a string object argument to the top trace item.
171  void appendArgument(const char *Name, const std::string &Value);
172 
173  /// Append a token argument to the top trace item.
174  void appendArgument(const char *Name, const Token &Value);
175 
176  /// Append an enum argument to the top trace item.
177  void appendArgument(const char *Name, int Value, const char *const Strings[]);
178 
179  /// Append a FileID argument to the top trace item.
180  void appendArgument(const char *Name, FileID Value);
181 
182  /// Append a FileEntry argument to the top trace item.
183  void appendArgument(const char *Name, const FileEntry *Value);
184 
185  /// Append a SourceLocation argument to the top trace item.
186  void appendArgument(const char *Name, SourceLocation Value);
187 
188  /// Append a SourceRange argument to the top trace item.
189  void appendArgument(const char *Name, SourceRange Value);
190 
191  /// Append a CharSourceRange argument to the top trace item.
192  void appendArgument(const char *Name, CharSourceRange Value);
193 
194  /// Append a ModuleIdPath argument to the top trace item.
195  void appendArgument(const char *Name, ModuleIdPath Value);
196 
197  /// Append an IdentifierInfo argument to the top trace item.
198  void appendArgument(const char *Name, const IdentifierInfo *Value);
199 
200  /// Append a MacroDirective argument to the top trace item.
201  void appendArgument(const char *Name, const MacroDirective *Value);
202 
203  /// Append a MacroDefinition argument to the top trace item.
204  void appendArgument(const char *Name, const MacroDefinition &Value);
205 
206  /// Append a MacroArgs argument to the top trace item.
207  void appendArgument(const char *Name, const MacroArgs *Value);
208 
209  /// Append a Module argument to the top trace item.
210  void appendArgument(const char *Name, const Module *Value);
211 
212  /// Append a double-quoted argument to the top trace item.
213  void appendQuotedArgument(const char *Name, const std::string &Value);
214 
215  /// Append a double-quoted file path argument to the top trace item.
216  void appendFilePathArgument(const char *Name, llvm::StringRef Value);
217 
218  /// Get the raw source string of the range.
219  llvm::StringRef getSourceString(CharSourceRange Range);
220 
221  /// Callback trace information.
222  /// We use a reference so the trace will be preserved for the caller
223  /// after this object is destructed.
224  std::vector<CallbackCall> &CallbackCalls;
225 
226  // List of (Glob,Enabled) pairs used to filter callbacks.
228 
229  // Whether a callback should be printed.
230  llvm::StringMap<bool> CallbackIsEnabled;
231 
232  /// Inhibit trace while this is set.
234 
235  Preprocessor &PP;
236 };
237 
238 } // namespace pp_trace
239 } // namespace clang
240 
241 #endif // PPTRACE_PPCALLBACKSTRACKER_H
SourceLocation Loc
&#39;#&#39; location in the include directive
std::vector< CallbackCall > & CallbackCalls
Callback trace information.
CallbackCall(llvm::StringRef Name)
static std::string getSourceString(clang::Preprocessor &PP, clang::SourceRange Range)
std::vector< HeaderHandle > Path
This class overrides the PPCallbacks class for tracking preprocessor activity by means of its callbac...
BindArgumentKind Kind
bool DisableTrace
Inhibit trace while this is set.
This class represents one callback call by name and an array of arguments.
bool IsAngled
true if this was an include with angle brackets
PathRef FileName
clang::PPCallbacks::ConditionValueKind ConditionValue
std::vector< llvm::StringRef > Strings
llvm::StringMap< bool > CallbackIsEnabled
===– Representation.cpp - ClangDoc Representation --------—*- C++ -*-===//
static GeneratorRegistry::Add< MDGenerator > MD(MDGenerator::Format, "Generator for MD output.")
CharSourceRange Range
SourceRange for the file name.
std::vector< std::pair< llvm::GlobPattern, bool > > FilterType
std::vector< Argument > Arguments