X-Git-Url: http://rtime.felk.cvut.cz/gitweb/boost-statechart-viewer.git/blobdiff_plain/4f7a21f132d2f4c67b5a2280567cd1bd898ad911..c0b5980b4f914f4ee974f37aa8936c1ad93667d3:/src/visualizer.cpp diff --git a/src/visualizer.cpp b/src/visualizer.cpp index 20105b6..f22ff3c 100644 --- a/src/visualizer.cpp +++ b/src/visualizer.cpp @@ -19,7 +19,9 @@ //////////////////////////////////////////////////////////////////////////////////////// //standard header files +#include #include +#include //LLVM Header files #include "llvm/Support/raw_ostream.h" @@ -27,6 +29,7 @@ //clang header files #include "clang/AST/ASTConsumer.h" +#include "clang/AST/ASTContext.h" #include "clang/AST/CXXInheritance.h" #include "clang/AST/RecursiveASTVisitor.h" #include "clang/Frontend/CompilerInstance.h" @@ -35,36 +38,192 @@ using namespace clang; using namespace std; -class Statechart +namespace Model { -public: + + inline int getIndentLevelIdx() { + static int i = ios_base::xalloc(); + return i; + } + + ostream& indent(ostream& os) { os << setw(2*os.iword(getIndentLevelIdx())) << ""; return os; } + ostream& indent_inc(ostream& os) { os.iword(getIndentLevelIdx())++; return os; } + ostream& indent_dec(ostream& os) { os.iword(getIndentLevelIdx())--; return os; } + + class State; + + class Context : public map { + public: + iterator add(State *state); + Context *findContext(const string &name); + }; + + class State : public Context + { + string initialInnerState; + list defferedEvents; + public: + const string name; + bool noTypedef; + explicit State(string name) : name(name), noTypedef(false) {} + void setInitialInnerState(string name) { initialInnerState = name; } + void addDeferredEvent(const string &name) { defferedEvents.push_back(name); } + void setNoTypedef() { noTypedef = true;} + friend ostream& operator<<(ostream& os, const State& s); + }; + + + Context::iterator Context::add(State *state) + { + pair ret = insert(value_type(state->name, state)); + return ret.first; + } + + Context *Context::findContext(const string &name) + { + iterator i = find(name), e; + if (i != end()) + return i->second; + for (i = begin(), e = end(); i != e; ++i) { + Context *c = i->second->findContext(name); + if (c) + return c; + } + return 0; + } + + ostream& operator<<(ostream& os, const Context& c); + + ostream& operator<<(ostream& os, const State& s) + { + string label = s.name; + for (list::const_iterator i = s.defferedEvents.begin(), e = s.defferedEvents.end(); i != e; ++i) + label.append("
").append(*i).append(" / defer"); + if(s.noTypedef) os << indent << s.name << " [label=<" << label << ">, color=\"red\"]\n"; + else os << indent << s.name << " [label=<" << label << ">]\n"; + if (s.size()) { + os << indent << s.name << " -> " << s.initialInnerState << " [style = dashed]\n"; + os << indent << "subgraph cluster_" << s.name << " {\n" << indent_inc; + os << indent << "label = \"" << s.name << "\"\n"; + os << indent << s.initialInnerState << " [peripheries=2]\n"; + os << static_cast(s); + os << indent_dec << indent << "}\n"; + } + return os; + } + + + ostream& operator<<(ostream& os, const Context& c) + { + for (Context::const_iterator i = c.begin(), e = c.end(); i != e; i++) { + os << *i->second; + } + return os; + } + + class Transition { public: - string src, dst, event; + const string src, dst, event; Transition(string src, string dst, string event) : src(src), dst(dst), event(event) {} }; - string name; - string name_of_start; - list transitions; - list cReactions; /** list of custom reactions. After all files are traversed this list should be empty. */ - list events; - list states; - void write_dot_file(string fn) + ostream& operator<<(ostream& os, const Transition& t) + { + os << indent << t.src << " -> " << t.dst << " [label = \"" << t.event << "\"]\n"; + return os; + } + + + class Machine : public Context { - ofstream f(fn.c_str()); - f << "digraph " << name << " {\n"; - for (string& s : states) { - f << " " << s << "\n"; + protected: + string initial_state; + public: + const string name; + explicit Machine(string name) : name(name) {} + + void setInitialState(string name) { initial_state = name; } + + friend ostream& operator<<(ostream& os, const Machine& m); + }; + + ostream& operator<<(ostream& os, const Machine& m) + { + os << indent << "subgraph " << m.name << " {\n" << indent_inc; + os << indent << m.initial_state << " [peripheries=2]\n"; + os << static_cast(m); + os << indent_dec << indent << "}\n"; + return os; + } + + + class Model : public map + { + Context undefined; // For forward-declared state classes + public: + list< Transition*> transitions; + + iterator add(const Machine &m) + { + pair ret = insert(value_type(m.name, m)); + return ret.first; } - for (Transition &t : transitions) { - f << t.src << " -> " << t.dst << " [label = \"" << t.event << "\"]\n"; + void addUndefinedState(State *m) + { + undefined[m->name] = m; } - f << "}"; - } + + Context *findContext(const string &name) + { + Context::iterator ci = undefined.find(name); + if (ci != undefined.end()) + return ci->second; + iterator i = find(name), e; + if (i != end()) + return &i->second; + for (i = begin(), e = end(); i != e; ++i) { + Context *c = i->second.findContext(name); + if (c) + return c; + } + return 0; + } + + State *findState(const string &name) + { + for (iterator i = begin(), e = end(); i != e; ++i) { + Context *c = i->second.findContext(name); + if (c) + return static_cast(c); + } + return 0; + } + + + State *removeFromUndefinedContexts(const string &name) + { + Context::iterator ci = undefined.find(name); + if (ci == undefined.end()) + return 0; + undefined.erase(ci); + return ci->second; + } + + void write_as_dot_file(string fn) + { + ofstream f(fn.c_str()); + f << "digraph statecharts {\n" << indent_inc; + for (iterator i = begin(), e = end(); i != e; i++) + f << i->second; + for (list::iterator t = transitions.begin(), e = transitions.end(); t != e; ++t) + f << **t; + f << indent_dec << "}\n"; + } + }; }; @@ -74,36 +233,106 @@ class MyCXXRecordDecl : public CXXRecordDecl CXXBasePath &Path, void *qualName) { - string qn(static_cast(qualName)); - const RecordType *rt = Specifier->getType()->getAs(); - assert(rt); - TagDecl *canon = rt->getDecl()->getCanonicalDecl(); - return canon->getQualifiedNameAsString() == qn; + string qn(static_cast(qualName)); + const RecordType *rt = Specifier->getType()->getAs(); + assert(rt); + TagDecl *canon = rt->getDecl()->getCanonicalDecl(); + return canon->getQualifiedNameAsString() == qn; } public: - bool isDerivedFrom(const char *baseStr) const { - CXXBasePaths Paths(/*FindAmbiguities=*/false, /*RecordPaths=*/false, /*DetectVirtual=*/false); + bool isDerivedFrom(const char *baseStr, CXXBaseSpecifier const **Base = 0) const { + CXXBasePaths Paths(/*FindAmbiguities=*/false, /*RecordPaths=*/!!Base, /*DetectVirtual=*/false); Paths.setOrigin(const_cast(this)); - return lookupInBases(&FindBaseClassString, const_cast(baseStr), Paths); + if (!lookupInBases(&FindBaseClassString, const_cast(baseStr), Paths)) + return false; + if (Base) + *Base = Paths.front().back().Base; + return true; } }; +class FindTransitVisitor : public RecursiveASTVisitor +{ + Model::Model &model; + const CXXRecordDecl *SrcState; + const Type *EventType; +public: + explicit FindTransitVisitor(Model::Model &model, const CXXRecordDecl *SrcState, const Type *EventType) + : model(model), SrcState(SrcState), EventType(EventType) {} + + bool VisitMemberExpr(MemberExpr *E) { + if (E->getMemberNameInfo().getAsString() != "transit") + return true; + if (E->hasExplicitTemplateArgs()) { + const Type *DstStateType = E->getExplicitTemplateArgs()[0].getArgument().getAsType().getTypePtr(); + CXXRecordDecl *DstState = DstStateType->getAsCXXRecordDecl(); + CXXRecordDecl *Event = EventType->getAsCXXRecordDecl(); + Model::Transition *T = new Model::Transition(SrcState->getName(), DstState->getName(), Event->getName()); + model.transitions.push_back(T); + } + return true; + } +}; class Visitor : public RecursiveASTVisitor { - ASTContext *Context; - Statechart ≻ + ASTContext *ASTCtx; + Model::Model &model; + DiagnosticsEngine &Diags; + unsigned diag_unhandled_reaction_type, diag_unhandled_reaction_decl, + diag_found_state, diag_found_statemachine, diag_no_history, diag_warning; + public: bool shouldVisitTemplateInstantiations() const { return true; } - explicit Visitor(ASTContext *Context, Statechart &sc) - : Context(Context), sc(sc) {} + explicit Visitor(ASTContext *Context, Model::Model &model, DiagnosticsEngine &Diags) + : ASTCtx(Context), model(model), Diags(Diags) + { + diag_found_statemachine = + Diags.getCustomDiagID(DiagnosticsEngine::Note, "Found statemachine '%0'"); + diag_found_state = + Diags.getCustomDiagID(DiagnosticsEngine::Note, "Found state '%0'"); + diag_unhandled_reaction_type = + Diags.getCustomDiagID(DiagnosticsEngine::Error, "Unhandled reaction type '%0'"); + diag_unhandled_reaction_decl = + Diags.getCustomDiagID(DiagnosticsEngine::Error, "Unhandled reaction decl '%0'"); + diag_unhandled_reaction_decl = + Diags.getCustomDiagID(DiagnosticsEngine::Error, "History is not yet supported"); + diag_warning = + Diags.getCustomDiagID(DiagnosticsEngine::Warning, "'%0' %1"); + } + + DiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID) { return Diags.Report(Loc, DiagID); } - void HandleReaction(const Type *T, CXXRecordDecl *SrcState) + void HandleCustomReaction(const CXXRecordDecl *SrcState, const Type *EventType) { + IdentifierInfo& II = ASTCtx->Idents.get("react"); + // TODO: Lookup for react even in base classes - probably by using Sema::LookupQualifiedName() + for (DeclContext::lookup_const_result ReactRes = SrcState->lookup(DeclarationName(&II)); + ReactRes.first != ReactRes.second; ++ReactRes.first) { + if (CXXMethodDecl *React = dyn_cast(*ReactRes.first)) { + if (React->getNumParams() >= 1) { + const ParmVarDecl *p = React->getParamDecl(0); + const Type *ParmType = p->getType().getTypePtr(); + if (ParmType->isLValueReferenceType()) + ParmType = dyn_cast(ParmType)->getPointeeType().getTypePtr(); + if (ParmType == EventType) + FindTransitVisitor(model, SrcState, EventType).TraverseStmt(React->getBody()); + } else + Diag(React->getLocStart(), diag_warning) + << React << "has not a parameter"; + } else + Diag((*ReactRes.first)->getSourceRange().getBegin(), diag_warning) + << (*ReactRes.first)->getDeclKindName() << "is not supported as react method"; + } + } + + void HandleReaction(const Type *T, const SourceLocation Loc, CXXRecordDecl *SrcState) + { + // TODO: Improve Loc tracking if (const ElaboratedType *ET = dyn_cast(T)) - HandleReaction(ET->getNamedType().getTypePtr(), SrcState); + HandleReaction(ET->getNamedType().getTypePtr(), Loc, SrcState); else if (const TemplateSpecializationType *TST = dyn_cast(T)) { string name = TST->getTemplateName().getAsTemplateDecl()->getQualifiedNameAsString(); if (name == "boost::statechart::transition") { @@ -112,58 +341,158 @@ public: CXXRecordDecl *Event = EventType->getAsCXXRecordDecl(); CXXRecordDecl *DstState = DstStateType->getAsCXXRecordDecl(); - sc.transitions.push_back(Statechart::Transition(SrcState->getName(), DstState->getName(), - Event->getName())); - //llvm::errs() << EventRec->getName() << << "\n"; + Model::Transition *T = new Model::Transition(SrcState->getName(), DstState->getName(), Event->getName()); + model.transitions.push_back(T); + } else if (name == "boost::statechart::custom_reaction") { + const Type *EventType = TST->getArg(0).getAsType().getTypePtr(); + HandleCustomReaction(SrcState, EventType); + } else if (name == "boost::statechart::deferral") { + const Type *EventType = TST->getArg(0).getAsType().getTypePtr(); + CXXRecordDecl *Event = EventType->getAsCXXRecordDecl(); + + Model::State *s = model.findState(SrcState->getName()); + assert(s); + s->addDeferredEvent(Event->getName()); } else if (name == "boost::mpl::list") { for (TemplateSpecializationType::iterator Arg = TST->begin(), End = TST->end(); Arg != End; ++Arg) - HandleReaction(Arg->getAsType().getTypePtr(), SrcState); - } - //->getDecl()->getQualifiedNameAsString(); - } else { - llvm::errs() << "Unhandled reaction Type: " << T->getTypeClassName() << "\n"; - assert(0); - } + HandleReaction(Arg->getAsType().getTypePtr(), Loc, SrcState); + } else + Diag(Loc, diag_unhandled_reaction_type) << name; + } else + Diag(Loc, diag_unhandled_reaction_type) << T->getTypeClassName(); } void HandleReaction(const NamedDecl *Decl, CXXRecordDecl *SrcState) { if (const TypedefDecl *r = dyn_cast(Decl)) - HandleReaction(r->getCanonicalDecl()->getUnderlyingType().getTypePtr(), SrcState); - else { - llvm::errs() << "Unhandled reaction Decl: " << Decl->getDeclKindName() << "\n"; - assert(0); + HandleReaction(r->getCanonicalDecl()->getUnderlyingType().getTypePtr(), + r->getLocStart(), SrcState); + else + Diag(Decl->getLocation(), diag_unhandled_reaction_decl) << Decl->getDeclKindName(); + } + + TemplateArgumentLoc getTemplateArgLoc(const TypeLoc &T, unsigned ArgNum) + { + if (const ElaboratedTypeLoc *ET = dyn_cast(&T)) + return getTemplateArgLoc(ET->getNamedTypeLoc(), ArgNum); + else if (const TemplateSpecializationTypeLoc *TST = dyn_cast(&T)) { + if (TST->getNumArgs() >= ArgNum+1) { + return TST->getArgLoc(ArgNum); + } else + if(ArgNum!=2) + Diag(TST->getBeginLoc(), diag_warning) << TST->getType()->getTypeClassName() << "has not enough arguments" << TST->getSourceRange(); + } else + Diag(T.getBeginLoc(), diag_warning) << T.getType()->getTypeClassName() << "type as template argument is not supported" << T.getSourceRange(); + return TemplateArgumentLoc(); + } + + TemplateArgumentLoc getTemplateArgLocOfBase(const CXXBaseSpecifier *Base, unsigned ArgNum) { + return getTemplateArgLoc(Base->getTypeSourceInfo()->getTypeLoc(), ArgNum); + } + + CXXRecordDecl *getTemplateArgDeclOfBase(const CXXBaseSpecifier *Base, unsigned ArgNum, TemplateArgumentLoc &Loc) { + Loc = getTemplateArgLocOfBase(Base, ArgNum); + switch (Loc.getArgument().getKind()) { + case TemplateArgument::Type: + return Loc.getTypeSourceInfo()->getType()->getAsCXXRecordDecl(); + case TemplateArgument::Null: + // Diag() was already called + break; + default: + Diag(Loc.getSourceRange().getBegin(), diag_warning) << Loc.getArgument().getKind() << "unsupported kind" << Loc.getSourceRange(); } + return 0; } + CXXRecordDecl *getTemplateArgDeclOfBase(const CXXBaseSpecifier *Base, unsigned ArgNum) { + TemplateArgumentLoc Loc; + return getTemplateArgDeclOfBase(Base, ArgNum, Loc); + } - bool VisitCXXRecordDecl(CXXRecordDecl *Declaration) + void handleSimpleState(CXXRecordDecl *RecordDecl, const CXXBaseSpecifier *Base) { - if (!Declaration->isCompleteDefinition()) - return true; - - MyCXXRecordDecl *StateDecl = static_cast(Declaration); + int typedef_num = 0; + string name(RecordDecl->getName()); //getQualifiedNameAsString()); + printf("stav %s\n", RecordDecl->getName()); + Diag(RecordDecl->getLocStart(), diag_found_state) << name; + + Model::State *state; + // Either we saw a reference to forward declared state + // before, or we create a new state. + if (!(state = model.removeFromUndefinedContexts(name))) + state = new Model::State(name); + + CXXRecordDecl *Context = getTemplateArgDeclOfBase(Base, 1); + if (Context) { + Model::Context *c = model.findContext(Context->getName()); + if (!c) { + Model::State *s = new Model::State(Context->getName()); + model.addUndefinedState(s); + c = s; + } + c->add(state); + } + //TODO support more innitial states + TemplateArgumentLoc Loc; + if (MyCXXRecordDecl *InnerInitialState = + static_cast(getTemplateArgDeclOfBase(Base, 2, Loc))) { + if (InnerInitialState->isDerivedFrom("boost::statechart::simple_state") || + InnerInitialState->isDerivedFrom("boost::statechart::state_machine")) { + state->setInitialInnerState(InnerInitialState->getName()); + } + else + Diag(Loc.getTypeSourceInfo()->getTypeLoc().getLocStart(), diag_warning) + << InnerInitialState->getName() << " as inner initial state is not supported" << Loc.getSourceRange(); + } - if (StateDecl->isDerivedFrom("boost::statechart::simple_state")) - { - string state(StateDecl->getName()); //getQualifiedNameAsString()); - llvm::errs() << "Found state " << state << "\n"; - sc.states.push_back(state); +// if (CXXRecordDecl *History = getTemplateArgDecl(Base->getType().getTypePtr(), 3)) +// Diag(History->getLocStart(), diag_no_history); - IdentifierInfo& II = Context->Idents.get("reactions"); - for (DeclContext::lookup_result Reactions = StateDecl->lookup(DeclarationName(&II)); - Reactions.first != Reactions.second; ++Reactions.first) - HandleReaction(*Reactions.first, StateDecl); + IdentifierInfo& II = ASTCtx->Idents.get("reactions"); + // TODO: Lookup for reactions even in base classes - probably by using Sema::LookupQualifiedName() + for (DeclContext::lookup_result Reactions = RecordDecl->lookup(DeclarationName(&II)); + Reactions.first != Reactions.second; ++Reactions.first) + { + HandleReaction(*Reactions.first, RecordDecl); + typedef_num++; } - else if (StateDecl->isDerivedFrom("boost::statechart::state_machine")) - { - sc.name = StateDecl->getQualifiedNameAsString(); - sc.name_of_start = "tmp"; //StateDecl->getStateMachineInitialStateAsString() - llvm::errs() << "Found state_machine " << sc.name << "\n"; + if(typedef_num == 0) { + Diag(RecordDecl->getLocStart(), diag_warning) + << " missing typedef for reactions in state : " << RecordDecl->getName(); + state->setNoTypedef(); } - else if (StateDecl->isDerivedFrom("boost::statechart::event")) + } + + void handleStateMachine(CXXRecordDecl *RecordDecl, const CXXBaseSpecifier *Base) + { + Model::Machine m(RecordDecl->getName()); + Diag(RecordDecl->getLocStart(), diag_found_statemachine) << m.name; + + if (MyCXXRecordDecl *InitialState = + static_cast(getTemplateArgDeclOfBase(Base, 1))) + m.setInitialState(InitialState->getName()); + model.add(m); + } + + bool VisitCXXRecordDecl(CXXRecordDecl *Declaration) + { + if (!Declaration->isCompleteDefinition()) + return true; + if (Declaration->getQualifiedNameAsString() == "boost::statechart::state" || + Declaration->getQualifiedNameAsString() == "TimedState" || + Declaration->getQualifiedNameAsString() == "TimedSimpleState") + return true; // This is an "abstract class" not a real state + + MyCXXRecordDecl *RecordDecl = static_cast(Declaration); + const CXXBaseSpecifier *Base; + + if (RecordDecl->isDerivedFrom("boost::statechart::simple_state", &Base)) + handleSimpleState(RecordDecl, Base); + else if (RecordDecl->isDerivedFrom("boost::statechart::state_machine", &Base)) + handleStateMachine(RecordDecl, Base); + else if (RecordDecl->isDerivedFrom("boost::statechart::event")) { - sc.events.push_back(StateDecl->getNameAsString()); + //sc.events.push_back(RecordDecl->getNameAsString()); } return true; } @@ -172,16 +501,17 @@ public: class VisualizeStatechartConsumer : public clang::ASTConsumer { - Statechart statechart; + Model::Model model; Visitor visitor; string destFileName; public: - explicit VisualizeStatechartConsumer(ASTContext *Context, std::string destFileName) - : visitor(Context, statechart), destFileName(destFileName) {} + explicit VisualizeStatechartConsumer(ASTContext *Context, std::string destFileName, + DiagnosticsEngine &D) + : visitor(Context, model, D), destFileName(destFileName) {} virtual void HandleTranslationUnit(clang::ASTContext &Context) { visitor.TraverseDecl(Context.getTranslationUnitDecl()); - statechart.write_dot_file(destFileName); + model.write_as_dot_file(destFileName); } }; @@ -192,7 +522,7 @@ protected: size_t dot = getCurrentFile().find_last_of('.'); std::string dest = getCurrentFile().substr(0, dot); dest.append(".dot"); - return new VisualizeStatechartConsumer(&CI.getASTContext(), dest); + return new VisualizeStatechartConsumer(&CI.getASTContext(), dest, CI.getDiagnostics()); } bool ParseArgs(const CompilerInstance &CI,