// Hook called whenever a macro definition is seen.
void
PPCallbacksTracker::MacroDefined(const clang::Token &MacroNameTok,
const clang::MacroDirective *MacroDirective) {
beginCallback("MacroDefined");
appendArgument("MacroNameTok", MacroNameTok);
appendArgument("MacroDirective", MacroDirective);
}
// Hook called whenever a macro #undef is seen.
void PPCallbacksTracker::MacroUndefined(
const clang::Token &MacroNameTok,
const clang::MacroDefinition &MacroDefinition) {
beginCallback("MacroUndefined");
appendArgument("MacroNameTok", MacroNameTok);
appendArgument("MacroDefinition", MacroDefinition);
}
// Callback invoked when start reading any pragma directive.
void
PPCallbacksTracker::PragmaDirective(clang::SourceLocation Loc,
clang::PragmaIntroducerKind Introducer) {
beginCallback("PragmaDirective");
appendArgument("Loc", Loc);
appendArgument("Introducer", Introducer, PragmaIntroducerKindStrings);
}
// Append an IdentifierInfo argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name,
const clang::IdentifierInfo *Value) {
if (!Value) {
appendArgument(Name, "(null)");
return;
}
appendArgument(Name, Value->getName().str().c_str());
}
// Append a SourceLocation argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name,
clang::SourceLocation Value) {
if (Value.isInvalid()) {
appendArgument(Name, "(invalid)");
return;
}
appendArgument(Name, getSourceLocationString(PP, Value).c_str());
}
// Callback invoked when a #pragma detect_mismatch directive is
// read.
void PPCallbacksTracker::PragmaDetectMismatch(clang::SourceLocation Loc,
llvm::StringRef Name,
llvm::StringRef Value) {
beginCallback("PragmaDetectMismatch");
appendArgument("Loc", Loc);
appendArgument("Name", Name);
appendArgument("Value", Value);
}
// Callback invoked when a #pragma comment directive is read.
void PPCallbacksTracker::PragmaComment(clang::SourceLocation Loc,
const clang::IdentifierInfo *Kind,
llvm::StringRef Str) {
beginCallback("PragmaComment");
appendArgument("Loc", Loc);
appendArgument("Kind", Kind);
appendArgument("Str", Str);
}
// Callback invoked whenever there was an explicit module-import
// syntax.
void PPCallbacksTracker::moduleImport(clang::SourceLocation ImportLoc,
clang::ModuleIdPath Path,
const clang::Module *Imported) {
beginCallback("moduleImport");
appendArgument("ImportLoc", ImportLoc);
appendArgument("Path", Path);
appendArgument("Imported", Imported);
}
// Append a Module argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name,
const clang::Module *Value) {
if (!Value) {
appendArgument(Name, "(null)");
return;
}
appendArgument(Name, Value->Name.c_str());
}
// Append a CharSourceRange argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name,
clang::CharSourceRange Value) {
if (Value.isInvalid()) {
appendArgument(Name, "(invalid)");
return;
}
appendArgument(Name, getSourceString(Value).str().c_str());
}
// Append a MacroDirective argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name,
const clang::MacroDirective *Value) {
if (!Value) {
appendArgument(Name, "(null)");
return;
}
appendArgument(Name, MacroDirectiveKindStrings[Value->getKind()]);
}
// Hook called whenever an #ifndef is seen.
void PPCallbacksTracker::Ifndef(clang::SourceLocation Loc,
const clang::Token &MacroNameTok,
const clang::MacroDefinition &MacroDefinition) {
beginCallback("Ifndef");
appendArgument("Loc", Loc);
appendArgument("MacroNameTok", MacroNameTok);
appendArgument("MacroDefinition", MacroDefinition);
}
// Hook called whenever an #if is seen.
void PPCallbacksTracker::If(clang::SourceLocation Loc,
clang::SourceRange ConditionRange,
ConditionValueKind ConditionValue) {
beginCallback("If");
appendArgument("Loc", Loc);
appendArgument("ConditionRange", ConditionRange);
appendArgument("ConditionValue", ConditionValue, ConditionValueKindStrings);
}
// Hook called whenever the 'defined' operator is seen.
void PPCallbacksTracker::Defined(const clang::Token &MacroNameTok,
const clang::MacroDefinition &MacroDefinition,
clang::SourceRange Range) {
beginCallback("Defined");
appendArgument("MacroNameTok", MacroNameTok);
appendArgument("MacroDefinition", MacroDefinition);
appendArgument("Range", Range);
}
// Callback invoked whenever a source file is skipped as the result
// of header guard optimization.
void
PPCallbacksTracker::FileSkipped(const clang::FileEntry &SkippedFile,
const clang::Token &FilenameTok,
clang::SrcMgr::CharacteristicKind FileType) {
beginCallback("FileSkipped");
appendArgument("ParentFile", &SkippedFile);
appendArgument("FilenameTok", FilenameTok);
appendArgument("FileType", FileType, CharacteristicKindStrings);
}
// Callback invoked when a #pragma message directive is read.
void PPCallbacksTracker::PragmaMessage(
clang::SourceLocation Loc, llvm::StringRef Namespace,
clang::PPCallbacks::PragmaMessageKind Kind, llvm::StringRef Str) {
beginCallback("PragmaMessage");
appendArgument("Loc", Loc);
appendArgument("Namespace", Namespace);
appendArgument("Kind", Kind, PragmaMessageKindStrings);
appendArgument("Str", Str);
}
// Called when an OpenCL extension is either disabled or
// enabled with a pragma.
void PPCallbacksTracker::PragmaOpenCLExtension(
clang::SourceLocation NameLoc, const clang::IdentifierInfo *Name,
clang::SourceLocation StateLoc, unsigned State) {
beginCallback("PragmaOpenCLExtension");
appendArgument("NameLoc", NameLoc);
appendArgument("Name", Name);
appendArgument("StateLoc", StateLoc);
appendArgument("State", (int)State);
}
// Callback invoked whenever a source file is entered or exited.
void PPCallbacksTracker::FileChanged(
clang::SourceLocation Loc, clang::PPCallbacks::FileChangeReason Reason,
clang::SrcMgr::CharacteristicKind FileType, clang::FileID PrevFID) {
beginCallback("FileChanged");
appendArgument("Loc", Loc);
appendArgument("Reason", Reason, FileChangeReasonStrings);
appendArgument("FileType", FileType, CharacteristicKindStrings);
appendArgument("PrevFID", PrevFID);
}
// Callback invoked when a #pragma gcc dianostic directive is read.
void PPCallbacksTracker::PragmaDiagnostic(clang::SourceLocation Loc,
llvm::StringRef Namespace,
clang::diag::Severity Mapping,
llvm::StringRef Str) {
beginCallback("PragmaDiagnostic");
appendArgument("Loc", Loc);
appendArgument("Namespace", Namespace);
appendArgument("Mapping", (unsigned)Mapping, MappingStrings);
appendArgument("Str", Str);
}
// Called by Preprocessor::HandleMacroExpandedIdentifier when a
// macro invocation is found.
void
PPCallbacksTracker::MacroExpands(const clang::Token &MacroNameTok,
const clang::MacroDefinition &MacroDefinition,
clang::SourceRange Range,
const clang::MacroArgs *Args) {
beginCallback("MacroExpands");
appendArgument("MacroNameTok", MacroNameTok);
appendArgument("MacroDefinition", MacroDefinition);
appendArgument("Range", Range);
appendArgument("Args", Args);
}
// Append a FileID argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name, clang::FileID Value) {
if (Value.isInvalid()) {
appendArgument(Name, "(invalid)");
return;
}
const clang::FileEntry *FileEntry =
PP.getSourceManager().getFileEntryForID(Value);
if (!FileEntry) {
appendArgument(Name, "(getFileEntryForID failed)");
return;
}
appendFilePathArgument(Name, FileEntry->getName());
}
// Append a SourceRange argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name,
clang::SourceRange Value) {
if (DisableTrace)
return;
if (Value.isInvalid()) {
appendArgument(Name, "(invalid)");
return;
}
std::string Str;
llvm::raw_string_ostream SS(Str);
SS << "[" << getSourceLocationString(PP, Value.getBegin()) << ", "
<< getSourceLocationString(PP, Value.getEnd()) << "]";
appendArgument(Name, SS.str());
}
// Append a double-quoted argument to the top trace item.
void PPCallbacksTracker::appendQuotedArgument(const char *Name,
const std::string &Value) {
std::string Str;
llvm::raw_string_ostream SS(Str);
SS << "\"" << Value << "\"";
appendArgument(Name, SS.str());
}
// 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.
void PPCallbacksTracker::InclusionDirective(
clang::SourceLocation HashLoc, const clang::Token &IncludeTok,
llvm::StringRef FileName, bool IsAngled,
clang::CharSourceRange FilenameRange, const clang::FileEntry *File,
llvm::StringRef SearchPath, llvm::StringRef RelativePath,
const clang::Module *Imported) {
beginCallback("InclusionDirective");
appendArgument("IncludeTok", IncludeTok);
appendFilePathArgument("FileName", FileName);
appendArgument("IsAngled", IsAngled);
appendArgument("FilenameRange", FilenameRange);
appendArgument("File", File);
appendFilePathArgument("SearchPath", SearchPath);
appendFilePathArgument("RelativePath", RelativePath);
appendArgument("Imported", Imported);
}
// Append a FileEntry argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name,
const clang::FileEntry *Value) {
if (!Value) {
appendArgument(Name, "(null)");
return;
}
appendFilePathArgument(Name, Value->getName());
}
// Callback invoked when a #pragma warning directive is read.
void PPCallbacksTracker::PragmaWarning(clang::SourceLocation Loc,
llvm::StringRef WarningSpec,
llvm::ArrayRef<int> Ids) {
beginCallback("PragmaWarning");
appendArgument("Loc", Loc);
appendArgument("WarningSpec", WarningSpec);
std::string Str;
llvm::raw_string_ostream SS(Str);
SS << "[";
for (int i = 0, e = Ids.size(); i != e; ++i) {
if (i)
SS << ", ";
SS << Ids[i];
}
SS << "]";
appendArgument("Ids", SS.str());
}
void ArgList_TokenData::copyArguments(ArgList_TokenData *other)
{
foreach (Subprogram_TokenData *p, marguments)
delete p;
marguments.clear();
if (!other)
return;
foreach (Subprogram_TokenData *p, other->marguments)
appendArgument(p);
}
void ArgList_TokenData::deserialize(const QByteArray &data)
{
QVariantMap m = BeQt::deserialize(data).toMap();
foreach (Subprogram_TokenData *p, marguments)
delete p;
marguments.clear();
QVariantList list = m.value("arguments").toList();
foreach (const QVariant &v, list) {
Subprogram_TokenData sp(Token::Subprogram_Token);
sp.deserialize(v.toByteArray());
appendArgument(&sp);
}
// Append a MacroArgs argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name,
const clang::MacroArgs *Value) {
if (!Value) {
appendArgument(Name, "(null)");
return;
}
std::string Str;
llvm::raw_string_ostream SS(Str);
SS << "[";
// The argument tokens might include end tokens, so we reflect how
// how getUnexpArgument provides the arguments.
for (int I = 0, E = Value->getNumArguments(); I < E; ++I) {
const clang::Token *Current = Value->getUnexpArgument(I);
int TokenCount = Value->getArgLength(Current) + 1; // include EOF
E -= TokenCount;
if (I)
SS << ", ";
// We're assuming tokens are contiguous, as otherwise we have no
// other way to get at them.
--TokenCount;
for (int TokenIndex = 0; TokenIndex < TokenCount; ++TokenIndex, ++Current) {
if (TokenIndex)
SS << " ";
// We need to be careful here because the arguments might not be legal in
// YAML, so we use the token name for anything but identifiers and
// numeric literals.
if (Current->isAnyIdentifier() ||
Current->is(clang::tok::numeric_constant)) {
SS << PP.getSpelling(*Current);
} else {
SS << "<" << Current->getName() << ">";
}
}
}
SS << "]";
appendArgument(Name, SS.str());
}
// Append a MacroDefinition argument to the top trace item.
void PPCallbacksTracker::appendArgument(const char *Name,
const clang::MacroDefinition &Value) {
std::string Str;
llvm::raw_string_ostream SS(Str);
SS << "[";
bool Any = false;
if (Value.getLocalDirective()) {
SS << "(local)";
Any = true;
}
for (auto *MM : Value.getModuleMacros()) {
if (Any) SS << ", ";
SS << MM->getOwningModule()->getFullModuleName();
}
SS << "]";
appendArgument(Name, SS.str());
}
