292 lines
10 KiB
C++
292 lines
10 KiB
C++
//--------------------------------------------------------------------*- C++ -*-
|
|
// CLING - the C++ LLVM-based InterpreterG :)
|
|
// author: Manasij Mukherjee <manasij7479@gmail.com>
|
|
// author: Vassil Vassilev <vvasilev@cern.ch>
|
|
//
|
|
// This file is dual-licensed: you can choose to license it under the University
|
|
// of Illinois Open Source License or the GNU Lesser General Public License. See
|
|
// LICENSE.TXT for details.
|
|
//------------------------------------------------------------------------------
|
|
|
|
#ifndef CLING_AUTOLOADING_VISITOR_H
|
|
#define CLING_AUTOLOADING_VISITOR_H
|
|
|
|
#include "clang/AST/DeclVisitor.h"
|
|
#include "clang/AST/PrettyPrinter.h"
|
|
#include "clang/Basic/Specifiers.h"
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include <stack>
|
|
#include <set>
|
|
|
|
///\brief Generates forward declarations for a Decl or Transaction
|
|
/// by implementing a DeclVisitor
|
|
///
|
|
/// Important Points:
|
|
/// 1. Function arguments having an EnumConstant as a default value
|
|
/// are printed in the following way:
|
|
/// enum E {E_a, E_b};
|
|
/// void foo(E e = E_b){}
|
|
/// Generates:
|
|
/// enum E : unsigned int;
|
|
/// void foo(E e = E(1));
|
|
/// 1 is the integral value of E_b.
|
|
///
|
|
/// 2. Decls, in general, are skipped when they depend on things
|
|
/// that were previously skipped.
|
|
/// The set of strings, m_IncompatibleNames facilitate this.
|
|
/// Examine the shouldSkip functions to see why specific types
|
|
/// are skipped.
|
|
///
|
|
/// 3. Log file:
|
|
/// The name of the file depends on the name of the file where
|
|
/// the forward declarations are written.
|
|
/// So, fwd.h produces a corresponding fwd.h.skipped, when
|
|
/// output logging is enabled.
|
|
/// The log messages are written in the shouldSkip functions to
|
|
/// simplify the design.
|
|
///
|
|
///
|
|
|
|
namespace clang {
|
|
class ClassTemplateDecl;
|
|
class ClassTemplateSpecializationDecl;
|
|
class CXXRecordDecl;
|
|
class Decl;
|
|
class DeclContext;
|
|
class EmptyDecl;
|
|
class EnumDecl;
|
|
class EnumConstantDecl;
|
|
class FieldDecl;
|
|
class FileScopeAsmDecl;
|
|
class FriendDecl;
|
|
class FunctionDecl;
|
|
class FunctionTemplateDecl;
|
|
class ImportDecl;
|
|
class LabelDecl;
|
|
class LinkageSpecDecl;
|
|
class NamespaceDecl;
|
|
class NamespaceAliasDecl;
|
|
class ParmVarDecl;
|
|
class QualType;
|
|
class RecordDecl;
|
|
class Sema;
|
|
class StaticAssertDecl;
|
|
class TemplateArgumentList;
|
|
class TemplateDecl;
|
|
class TemplateParameterList;
|
|
class TranslationUnitDecl;
|
|
class TypeAliasDecl;
|
|
class TypedefDecl;
|
|
class VarDecl;
|
|
class UsingDirectiveDecl;
|
|
}
|
|
|
|
namespace llvm {
|
|
class raw_ostream;
|
|
}
|
|
|
|
namespace cling {
|
|
class Transaction;
|
|
|
|
class ForwardDeclPrinter : public clang::DeclVisitor<ForwardDeclPrinter> {
|
|
private:
|
|
clang::PrintingPolicy m_Policy; // intentional copy
|
|
llvm::raw_ostream& m_Log;
|
|
unsigned m_Indentation;
|
|
bool m_PrintInstantiation;
|
|
clang::SourceManager& m_SMgr;
|
|
clang::ASTContext& m_Ctx;
|
|
bool m_SkipFlag;
|
|
//False by default, true if current item is not to be printed
|
|
|
|
llvm::DenseMap<const clang::Decl*, bool> m_Visited; // fwd decl success
|
|
std::stack<llvm::raw_ostream*> m_StreamStack;
|
|
std::set<const char*> m_BuiltinNames;
|
|
|
|
public:
|
|
ForwardDeclPrinter(llvm::raw_ostream& OutS,
|
|
llvm::raw_ostream& LogS,
|
|
clang::Sema& S,
|
|
const Transaction& T,
|
|
unsigned Indentation = 0,
|
|
bool printMacros = false);
|
|
|
|
// void VisitDeclContext(clang::DeclContext *DC, bool shouldIndent = true);
|
|
|
|
void Visit(clang::Decl *D);
|
|
void VisitTranslationUnitDecl(clang::TranslationUnitDecl *D);
|
|
void VisitTypedefDecl(clang::TypedefDecl *D);
|
|
void VisitTypeAliasDecl(clang::TypeAliasDecl *D);
|
|
void VisitEnumDecl(clang::EnumDecl *D);
|
|
void VisitRecordDecl(clang::RecordDecl *D);
|
|
void VisitEmptyDecl(clang::EmptyDecl *D);
|
|
void VisitFunctionDecl(clang::FunctionDecl *D);
|
|
void VisitFriendDecl(clang::FriendDecl *D);
|
|
void VisitFieldDecl(clang::FieldDecl *D);
|
|
void VisitVarDecl(clang::VarDecl *D);
|
|
void VisitLabelDecl(clang::LabelDecl *D);
|
|
void VisitParmVarDecl(clang::ParmVarDecl *D);
|
|
void VisitFileScopeAsmDecl(clang::FileScopeAsmDecl *D);
|
|
void VisitImportDecl(clang::ImportDecl *D);
|
|
void VisitStaticAssertDecl(clang::StaticAssertDecl *D);
|
|
void VisitNamespaceDecl(clang::NamespaceDecl *D);
|
|
void VisitUsingDirectiveDecl(clang::UsingDirectiveDecl *D);
|
|
void VisitUsingDecl(clang::UsingDecl* D);
|
|
void VisitUsingShadowDecl(clang::UsingShadowDecl* D);
|
|
void VisitNamespaceAliasDecl(clang::NamespaceAliasDecl *D);
|
|
void VisitTagDecl(clang::TagDecl *D);
|
|
void VisitLinkageSpecDecl(clang::LinkageSpecDecl *D);
|
|
void VisitRedeclarableTemplateDecl(const clang::RedeclarableTemplateDecl *D);
|
|
void VisitFunctionTemplateDecl(clang::FunctionTemplateDecl *D);
|
|
void VisitClassTemplateDecl(clang::ClassTemplateDecl *D);
|
|
void VisitClassTemplateSpecializationDecl(clang::ClassTemplateSpecializationDecl* D);
|
|
void VisitTypeAliasTemplateDecl(clang::TypeAliasTemplateDecl* D);
|
|
|
|
// Not coming from the RecursiveASTVisitor
|
|
void Visit(clang::QualType QT);
|
|
void Visit(const clang::Type* T);
|
|
void VisitNestedNameSpecifier(const clang::NestedNameSpecifier* NNS);
|
|
void VisitTemplateArgument(const clang::TemplateArgument& TA);
|
|
void VisitTemplateName(const clang::TemplateName& TN);
|
|
|
|
void printDeclType(llvm::raw_ostream& Stream, clang::QualType T,
|
|
llvm::StringRef DeclName, bool Pack = false);
|
|
|
|
void PrintTemplateParameters(llvm::raw_ostream& Stream,
|
|
clang::TemplateParameterList *Params,
|
|
const clang::TemplateArgumentList *Args = 0);
|
|
void prettyPrintAttributes(clang::Decl *D, std::string extra = "");
|
|
|
|
bool isOperator(clang::FunctionDecl* D);
|
|
bool hasDefaultArgument(clang::FunctionDecl* D);
|
|
|
|
bool shouldSkip(clang::Decl* D) {
|
|
switch (D->getKind()) {
|
|
#define DECL(TYPE, BASE) \
|
|
case clang::Decl::TYPE: return shouldSkip((clang::TYPE##Decl*)D); break;
|
|
#define ABSTRACT_DECL(DECL)
|
|
#include "clang/AST/DeclNodes.inc"
|
|
#undef DECL
|
|
#undef ABSTRACT_DECL
|
|
}
|
|
return false;
|
|
}
|
|
|
|
std::string getNameIfPossible(clang::Decl* D) { return "<not named>"; }
|
|
std::string getNameIfPossible(clang::NamedDecl* D) {
|
|
return D->getNameAsString();
|
|
}
|
|
|
|
template <typename T> bool shouldSkip(T* D) {
|
|
// Anything inside DCs except those below cannot be fwd declared.
|
|
clang::Decl::Kind DCKind = D->getDeclContext()->getDeclKind();
|
|
if (DCKind != clang::Decl::Namespace
|
|
&& DCKind != clang::Decl::TranslationUnit
|
|
&& DCKind != clang::Decl::LinkageSpec) {
|
|
Log() << getNameIfPossible(D) <<" \n";
|
|
skipDecl(D, "Incompatible DeclContext");
|
|
} else {
|
|
if (clang::NamedDecl* ND = clang::dyn_cast<clang::NamedDecl>(D)) {
|
|
if (clang::IdentifierInfo* II = ND->getIdentifier()) {
|
|
if (m_BuiltinNames.find(II->getNameStart()) != m_BuiltinNames.end()
|
|
|| !strncmp(II->getNameStart(), "__builtin_", 10))
|
|
skipDecl(D, "builtin");
|
|
}
|
|
}
|
|
if (!m_SkipFlag)
|
|
if (shouldSkipImpl(D))
|
|
skipDecl(D, "shouldSkip");
|
|
}
|
|
if (m_SkipFlag) {
|
|
// Remember that we have tried to fwd declare this already.
|
|
m_Visited.insert(std::pair<const clang::Decl*, bool>(
|
|
getCanonicalOrNamespace(D), false));
|
|
}
|
|
return m_SkipFlag;
|
|
}
|
|
|
|
bool ContainsIncompatibleName(clang::TemplateParameterList* Params);
|
|
|
|
void skipDecl(clang::Decl* D, const char* Reason);
|
|
void resetSkip() { m_SkipFlag = false; }
|
|
|
|
void printStats();
|
|
private:
|
|
llvm::raw_ostream& Indent() { return Indent(m_Indentation); }
|
|
llvm::raw_ostream& Indent(unsigned Indentation);
|
|
|
|
// void ProcessDeclGroup(llvm::SmallVectorImpl<clang::Decl*>& Decls);
|
|
|
|
void Print(clang::AccessSpecifier AS);
|
|
|
|
llvm::raw_ostream& Out() { return *m_StreamStack.top(); }
|
|
llvm::raw_ostream& Log() { return m_Log; }
|
|
|
|
bool shouldSkipImpl(clang::Decl*){return false;}
|
|
|
|
bool shouldSkipImpl(clang::FunctionDecl* D);
|
|
bool shouldSkipImpl(clang::FunctionTemplateDecl* D);
|
|
bool shouldSkipImpl(clang::TagDecl* D);
|
|
bool shouldSkipImpl(clang::VarDecl* D);
|
|
bool shouldSkipImpl(clang::EnumDecl* D);
|
|
bool shouldSkipImpl(clang::ClassTemplateSpecializationDecl* D);
|
|
bool shouldSkipImpl(clang::UsingDirectiveDecl* D);
|
|
bool shouldSkipImpl(clang::TypeAliasTemplateDecl* D);
|
|
bool shouldSkipImpl(clang::EnumConstantDecl* D) { return false; };
|
|
bool haveSkippedBefore(const clang::Decl* D) const {
|
|
auto Found = m_Visited.find(getCanonicalOrNamespace(D));
|
|
return (Found != m_Visited.end() && !Found->second);
|
|
}
|
|
const clang::Decl* getCanonicalOrNamespace(const clang::Decl* D) const {
|
|
if (D->getKind() == clang::Decl::Namespace)
|
|
return D;
|
|
return D->getCanonicalDecl();
|
|
}
|
|
const clang::Decl* getCanonicalOrNamespace(const clang::NamespaceDecl* D) const {
|
|
return D;
|
|
}
|
|
std::string PrintEnclosingDeclContexts(llvm::raw_ostream& Stream,
|
|
const clang::DeclContext* DC);
|
|
void PrintNamespaceOpen(llvm::raw_ostream& Stream,
|
|
const clang::NamespaceDecl* ND);
|
|
void PrintLinkageOpen(llvm::raw_ostream& Stream,
|
|
const clang::LinkageSpecDecl* LSD);
|
|
|
|
class StreamRAII {
|
|
ForwardDeclPrinter& m_pr;
|
|
clang::PrintingPolicy m_oldPol;
|
|
std::string m_Output;
|
|
llvm::raw_string_ostream m_Stream;
|
|
bool m_HavePopped;
|
|
public:
|
|
StreamRAII(ForwardDeclPrinter& pr, clang::PrintingPolicy* pol = 0):
|
|
m_pr(pr), m_oldPol(pr.m_Policy), m_Stream(m_Output),
|
|
m_HavePopped(false) {
|
|
m_pr.m_StreamStack.push(&m_Stream);
|
|
if (pol)
|
|
m_pr.m_Policy = *pol;
|
|
}
|
|
~StreamRAII() {
|
|
if (!m_HavePopped) {
|
|
m_pr.m_StreamStack.pop();
|
|
m_Stream.flush();
|
|
if (!m_pr.m_SkipFlag) {
|
|
m_pr.Out() << m_Output;
|
|
}
|
|
}
|
|
m_pr.m_Policy = m_oldPol;
|
|
}
|
|
std::string take(bool pop = false) {
|
|
m_Stream.flush();
|
|
if (pop) {
|
|
assert(!m_HavePopped && "No popping twice");
|
|
m_HavePopped = true;
|
|
m_pr.m_StreamStack.pop();
|
|
}
|
|
return m_Output;
|
|
}
|
|
};
|
|
};
|
|
}
|
|
#endif
|