X-Git-Url: http://rtime.felk.cvut.cz/gitweb/boost-statechart-viewer.git/blobdiff_plain/aeb5fc8c4bda7cbd078a7ad335c2d8dbf774d0c5..72cf4322f409f8ef1095f2d6ecd428ca02c047c5:/src/visualizer.cpp diff --git a/src/visualizer.cpp b/src/visualizer.cpp index 97ceb2e..8a41710 100644 --- a/src/visualizer.cpp +++ b/src/visualizer.cpp @@ -1,488 +1,511 @@ -#include -#include -#include -#include +/** @file */ +//////////////////////////////////////////////////////////////////////////////////////// +// +// This file is part of Boost Statechart Viewer. +// +// Boost Statechart Viewer is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// Boost Statechart Viewer is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with Boost Statechart Viewer. If not, see . +// +//////////////////////////////////////////////////////////////////////////////////////// +//standard header files +#include +#include +#include +//LLVM Header files #include "llvm/Support/raw_ostream.h" -#include "llvm/System/Host.h" -#include "llvm/Config/config.h" +#include "llvm/Support/raw_os_ostream.h" -#include "clang/Frontend/DiagnosticOptions.h" -#include "clang/Frontend/TextDiagnosticPrinter.h" +//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" +#include "clang/Frontend/FrontendPluginRegistry.h" -#include "clang/Basic/LangOptions.h" +using namespace clang; +using namespace std; -#include "clang/Index/TranslationUnit.h" -#include "clang/Basic/SourceManager.h" -#include "clang/Lex/HeaderSearch.h" -#include "clang/Basic/FileManager.h" +namespace Model +{ -#include "clang/Frontend/HeaderSearchOptions.h" -#include "clang/Frontend/Utils.h" + inline int getIndentLevelIdx() { + static int i = ios_base::xalloc(); + return i; + } -#include "clang/Basic/TargetOptions.h" -#include "clang/Basic/TargetInfo.h" + 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; } -#include "clang/Lex/Preprocessor.h" -#include "clang/Frontend/PreprocessorOptions.h" -#include "clang/Frontend/FrontendOptions.h" + class State; -#include "clang/Frontend/CompilerInvocation.h" + class Context : public map { + public: + iterator add(State *state); + Context *findContext(const string &name); + }; -#include "clang/Basic/IdentifierTable.h" -#include "clang/Basic/Builtins.h" + class State : public Context + { + string initialInnerState; + list defferedEvents; + public: + const string name; + explicit State(string name) : name(name) {} + void setInitialInnerState(string name) { initialInnerState = name; } + void addDeferredEvent(const string &name) { defferedEvents.push_back(name); } + friend ostream& operator<<(ostream& os, const State& s); + }; -#include "clang/AST/ASTContext.h" -#include "clang/AST/ASTConsumer.h" -#include "clang/Sema/Sema.h" -#include "clang/AST/DeclBase.h" -#include "clang/AST/Type.h" -#include "clang/AST/Decl.h" -#include "clang/Sema/Lookup.h" -#include "clang/Sema/Ownership.h" -#include "clang/AST/DeclGroup.h" -#include "clang/Parse/Parser.h" + Context::iterator Context::add(State *state) + { + pair ret = insert(value_type(state->name, state)); + return ret.first; + } -#include "clang/Parse/ParseAST.h" -#include "clang/Basic/Version.h" + 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; + } -#include "clang/Driver/Driver.h" + ostream& operator<<(ostream& os, const Context& c); -#include "clang/Driver/Job.h" -#include "clang/Driver/Tool.h" -#include "clang/Driver/Compilation.h" + 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"); + 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; + } -#include "llvm/Support/CommandLine.h" -//my own header files -#include "stringoper.h" -#include "commandlineopt.h" + 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; + } -using namespace clang; -using namespace clang::driver; -class MyDiagnosticClient : public TextDiagnosticPrinter -{ - public: - MyDiagnosticClient(llvm::raw_ostream &os, const DiagnosticOptions &diags, bool OwnsOutputStream = false):TextDiagnosticPrinter(os, diags, OwnsOutputStream = false){} - virtual void HandleDiagnostic(Diagnostic::Level DiagLevel, const DiagnosticInfo &Info) + class Transition + { + public: + const string src, dst, event; + Transition(string src, string dst, string event) : src(src), dst(dst), event(event) {} + }; + + ostream& operator<<(ostream& os, const Transition& t) + { + os << indent << t.src << " -> " << t.dst << " [label = \"" << t.event << "\"]\n"; + return os; + } + + + class Machine : public Context + { + 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) { - TextDiagnosticPrinter::HandleDiagnostic(DiagLevel, Info); - if(DiagLevel == 3) exit(1); - + pair ret = insert(value_type(m.name, m)); + return ret.first; } -}; -class FindStates : public ASTConsumer -{ - std::list transitions; - std::list states; - std::string name_of_machine; - std::string name_of_start; - FullSourceLoc *fSloc; - public: - - virtual void Initialize(ASTContext &ctx)//run after the AST is constructed - { - SourceLocation loc; - name_of_start = ""; - name_of_machine = ""; - SourceManager &sman = ctx.getSourceManager(); - fSloc = new FullSourceLoc(loc, sman); + void addUndefinedState(State *m) + { + undefined[m->name] = m; } - virtual void HandleTopLevelDecl(DeclGroupRef DGR)// traverse all top level declarations + + Context *findContext(const string &name) { - const SourceManager &sman = fSloc->getManager(); - SourceLocation loc; - std::string line; - std::string super_class, output; - llvm::raw_string_ostream x(output); - for (DeclGroupRef::iterator i = DGR.begin(), e = DGR.end(); i != e; ++i) - { - const Decl *decl = *i; - loc = decl->getLocation(); - if(loc.isValid()) - { - const NamedDecl *namedDecl = dyn_cast(decl); - //std::cout<getDeclKindName()<<"\n"; - if (const TagDecl *tagDecl = dyn_cast(decl)) - { - if(tagDecl->isStruct() || tagDecl->isClass()) //is it a structure or class - { - const CXXRecordDecl *cRecDecl = dyn_cast(decl); - decl->print(x); - //decl->dump(); - line = cut_commentary(clean_spaces(get_line_of_code(x.str()))); - output = ""; - if(is_derived(line)) - { - if(name_of_machine == "") - { - find_name_of_machine(cRecDecl, line); - } - else - { - if(find_states(cRecDecl, line)) - { - const DeclContext *declCont = tagDecl->castToDeclContext(tagDecl); - std::cout << "New state: " << namedDecl->getNameAsString() << "\n"; - find_transitions(namedDecl->getNameAsString(), declCont); - } - } - } - } - } - if(const NamespaceDecl *namespaceDecl = dyn_cast(decl)) - { - DeclContext *declCont = namespaceDecl->castToDeclContext(namespaceDecl); - //declCont->dumpDeclContext(); - recursive_visit(declCont); - - } - } - } + 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; } - void recursive_visit(const DeclContext *declCont) //recursively visit all decls hidden inside namespaces + + State *findState(const string &name) { - const SourceManager &sman = fSloc->getManager(); - std::string line, output; - SourceLocation loc; - llvm::raw_string_ostream x(output); - for (DeclContext::decl_iterator i = declCont->decls_begin(), e = declCont->decls_end(); i != e; ++i) - { - const Decl *decl = *i; - const NamedDecl *namedDecl = dyn_cast(decl); - - //std::cout<<"a "<getDeclKindName()<<"\n"; - loc = decl->getLocation(); - if(loc.isValid()) - { - if (const TagDecl *tagDecl = dyn_cast(decl)) - { - if(tagDecl->isStruct() || tagDecl->isClass()) //is it a structure or class - { - const CXXRecordDecl *cRecDecl = dyn_cast(decl); - decl->print(x); - line = cut_commentary(clean_spaces(get_line_of_code(x.str()))); - output = ""; - if(is_derived(line)) - { - if(name_of_machine == "") - { - find_name_of_machine(cRecDecl, line); - } - else - { - if(find_states(cRecDecl, line)) - { - const DeclContext *declCont = tagDecl->castToDeclContext(tagDecl); - //states.push_back(namedDecl->getNameAsString()); - std::cout << "New state: " << namedDecl->getNameAsString() << "\n"; - find_transitions(namedDecl->getNameAsString(), declCont); - } - } - } - } - } - if(const NamespaceDecl *namespaceDecl = dyn_cast(decl)) - { - DeclContext *declCont = namespaceDecl->castToDeclContext(namespaceDecl); - //declCont->dumpDeclContext(); - recursive_visit(declCont); - } - } - } + for (iterator i = begin(), e = end(); i != e; ++i) { + Context *c = i->second.findContext(name); + if (c) + return static_cast(c); + } + return 0; } - bool find_states(const CXXRecordDecl *cRecDecl, std::string line) // test if the struct/class is the state (must be derived from simple_state) - { - std::string super_class = get_super_class(line), base; - if(cRecDecl->getNumBases()>1) - { - for(unsigned i = 0; igetNumBases();i++ ) - { - if(i!=cRecDecl->getNumBases()-1) base = get_first_base(super_class); - else base = super_class; - if(is_state(super_class)) - { - //std::cout<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"; + } + }; +}; + + +class MyCXXRecordDecl : public CXXRecordDecl +{ + static bool FindBaseClassString(const CXXBaseSpecifier *Specifier, + 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; + } + +public: + bool isDerivedFrom(const char *baseStr, CXXBaseSpecifier const **Base = 0) const { + CXXBasePaths Paths(/*FindAmbiguities=*/false, /*RecordPaths=*/!!Base, /*DetectVirtual=*/false); + Paths.setOrigin(const_cast(this)); + 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 *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, 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 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 find_name_of_machine(const CXXRecordDecl *cRecDecl, std::string line) // find name of the state machine and the start state - { - std::string super_class = get_super_class(line), base, params; - - int pos = 0; - if(cRecDecl->getNumBases()>1) - { - for(unsigned i = 0; igetNumBases();i++ ) - { - if(i!=cRecDecl->getNumBases()-1) base = get_first_base(super_class); - else base = super_class; - if(is_machine(base)) - { - params = get_params(base); - pos = params.find(","); - name_of_machine = params.substr(0,pos); - name_of_start = params.substr(pos); - std::cout<<"Name of the state machine: "<(T)) + 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") { + const Type *EventType = TST->getArg(0).getAsType().getTypePtr(); + const Type *DstStateType = TST->getArg(1).getAsType().getTypePtr(); + CXXRecordDecl *Event = EventType->getAsCXXRecordDecl(); + CXXRecordDecl *DstState = DstStateType->getAsCXXRecordDecl(); + + 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(), 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(), + r->getLocStart(), SrcState); + else + Diag(Decl->getLocation(), diag_unhandled_reaction_decl) << Decl->getDeclKindName(); + } + + CXXRecordDecl *getTemplateArgDecl(const Type *T, unsigned ArgNum, const SourceLocation Loc) + { + if (const ElaboratedType *ET = dyn_cast(T)) + return getTemplateArgDecl(ET->getNamedType().getTypePtr(), ArgNum, Loc); + else if (const TemplateSpecializationType *TST = dyn_cast(T)) { + if (TST->getNumArgs() >= ArgNum+1) + return TST->getArg(ArgNum).getAsType()->getAsCXXRecordDecl(); + } else + Diag(Loc, diag_warning) << T->getTypeClassName() << "type as template argument is not supported"; + return 0; + } + + CXXRecordDecl *getTemplateArgDeclOfBase(const CXXBaseSpecifier *Base, unsigned ArgNum) { + return getTemplateArgDecl(Base->getType().getTypePtr(), 1, + Base->getTypeSourceInfo()->getTypeLoc().getLocStart()); + } + + bool VisitCXXRecordDecl(CXXRecordDecl *Declaration) + { + if (!Declaration->isCompleteDefinition()) + return true; + if (Declaration->getQualifiedNameAsString() == "boost::statechart::state") + 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)) + { + string name(RecordDecl->getName()); //getQualifiedNameAsString()); + 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); + 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); + + if (MyCXXRecordDecl *InnerInitialState = + static_cast(getTemplateArgDeclOfBase(Base, 2))) { + if (InnerInitialState->isDerivedFrom("boost::statechart::simple_state") || + InnerInitialState->isDerivedFrom("boost::statechart::state_machine")) + state->setInitialInnerState(InnerInitialState->getName()); else - { - if(is_machine(super_class)) - { - //std::cout<getTypeSourceInfo()->getTypeLoc().getLocStart(), diag_warning) + << InnerInitialState->getQualifiedNameAsString() << " as inner initial state is not supported"; + } + +// if (CXXRecordDecl *History = getTemplateArgDecl(Base->getType().getTypePtr(), 3)) +// Diag(History->getLocStart(), diag_no_history); + + 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); } + else if (RecordDecl->isDerivedFrom("boost::statechart::state_machine", &Base)) + { + Model::Machine m(RecordDecl->getName()); + Diag(RecordDecl->getLocStart(), diag_found_statemachine) << m.name; - void find_transitions (const std::string name_of_state,const DeclContext *declCont) // traverse all methods for finding declarations of transitions - { - std::string output, line, dest, params, base; - llvm::raw_string_ostream x(output); - int num; - for (DeclContext::decl_iterator i = declCont->decls_begin(), e = declCont->decls_end(); i != e; ++i) - { - const Decl *decl = *i; - if (const TypedefDecl *typedDecl = dyn_cast(decl)) - { - decl->print(x); - output = x.str(); - line = clean_spaces(cut_typedef(output)); - num = count(output,'<'); - if(num>1) - { - num-=1; - if(is_list(line)) - { - line = get_inner_part(line); - } - } - for(int j = 0;j(getTemplateArgDeclOfBase(Base, 1))) + m.setInitialState(InitialState->getName()); + model.add(m); } - - void save_to_file(std::string output) + else if (RecordDecl->isDerivedFrom("boost::statechart::event")) { - std::string state, str, context, ctx; - int pos1, pos2, cnt, subs; - std::ofstream filestr(output.c_str()); - std::cout<::iterator i = states.begin();i!=states.end();i++) // write all states in the context of the automaton - { - state = *i; - cnt = count(state,','); - if(cnt==1) - { - pos1 = state.find(","); - ctx = cut_namespaces(state.substr(pos1+1)); - //std::cout<::iterator i = states.begin();i!=states.end();i++) - { - state = *i; - cnt = count(state,','); - //std::cout<::iterator i = transitions.begin();i!=transitions.end();i++) // write all transitions - { - state = *i; - pos1 = state.find(","); - filestr<"; - pos2 = state.rfind(","); - filestr<getNameAsString()); } + return true; + } }; -int main(int argc, char **argv) + +class VisualizeStatechartConsumer : public clang::ASTConsumer { - llvm::cl::ParseCommandLineOptions(argc, argv); - //std::cout<<"Input file: "< Args(argv, argv + argc); - Args.push_back("-xc++"); - llvm::OwningPtr C(TheDriver.BuildCompilation(Args.size(), - Args.data())); - const driver::JobList &Jobs = C->getJobs(); - const driver::Command *Cmd = cast(*Jobs.begin()); - const driver::ArgStringList &CCArgs = Cmd->getArguments(); - - CompilerInvocation::CreateFromArgs(compInv, - const_cast(CCArgs.data()), - const_cast(CCArgs.data())+CCArgs.size(), - diag); - - HeaderSearchOptions hsopts; - - hsopts.ResourceDir = LLVM_PREFIX "/lib/clang/" CLANG_VERSION_STRING; - TargetOptions to = compInv.getTargetOpts(); - TargetInfo *ti = TargetInfo::CreateTargetInfo(diag, to); - LangOptions lang = compInv.getLangOpts(); - /*lang.BCPLComment=1; - lang.CPlusPlus=1; - lang.Digraphs=1; - lang.GNUMode=1; - lang.ObjC1=lang.ObjC2 = 1; - lang.GNUInline = 1; - lang.Bool=1; - lang.GNUKeywords = lang.GNUMode; - lang.CXXOperatorNames = lang.CPlusPlus; - lang.DollarIdents = 1;*/ - - - clang::ApplyHeaderSearchOptions(*headers, hsopts, lang, ti->getTriple()); - Preprocessor pp(diag, lang, *ti, sm, *headers); - Builtin::Context builtins(*ti); - pp.getBuiltinInfo().InitializeBuiltins(pp.getIdentifierTable(),pp.getLangOptions().NoBuiltin); - FrontendOptions f; - PreprocessorOptions ppio; - InitializePreprocessor(pp, ppio,hsopts,f); - const FileEntry *file = fm.getFile(inputFilename); - sm.createMainFileID(file); - IdentifierTable tab(lang); - SelectorTable sel; - FindStates c; - ASTContext ctx(lang, sm, *ti, tab, sel, builtins,0); - mdc->BeginSourceFile(lang, &pp); - ParseAST(pp, &c, ctx, false, false); - mdc->EndSourceFile(); - c.save_to_file(outputFile); - return 0; + Model::Model model; + Visitor visitor; + string destFileName; +public: + 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()); + model.write_as_dot_file(destFileName); + } +}; + +class VisualizeStatechartAction : public PluginASTAction +{ +protected: + ASTConsumer *CreateASTConsumer(CompilerInstance &CI, llvm::StringRef) { + size_t dot = getCurrentFile().find_last_of('.'); + std::string dest = getCurrentFile().substr(0, dot); + dest.append(".dot"); + return new VisualizeStatechartConsumer(&CI.getASTContext(), dest, CI.getDiagnostics()); + } + + bool ParseArgs(const CompilerInstance &CI, + const std::vector& args) { + for (unsigned i = 0, e = args.size(); i != e; ++i) { + llvm::errs() << "Visualizer arg = " << args[i] << "\n"; + + // Example error handling. + if (args[i] == "-an-error") { + DiagnosticsEngine &D = CI.getDiagnostics(); + unsigned DiagID = D.getCustomDiagID( + DiagnosticsEngine::Error, "invalid argument '" + args[i] + "'"); + D.Report(DiagID); + return false; + } + } + if (args.size() && args[0] == "help") + PrintHelp(llvm::errs()); + + return true; + } + void PrintHelp(llvm::raw_ostream& ros) { + ros << "Help for Visualize Statechart plugin goes here\n"; + } + +}; + +static FrontendPluginRegistry::Add X("visualize-statechart", "visualize statechart"); -} +// Local Variables: +// c-basic-offset: 4 +// End: