X-Git-Url: http://rtime.felk.cvut.cz/gitweb/boost-statechart-viewer.git/blobdiff_plain/147b691963a696716839a86144225d4ec89e43be..3602fe3023edf36a17aab8bbdf9e773f0eab7097:/src/visualizer.cpp

diff --git a/src/visualizer.cpp b/src/visualizer.cpp
index a32f03c..721ef1a 100644
--- a/src/visualizer.cpp
+++ b/src/visualizer.cpp
@@ -1,97 +1,172 @@
-#include <iostream>
-#include <string>
-#include <fstream>
-#include <list>
+/** @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 <http://www.gnu.org/licenses/>.
+//
+////////////////////////////////////////////////////////////////////////////////////////
 
+//standard header files
+#include <iostream>
 
+//LLVM Header files
 #include "llvm/Support/raw_ostream.h"
-#include "llvm/System/Host.h"
+#include "llvm/Support/Host.h"
 #include "llvm/Config/config.h"
 
-#include "clang/Frontend/DiagnosticOptions.h"
+//clang header files
 #include "clang/Frontend/TextDiagnosticPrinter.h"
-
-#include "clang/Basic/LangOptions.h"
-
-#include "clang/Index/TranslationUnit.h"
-#include "clang/Basic/SourceManager.h"
 #include "clang/Lex/HeaderSearch.h"
 #include "clang/Basic/FileManager.h"
-
-#include "clang/Frontend/HeaderSearchOptions.h"
 #include "clang/Frontend/Utils.h"
-
-#include "clang/Basic/TargetOptions.h"
 #include "clang/Basic/TargetInfo.h"
-
 #include "clang/Lex/Preprocessor.h"
-#include "clang/Frontend/PreprocessorOptions.h"
-#include "clang/Frontend/FrontendOptions.h"
-
-#include "clang/Frontend/CompilerInvocation.h"
-
-#include "clang/Basic/IdentifierTable.h"
-#include "clang/Basic/Builtins.h"
-
-#include "clang/AST/ASTContext.h"
+#include "clang/Frontend/CompilerInstance.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"
-
 #include "clang/Parse/ParseAST.h"
 #include "clang/Basic/Version.h"
-
-#include "llvm/Support/CommandLine.h"
+#include "clang/Driver/Driver.h"
+#include "clang/Driver/Compilation.h"
 
 //my own header files
-#include "stringoper.h"
-#include "commandlineopt.h"
+#include "iooper.h"
 
 using namespace clang;
+using namespace clang::driver;
+using namespace std;
 
-
+/**
+ * This class provides Simple diagnostic Client. It uses implementation in library for printing diagnostci information.
+ * Also it counts number of warnings, errors, ... When an error occurs the program is stopped.
+ */
 class MyDiagnosticClient : public TextDiagnosticPrinter
 {
+	int nwarnings; /** Save number of Warnings occured during diagnostic */
+	int nnotes;
+	int nignored;
+	int nerrors;
 	public:
-	MyDiagnosticClient(llvm::raw_ostream &os, const DiagnosticOptions &diags, bool OwnsOutputStream = false):TextDiagnosticPrinter(os, diags, OwnsOutputStream = false){}
+   /**
+    * Initialize number of warnings, errors, ...
+    */
+   MyDiagnosticClient(llvm::raw_ostream &os, const DiagnosticOptions &diags, bool OwnsOutputStream = false):TextDiagnosticPrinter(os, diags, OwnsOutputStream = false)
+	{
+		nwarnings=0;
+		nnotes=0;
+		nignored=0;
+		nerrors = 0;
+	}
+   /**
+     * This method prints diagnostic and counts diagnostic types.
+     */
 	virtual void HandleDiagnostic(Diagnostic::Level DiagLevel, const DiagnosticInfo &Info)
 	{
-		TextDiagnosticPrinter::HandleDiagnostic(DiagLevel, Info);
-		if(DiagLevel == 3) exit(1);
+		TextDiagnosticPrinter::HandleDiagnostic(DiagLevel, Info); // print diagnostic information using library implementation
+		switch (DiagLevel) // count number of all diagnostic information
+		{
+			case 0 : nignored+=1; break;
+			case 1 : nnotes+=1; break;
+			case 2 : nwarnings+=1; break;
+			default : nerrors+=1; 
+						 print_stats(); 
+						 exit(1);
+		}
+	}
+   /**
+     * Print statistics about diagnostic.
+     */
+	void print_stats()
+	{
+		cout<<"\n--Diagnostic Info--\n";
+		cout<<"Number of ignored: "<<nignored<<"\n";
+		cout<<"Number of notes: "<<nnotes<<"\n";
+		cout<<"Number of warnings: "<<nwarnings<<"\n";
+		cout<<"Number of errors and fatal errors: "<<nerrors<<"\n";
+	}
+	
+	int getNbrOfWarnings() /** Return number of warnings */
+	{
+		return nwarnings;		
+	}
+	
+	int getNbrOfNotes() /** Return number of notes */
+	{
+		return nnotes;		
+	}
+
+	int getNbrOfIgnored() /** Return number of ignored */
+	{
+		return nignored;		
 	}
 };
 
+/**
+ * My ASTConsumer provides interface for traversing AST. It uses recursive traversing in namespaces.
+ */
 class FindStates : public ASTConsumer
 {
-	std::list<string> transitions;
-	std::list<string> states;
-	std::string name_of_machine;
-	std::string name_of_start;
-	FullSourceLoc *fSloc;
+	list<string> transitions; 
+	list<string> cReactions; /** list of custom reactions. After all files are traversed this list should be empty. */
+	list<string> events;
+	list<string> states;
+	string name_of_machine;
+	string name_of_start;
+	FullSourceLoc *fsloc; /** Full Source Location instance for holding Source Manager. */
 	public:
 
-	virtual void Initialize(ASTContext &ctx)//run after the AST is constructed
+	list<string> getStates() /** Return list of states. */
+	{
+		return states;
+	}
+	
+	list<string> getTransitions() /** Return list of transitions. */
+	{
+		return transitions;
+	}
+		
+	list<string> getEvents() /** Return list of events. */
+	{
+		return events;
+	}
+
+	string getStateMachine() /** Return name of the state machine. */
+	{
+		return name_of_machine;
+	}
+
+	string getNameOfFirstState() /** Return name of start state. */
+	{
+		return name_of_start;
+	}
+	
+	virtual void Initialize(ASTContext &ctx)/** Run after the AST is constructed before the consumer starts to work. So this function works like constructor. */
 	{	
-		SourceLocation loc;
+		fsloc = new FullSourceLoc(* new SourceLocation(), ctx.getSourceManager());
 		name_of_start = "";
 		name_of_machine = "";
-		SourceManager &sman = ctx.getSourceManager();
-		fSloc = new FullSourceLoc(loc, sman);
 	}
 
-	virtual void HandleTopLevelDecl(DeclGroupRef DGR)// traverse all top level declarations
+/**
+*   Traverse global decls using DeclGroupRef for handling all global decls. But only interesting decls are processed. Interesting decls are Struct, Class, C++ methods and Namespace.
+*   When Namespace is found it recursively traverse all decls inside this Namespace using method recursive_visit.
+*/
+	virtual void HandleTopLevelDecl(DeclGroupRef DGR)
 	{
-		const SourceManager &sman = fSloc->getManager();
 		SourceLocation loc;
-		std::string line;
-		std::string super_class, output;
+		string line, output, event;
 		llvm::raw_string_ostream x(output);
 		for (DeclGroupRef::iterator i = DGR.begin(), e = DGR.end(); i != e; ++i) 
 		{
@@ -99,371 +174,323 @@ class FindStates : public ASTConsumer
 			loc = decl->getLocation();
 			if(loc.isValid())
 			{
-				const NamedDecl *namedDecl = dyn_cast<NamedDecl>(decl);
-				//std::cout<<decl->getDeclKindName()<<"\n";
+				if(decl->getKind()==35)
+				{					
+					method_decl(decl);
+				}
 				if (const TagDecl *tagDecl = dyn_cast<TagDecl>(decl))
 				{
-					if(tagDecl->isStruct() || tagDecl->isClass()) //is it a structure or class	
+					if(tagDecl->isStruct() || tagDecl->isClass()) //is it a struct or class	
 					{
-						const CXXRecordDecl *cRecDecl = dyn_cast<CXXRecordDecl>(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);
-								}
-							}
-						}
+						struct_class(decl);
 					}
 				}	
 				if(const NamespaceDecl *namespaceDecl = dyn_cast<NamespaceDecl>(decl))
 				{
+					
 					DeclContext *declCont = namespaceDecl->castToDeclContext(namespaceDecl);
-					//declCont->dumpDeclContext();				
 					recursive_visit(declCont);
 				
 				}
 			}
+			output = "";
 		}
 	}
-	void recursive_visit(const DeclContext *declCont) //recursively visit all decls hidden inside namespaces
+
+/**
+*   It is used to recursive traverse decls in Namespaces. This method do the same as HandleTopLevelDecl.
+*/
+	void recursive_visit(const DeclContext *declCont)
 	{
-		const SourceManager &sman = fSloc->getManager();
-		std::string line, output;
-		SourceLocation loc;
+		string line, output, event;
 		llvm::raw_string_ostream x(output);
+		SourceLocation loc;
 		for (DeclContext::decl_iterator i = declCont->decls_begin(), e = declCont->decls_end(); i != e; ++i)
 		{
 			const Decl *decl = *i;
-			const NamedDecl *namedDecl = dyn_cast<NamedDecl>(decl);
-			
-			//std::cout<<"a "<<decl->getDeclKindName()<<"\n";
 			loc = decl->getLocation();
 			if(loc.isValid())
-			{			
-				if (const TagDecl *tagDecl = dyn_cast<TagDecl>(decl))
+			{	
+				if(decl->getKind()==35)
+				{
+					method_decl(decl);
+				}
+				else if (const TagDecl *tagDecl = dyn_cast<TagDecl>(decl))
 				{
 					if(tagDecl->isStruct() || tagDecl->isClass()) //is it a structure or class	
 					{
-						const CXXRecordDecl *cRecDecl = dyn_cast<CXXRecordDecl>(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);
-								}
-							}
-						}
+						struct_class(decl);
 					}	
 				}
-				if(const NamespaceDecl *namespaceDecl = dyn_cast<NamespaceDecl>(decl))
+				else if(const NamespaceDecl *namespaceDecl = dyn_cast<NamespaceDecl>(decl))
 				{
-					DeclContext *declCont = namespaceDecl->castToDeclContext(namespaceDecl);
-					//declCont->dumpDeclContext();				
+					DeclContext *declCont = namespaceDecl->castToDeclContext(namespaceDecl);			
 					recursive_visit(declCont);
 				}
 			}
+			output = "";
 		} 
 	}
-	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)
+		
+/**
+*	This function works with class or struct. It splits the decl into 3 interesting parts.
+*	The state machine decl, state decl and event decl.
+*/
+	void struct_class(const Decl *decl)
+	{
+		string output, line, ret, trans, event;	
+		llvm::raw_string_ostream x(output);
+		decl->print(x);
+		line = get_line_of_code(x.str());
+		output = "";
+		int pos;
+		const NamedDecl *namedDecl = dyn_cast<NamedDecl>(decl);
+		if(is_derived(line))
 		{
-			for(unsigned i = 0; i<cRecDecl->getNumBases();i++ )
-			{
-				if(i!=cRecDecl->getNumBases()-1) base = get_first_base(super_class);
-				else base = super_class;
-				if(is_state(super_class)) 
-				{
-					//std::cout<<get_params(super_class);
-					states.push_back(get_params(super_class));
-					return true;
-				}
-				else
-				{
-					super_class = get_next_base(super_class);
-				}
-			}
-			return false;
-		}
-		else
-		{ 
-			if(is_state(super_class)) 
+			const CXXRecordDecl *cRecDecl = dyn_cast<CXXRecordDecl>(decl);
+					
+			if(find_events(cRecDecl, line))
 			{
-				//std::cout<<get_params(super_class);
-				states.push_back(get_params(super_class));
-				return true;
+				events.push_back(namedDecl->getNameAsString());
 			}
-			else return false;
-		}
-	}
-		
-	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; i<cRecDecl->getNumBases();i++ )
+			else if(name_of_machine == "")
 			{
-				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: "<<name_of_machine<<"\n";
-					std::cout<<"Name of the first state: "<<name_of_start<<"\n";
-				}
-				else
+				ret = find_name_of_machine(cRecDecl, line);
+				if(!ret.empty())
 				{
-					super_class = get_next_base(super_class);
+					pos = ret.find(",");
+					name_of_machine = ret.substr(0,pos);
+					name_of_start = ret.substr(pos+1);
 				}
 			}
-		}
-		else
-		{ 
-			if(is_machine(super_class))
+			else
 			{
-				//std::cout<<super_class;
-				params = get_params(super_class);
-				//std::cout<<params;
-				pos = params.find(",");
-				name_of_machine = cut_namespaces(params.substr(0,pos));
-				name_of_start = cut_namespaces(params.substr(pos+1));
-				std::cout<<"Name of the state machine:"<<name_of_machine<<"\n";
-				std::cout<<"Name of the first state:"<<name_of_start<<"\n";
+				ret = find_states(cRecDecl, line); 
+				if(!ret.empty())
+				{
+					states.push_back(ret);			
+					methods_in_class(decl,namedDecl->getNameAsString());
+				}
 			}
 		}
 	}
 
-	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;	
+/**
+*	This function provides traversing all methods and other context indide class. If
+*	typedef or classic method decl is found. If typedef is found then it is being testted for transitions and custom reactions.
+*/
+	void methods_in_class(const Decl *decl, const string state)
+	{
+		string output, line, ret, trans, event;	
 		llvm::raw_string_ostream x(output);
-		int num;		
+		int pos, num;
+		const TagDecl *tagDecl = dyn_cast<TagDecl>(decl);
+		const DeclContext *declCont = tagDecl->castToDeclContext(tagDecl);			
+		output="";
 		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<TypedefDecl>(decl)) 
+			if (i->getKind()==26) // typedefs
 			{
-					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<num;j++)
+				i->print(x);
+				output = x.str();
+				line = clean_spaces(cut_type(output));		
+				ret = find_transitions(state,line);
+				if(!ret.empty()) 
+				{
+					num = count(ret,';')+1;
+					for(int i = 0;i<num;i++)
 					{
-						if(j!=num-1) base = get_first_base(line);			
-						else base = line;
-						if(is_transition(base))
+						pos = ret.find(";");
+						if(pos == 0)
 						{
-							dest = name_of_state;
-							params = get_params(base);
-							dest.append(",");							
-							dest.append(params);
-							transitions.push_back(dest);
-							line = get_next_base(line);
+							ret = ret.substr(1);
+							pos = ret.find(";");
+							if(pos==-1) cReactions.push_back(ret);
+							else cReactions.push_back(ret.substr(0,pos));	
+							num-=1;
 						}
-						else
+						else 
 						{
-							line = get_next_base(line);
+							if(pos==-1) transitions.push_back(ret);
+							else transitions.push_back(ret.substr(0,pos));
 						}
+						if(i!=num-1) ret = ret.substr(pos+1);
 					}
-					output = "";
+					output="";
+				}
 			}
-		}	
+			if(i->getKind()==35) method_decl(decl);// C++ method
+		}
 	}
-	
-	void save_to_file(std::string output)
+
+ /**
+   * Traverse method declaration using classes with main class Stmt.
+   */
+	void method_decl(const Decl *decl)
 	{
-		std::string state, str, context, ctx;
-		int pos1, pos2, cnt, subs;
-		std::ofstream filestr(output.c_str());
-		std::cout<<output<<"\n";
-		filestr<<"digraph "<< name_of_machine<< " {\n";
-		context = name_of_machine;
-		for(list<string>::iterator i = states.begin();i!=states.end();i++) // write all states in the context of the automaton
+		string output, line, event;	
+		llvm::raw_string_ostream x(output);
+		if(decl->hasBody())
 		{
-			state = *i;
-			cnt = count(state,',');
-			if(cnt==1)
+			decl->print(x);
+			line = get_return(x.str());
+			if(test_model(line,"result"))
 			{
-				pos1 = state.find(",");
-				ctx = cut_namespaces(state.substr(pos1+1));
-				//std::cout<<name_of_machine.length();				
-				if(ctx.compare(0,context.length(),context)==0)
+				const FunctionDecl *fDecl = dyn_cast<FunctionDecl>(decl);
+				const ParmVarDecl *pvd = fDecl->getParamDecl(0);
+                                QualType qt = pvd->getOriginalType();
+				event = qt.getAsString();
+				if(event[event.length()-1]=='&') event = event.substr(0,event.length()-2);
+				event = event.substr(event.rfind(" ")+1);
+				line = dyn_cast<NamedDecl>(decl)->getQualifiedNameAsString();
+				line = cut_namespaces(line.substr(0,line.rfind("::")));
+				line.append(",");
+				line.append(event);
+				find_return_stmt(decl->getBody(),line); 
+				for(list<string>::iterator i = cReactions.begin();i!=cReactions.end();i++) // erase info about it from list of custom reactions
 				{
-					filestr<<cut_namespaces(state.substr(0,pos1))<<";\n";
-					states.erase(i);
-					i--;
-				}
-			}
-			if(cnt==2)
-			{
-				pos1 = state.find(",");
-				pos2 = state.rfind(",");
-				ctx = cut_namespaces(state.substr(pos1+1,pos2-pos1-1));
-				//std::cout<<ctx<<" "<<context<<"\n";
-				if(ctx.compare(0,context.length(),context)==0)
-				{				
-					filestr<<cut_namespaces(state.substr(0,pos1))<<";\n";
+					event = *i;
+					if(line.compare(event)==0) 
+					{
+						cReactions.erase(i);
+						break;
+					}
 				}
 			}
 		}
-		filestr<<name_of_start<<" [peripheries=2] ;\n";
-		subs = 0;
-		while(!states.empty()) // substates ?
+	}
+
+	void find_return_stmt(Stmt *statemt,string event) /** Traverse all statements in function for finding all return Statements.*/
+	{
+		if(statemt->getStmtClass() == 99) test_stmt(dyn_cast<CaseStmt>(statemt)->getSubStmt(), event);
+		else
 		{
-			state = states.front();
-			filestr<<"subgraph cluster"<<subs<<" {\n";			
-			pos1 = state.find(",");
-			pos2 = state.rfind(",");
-			context = cut_namespaces(state.substr(0,pos1));
-			filestr<<"label=\""<<context<<"\";\n";
-			filestr<<cut_namespaces(state.substr(pos2+1))<<" [peripheries=2] ;\n";	
-			states.pop_front();	
-			//std::cout<<states.size();	
-			for(list<string>::iterator i = states.begin();i!=states.end();i++)
+			for (Stmt::child_range range = statemt->children(); range; ++range)    
 			{
-				state = *i;
-				cnt = count(state,',');
-				//std::cout<<state<<" \n";
-				if(cnt==1)
-				{
-					pos1 = state.find(",");
-					ctx = cut_namespaces(state.substr(pos1+1));
-					
-					//std::cout<<ctx<<" "<<context<<"\n";
-					if(ctx.compare(0,context.length(),context)==0)
-					{
-						filestr<<cut_namespaces(state.substr(0,pos1))<<";\n";
-						states.erase(i);
-						i--;
-					}
-				}
-				if(cnt==2)
-				{
-					pos1 = state.find(",");
-					pos2 = state.rfind(",");
-					ctx = cut_namespaces(state.substr(pos1+1,pos2-pos1-1));
-					if(ctx.compare(0,context.length(),context)==0)
-					{				
-						filestr<<cut_namespaces(state.substr(0,pos1))<<";\n";
-						//std::cout<<ctx<<"\n";
-					}
-				}
+				test_stmt(*range, event);
 			}
-			filestr<<"}\n";
-			subs+=1;	
-		}		
-		for(list<string>::iterator i = transitions.begin();i!=transitions.end();i++) // write all transitions
-		{
-			state = *i;
-			pos1 = state.find(",");
-			filestr<<cut_namespaces(state.substr(0,pos1))<<"->";
-			pos2 = state.rfind(",");
-			filestr<<cut_namespaces(state.substr(pos2+1));
-			filestr<<"[label=\""<<cut_namespaces(state.substr(pos1+1,pos2-pos1-1))<<"\"];\n";
-		}		
-		filestr<<"}";
-		filestr.close();
+		}
+	}
+	
+	void test_stmt(Stmt *stmt, string event) /** test statement for its kind Using number as identifier for all Statement Classes.*/
+	{
+		const SourceManager &sman = fsloc->getManager();
+		int type;
+		string line, param;
+		type = stmt->getStmtClass();
+		switch(type)
+		{	
+			case 8 :		find_return_stmt(dyn_cast<DoStmt>(stmt)->getBody(), event); // do
+							break;
+			case 86 :	find_return_stmt(dyn_cast<ForStmt>(stmt)->getBody(), event); // for
+							break;
+			case 88 :   find_return_stmt(dyn_cast<IfStmt>(stmt)->getThen(), event); //if then
+							find_return_stmt(dyn_cast<IfStmt>(stmt)->getElse(), event); //if else
+							break;
+			case 90 :	find_return_stmt(dyn_cast<LabelStmt>(stmt)->getSubStmt(), event); //label
+							break;
+			case 98 :	line = sman.getCharacterData(dyn_cast<ReturnStmt>(stmt)->getReturnLoc()); 
+							line = get_line_of_code(line).substr(6);
+							line = line.substr(0,line.find("("));
+							if(test_model(line,"transit"))
+							{
+								param = get_params(line);
+								transitions.push_back(event.append(",").append(param));
+							}
+							break;
+			case 99 :  	find_return_stmt(stmt, event);
+							break;
+			case 101 : 	find_return_stmt(dyn_cast<SwitchStmt>(stmt)->getBody(), event); // switch
+							break;
+			case 102 : 	find_return_stmt(dyn_cast<WhileStmt>(stmt)->getBody(), event); // while
+							break;
+		}
 	}
-};
 
-int main(int argc, char *argv[])
-{
-	llvm::cl::ParseCommandLineOptions(argc, argv);	
-	std::cout<<"Input file: "<<inputFilename<<"\n";	
-	FILE* fileI = fopen(inputFilename.c_str(), "r");
-	if (!fileI)  
+};
+/**
+  * Main function provides all initialization before starting analysis of AST. Diagnostic Client is initialized,
+  * Command line options are processed.
+  */
+int main(int argc, char **argv)
+{ 
+	if(argc==1 || strncmp(argv[1],"-help",5)==0)
 	{
-		perror(inputFilename.c_str());
-		exit(1);
+		cout<<endl<<" Boost Statechart Viewer - help"<<endl;
+		cout<<"================================"<<endl;
+		cout<<"The program can be used almost the same way as a C compiler. You will typically need to specify locations for all header files except of the files stored in system folder(in Linux: /usr/...) using -I option. Of course you can specify the output filename (-o option). Program displays all diagnostic messages like compilers. If an error occurs the program stops."<<endl<<endl;
+		return 0;
 	}
-	fclose(fileI);
-	DiagnosticOptions diagnosticOptions;
-	MyDiagnosticClient *mdc = new MyDiagnosticClient(llvm::outs(), diagnosticOptions);
-	Diagnostic diag(mdc);
-	diag.setIgnoreAllWarnings(true);
-	LangOptions lang;
-	lang.BCPLComment=1;
-	lang.CPlusPlus=1; 
-	SourceManager sm (diag);
-	FileManager fm;
+	string inputFilename = "";
+	string outputFilename = "graph.dot"; // initialize output Filename
+	DiagnosticOptions dopts;
+	dopts.ShowColors=1;
+	MyDiagnosticClient *mdc = new MyDiagnosticClient(llvm::errs(), dopts);
+	llvm::IntrusiveRefCntPtr<DiagnosticIDs> dis(new DiagnosticIDs());	
+	Diagnostic diag(dis,mdc);
+	FileManager fm( * new FileSystemOptions());
+	SourceManager sm (diag, fm);
 	HeaderSearch *headers = new HeaderSearch(fm);
-	CompilerInvocation::setLangDefaults(lang, IK_ObjCXX);
+	
+	Driver TheDriver(LLVM_BINDIR, llvm::sys::getHostTriple(), "", false, false, diag);
+	TheDriver.setCheckInputsExist(true);
+	TheDriver.CCCIsCXX = 1;	
+	TheDriver.ResourceDir = LLVM_PREFIX "/lib/clang/" CLANG_VERSION_STRING;
 
-	HeaderSearchOptions hsopts;
-	hsopts.ResourceDir=LLVM_PREFIX "/lib/clang/" CLANG_VERSION_STRING;
-	for(unsigned i = 0; i<includeFiles.size();i++)
-	{
-		hsopts.AddPath(includeFiles[i],
-				clang::frontend::Angled,
-				false,
-				false,
-				true);
+	CompilerInvocation compInv;
+	llvm::SmallVector<const char *, 16> Args(argv, argv + argc);
+	llvm::OwningPtr<Compilation> C(TheDriver.BuildCompilation(Args.size(),
+                                                            Args.data()));
+	const driver::JobList &Jobs = C->getJobs();
+	const driver::Command *Cmd = cast<driver::Command>(*Jobs.begin());
+	const driver::ArgStringList &CCArgs = Cmd->getArguments();
+	for(unsigned i = 0; i<Args.size();i++) // find -o in ArgStringList
+	{	
+		if(strncmp(Args[i],"-o",2)==0) 
+		{
+			if(strlen(Args[i])>2)
+			{
+				string str = Args[i];
+				outputFilename = str.substr(2);
+			}
+			else outputFilename = Args[i+1];
+			break;
+		}
 	}
-	TargetOptions to;
-	to.Triple = llvm::sys::getHostTriple();
-	TargetInfo *ti = TargetInfo::CreateTargetInfo(diag, to);
-	clang::ApplyHeaderSearchOptions(
-		*headers,
-		hsopts,
-		lang,
-		ti->getTriple());
+		
+	CompilerInvocation::CreateFromArgs(compInv,
+	                                  const_cast<const char **>(CCArgs.data()),
+	                                  const_cast<const char **>(CCArgs.data())+CCArgs.size(),
+	                                  diag);
+
+	HeaderSearchOptions hsopts = compInv.getHeaderSearchOpts();
+	LangOptions lang = compInv.getLangOpts();
+	CompilerInvocation::setLangDefaults(lang, IK_ObjCXX);
+	TargetInfo *ti = TargetInfo::CreateTargetInfo(diag, compInv.getTargetOpts());
+	FrontendOptions f = compInv.getFrontendOpts();
+	inputFilename = f.Inputs[0].second;
+
+	cout<<"Input filename: "<<inputFilename<<"\n"; // print Input filename
+	cout<<"Output filename: "<<outputFilename<<"\n"; // print Output filename
+
+
 	Preprocessor pp(diag, lang, *ti, sm, *headers);
-	pp.getBuiltinInfo().InitializeBuiltins(pp.getIdentifierTable(),
-                                           pp.getLangOptions());
-	FrontendOptions f;
-	PreprocessorOptions ppio;
-	InitializePreprocessor(pp, ppio,hsopts,f);
+	pp.getBuiltinInfo().InitializeBuiltins(pp.getIdentifierTable(), lang);
+		
+	InitializePreprocessor(pp, compInv.getPreprocessorOpts(),hsopts,f);
+	
 	const FileEntry *file = fm.getFile(inputFilename);
 	sm.createMainFileID(file);
 	IdentifierTable tab(lang);
-	SelectorTable sel;
 	Builtin::Context builtins(*ti);
 	FindStates c;
-	ASTContext ctx(lang, sm, *ti, tab, sel, builtins,0);
-	mdc->BeginSourceFile(lang, &pp);
+	ASTContext ctx(lang, sm, *ti, tab, * new SelectorTable(), builtins,0);
+	mdc->BeginSourceFile(lang, &pp);//start using diagnostic
 	ParseAST(pp, &c, ctx, false, false);
-	mdc->EndSourceFile();
-	c.save_to_file(outputFile);
+	mdc->EndSourceFile(); //end using diagnostic
+	IO_operations *io = new IO_operations(outputFilename, c.getStateMachine(), c.getNameOfFirstState(), c.getTransitions(), c.getStates(), c.getEvents());
+	io->save_to_file();
+	io->print_stats();
+	mdc->print_stats();
 	return 0;
-
 }