From 74a93874cb13063cb76ef607e96a61110d5a25e8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Pecka?= <peckato1@fit.cvut.cz>
Date: Sat, 19 Apr 2014 20:11:24 +0200
Subject: [PATCH] aconversions: Resolve issue #20.

 - Make interfaces interfaces - remove member variables from them
 - Remove redundant interfaces
 - Remove redundant classes aka StateNonTerminalMap. This functionality can be achieved by simpler std::map
 - Ensure second call of convert() will not fail by creating everything on fly. Thompson is the only algorithm where output must be member variable to make things simple. C11 will hopefully resolve this.
 - Hexavigesimal for Brzozowski classes.
---
 .../src/aconversion/ConversionHandler.cpp     |  8 +-
 .../src/fa2re/AbstractFAtoREConverter.cpp     |  5 --
 .../src/fa2re/AbstractFAtoREConverter.h       | 19 +----
 .../src/fa2re/BrzozowskiAlgebraic.cpp         | 25 +++---
 aconversions/src/fa2re/BrzozowskiAlgebraic.h  | 10 +--
 aconversions/src/fa2re/StateElimination.cpp   |  9 +-
 aconversions/src/fa2re/StateElimination.h     |  5 ++
 .../src/fa2rg/AbstractFAtoRGConverter.cpp     |  6 --
 .../src/fa2rg/AbstractFAtoRGConverter.h       | 12 ---
 .../src/fa2rg/StateNonterminalMap.cpp         | 45 ----------
 aconversions/src/fa2rg/StateNonterminalMap.h  | 60 --------------
 .../fa2rg/fa2lrg/AbstractFAtoLRGConverter.cpp |  9 --
 .../fa2rg/fa2lrg/AbstractFAtoLRGConverter.h   | 13 +--
 .../src/fa2rg/fa2lrg/FAtoLRGConverter.cpp     | 54 +++++++-----
 .../src/fa2rg/fa2lrg/FAtoLRGConverter.h       |  6 +-
 .../fa2rg/fa2rrg/AbstractFAtoRRGConverter.cpp |  8 --
 .../fa2rg/fa2rrg/AbstractFAtoRRGConverter.h   | 14 +---
 .../src/fa2rg/fa2rrg/FAtoRRGConverter.cpp     | 59 +++++++------
 .../src/fa2rg/fa2rrg/FAtoRRGConverter.h       |  6 +-
 .../src/re2fa/AbstractREtoFAConverter.cpp     |  5 --
 .../src/re2fa/AbstractREtoFAConverter.h       | 18 +---
 aconversions/src/re2fa/Brzozowski.cpp         | 63 ++++----------
 aconversions/src/re2fa/Brzozowski.h           | 35 +-------
 aconversions/src/re2fa/Glushkov.cpp           | 22 ++---
 aconversions/src/re2fa/Glushkov.h             |  5 ++
 aconversions/src/re2fa/Thompson.cpp           |  4 +-
 aconversions/src/re2fa/Thompson.h             | 10 +++
 .../src/re2rg/AbstractREtoRGConverter.cpp     |  5 --
 .../src/re2rg/AbstractREtoRGConverter.h       | 13 +--
 .../re2rg/re2rrg/AbstractREtoRRGConverter.cpp |  5 --
 .../re2rg/re2rrg/AbstractREtoRRGConverter.h   | 13 +--
 .../re2rg/re2rrg/BrzozowskiDerivationRRG.cpp  | 82 ++++++-------------
 .../re2rg/re2rrg/BrzozowskiDerivationRRG.h    | 17 ++--
 aconversions/src/re2rg/re2rrg/GlushkovRRG.cpp | 26 +++---
 aconversions/src/re2rg/re2rrg/GlushkovRRG.h   |  5 ++
 .../src/rg2fa/AbstractRGtoFAConverter.cpp     |  5 --
 .../src/rg2fa/AbstractRGtoFAConverter.h       | 10 +--
 .../rg2fa/lrg2fa/AbstractLRGtoFAConverter.cpp | 25 ------
 .../rg2fa/lrg2fa/AbstractLRGtoFAConverter.h   | 41 ----------
 .../src/rg2fa/lrg2fa/LRGtoFAConverter.cpp     | 24 +++---
 .../src/rg2fa/lrg2fa/LRGtoFAConverter.h       | 13 ++-
 .../rg2fa/rrg2fa/AbstractRRGtoFAConverter.cpp | 25 ------
 .../rg2fa/rrg2fa/AbstractRRGtoFAConverter.h   | 40 ---------
 .../src/rg2fa/rrg2fa/RRGtoFAConverter.cpp     | 24 +++---
 .../src/rg2fa/rrg2fa/RRGtoFAConverter.h       | 13 ++-
 .../src/rg2re/AbstractRGtoREConverter.cpp     |  5 --
 .../src/rg2re/AbstractRGtoREConverter.h       | 10 +--
 .../rg2re/lrg2re/AbstractLRGtoREConverter.cpp | 25 ------
 .../rg2re/lrg2re/AbstractLRGtoREConverter.h   | 37 ---------
 .../src/rg2re/lrg2re/LRGAlgebraic.cpp         | 14 ++--
 aconversions/src/rg2re/lrg2re/LRGAlgebraic.h  | 11 ++-
 .../rg2re/rrg2re/AbstractRRGtoREConverter.cpp | 25 ------
 .../rg2re/rrg2re/AbstractRRGtoREConverter.h   | 37 ---------
 .../src/rg2re/rrg2re/RRGAlgebraic.cpp         | 14 ++--
 aconversions/src/rg2re/rrg2re/RRGAlgebraic.h  | 11 ++-
 .../lrg2rrg/AbstractLRGtoRRGConverter.cpp     |  5 --
 .../rg2rg/lrg2rrg/AbstractLRGtoRRGConverter.h | 16 ----
 .../lrg2rrg/LeftToRightRegularGrammar.cpp     | 30 +++----
 .../rg2rg/lrg2rrg/LeftToRightRegularGrammar.h |  6 ++
 .../rrg2lrg/AbstractRRGtoLRGConverter.cpp     |  5 --
 .../rg2rg/rrg2lrg/AbstractRRGtoLRGConverter.h | 16 ----
 .../rrg2lrg/RightToLeftRegularGrammar.cpp     | 30 +++----
 .../rg2rg/rrg2lrg/RightToLeftRegularGrammar.h |  6 ++
 aconversions/src/shared/Hexavigesimal.cpp     | 31 +++++++
 aconversions/src/shared/Hexavigesimal.h       | 24 ++++++
 65 files changed, 393 insertions(+), 886 deletions(-)
 delete mode 100644 aconversions/src/fa2rg/StateNonterminalMap.cpp
 delete mode 100644 aconversions/src/fa2rg/StateNonterminalMap.h
 delete mode 100644 aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.cpp
 delete mode 100644 aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.h
 delete mode 100644 aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.cpp
 delete mode 100644 aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.h
 delete mode 100644 aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.cpp
 delete mode 100644 aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.h
 delete mode 100644 aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.cpp
 delete mode 100644 aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.h
 create mode 100644 aconversions/src/shared/Hexavigesimal.cpp
 create mode 100644 aconversions/src/shared/Hexavigesimal.h

diff --git a/aconversions/src/aconversion/ConversionHandler.cpp b/aconversions/src/aconversion/ConversionHandler.cpp
index c7f8637b50..7230d808b1 100644
--- a/aconversions/src/aconversion/ConversionHandler.cpp
+++ b/aconversions/src/aconversion/ConversionHandler.cpp
@@ -247,7 +247,7 @@ void ConversionHandler::convertLRGtoFSM( void )
 {
     const LeftRegularGrammar lrg = GrammarFactory::buildLeftRegularGrammar( GrammarParser::parse( m_tokens ) );
 
-    AbstractLRGtoFAConverter* conv;
+    AbstractRGtoFAConverter* conv;
 
     switch( m_algorithm )
     {
@@ -264,7 +264,7 @@ void ConversionHandler::convertRRGtoFSM( void )
 {
     const RightRegularGrammar rrg = GrammarFactory::buildRightRegularGrammar( GrammarParser::parse( m_tokens ) );
 
-    AbstractRRGtoFAConverter* conv;
+    AbstractRGtoFAConverter* conv;
 
     switch( m_algorithm )
     {
@@ -281,7 +281,7 @@ void ConversionHandler::convertLRGtoRE( void )
 {
     const LeftRegularGrammar lrg = GrammarFactory::buildLeftRegularGrammar( GrammarParser::parse( m_tokens ) );
 
-    AbstractLRGtoREConverter* conv;
+    AbstractRGtoREConverter* conv;
 
     switch( m_algorithm )
     {
@@ -299,7 +299,7 @@ void ConversionHandler::convertRRGtoRE( void )
 {
     const RightRegularGrammar rrg = GrammarFactory::buildRightRegularGrammar( GrammarParser::parse( m_tokens ) );
 
-    AbstractRRGtoREConverter* conv;
+    AbstractRGtoREConverter* conv;
 
     switch( m_algorithm )
     {
diff --git a/aconversions/src/fa2re/AbstractFAtoREConverter.cpp b/aconversions/src/fa2re/AbstractFAtoREConverter.cpp
index 2934413552..7d056806ed 100644
--- a/aconversions/src/fa2re/AbstractFAtoREConverter.cpp
+++ b/aconversions/src/fa2re/AbstractFAtoREConverter.cpp
@@ -6,11 +6,6 @@ using namespace regexp;
 namespace conversions
 {
 
-AbstractFAtoREConverter::AbstractFAtoREConverter( const FSM & automaton ) : m_automaton( automaton )
-{
-
-}
-
 AbstractFAtoREConverter::~AbstractFAtoREConverter( void )
 {
 
diff --git a/aconversions/src/fa2re/AbstractFAtoREConverter.h b/aconversions/src/fa2re/AbstractFAtoREConverter.h
index 4ea9b2e98c..dbc2377256 100644
--- a/aconversions/src/fa2re/AbstractFAtoREConverter.h
+++ b/aconversions/src/fa2re/AbstractFAtoREConverter.h
@@ -12,7 +12,7 @@ namespace conversions
 {
 
 /**
- * Abstract finite automata to regular expression converter.
+ * Interface for finite automaton to regular expression conversion.
  */
 class AbstractFAtoREConverter : public Conversion
 {
@@ -20,25 +20,10 @@ public:
     /**
      * @return regular expression equivalent to source automata.
      */
-    virtual regexp::RegExp convert( ) = 0;
+    virtual regexp::RegExp convert( void ) = 0;
 
     virtual ~AbstractFAtoREConverter( void );
 
-protected:
-    /**
-     * @param automaton Original FSM.
-     */
-    AbstractFAtoREConverter( const automaton::FSM & automaton );
-
-    /**
-     * Original FSM.
-     */
-    const automaton::FSM m_automaton;
-
-    /**
-     * New RE.
-     */
-    regexp::RegExp m_re;
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/fa2re/BrzozowskiAlgebraic.cpp b/aconversions/src/fa2re/BrzozowskiAlgebraic.cpp
index aa9ef137b6..6d9d38f04c 100644
--- a/aconversions/src/fa2re/BrzozowskiAlgebraic.cpp
+++ b/aconversions/src/fa2re/BrzozowskiAlgebraic.cpp
@@ -14,7 +14,7 @@ using namespace regexp;
 namespace conversions
 {
 
-BrzozowskiAlgebraic::BrzozowskiAlgebraic( const FSM & fsm ) : AbstractFAtoREConverter( fsm )
+BrzozowskiAlgebraic::BrzozowskiAlgebraic( const FSM & automaton ) : m_automaton( automaton )
 {
 
 }
@@ -24,20 +24,22 @@ BrzozowskiAlgebraic::~BrzozowskiAlgebraic( void )
 
 }
 
-void BrzozowskiAlgebraic::initEquations( void )
+RegExp BrzozowskiAlgebraic::convert( void )
 {
+    RightRegularEquationSolver solver;
+
+    // initialize equations
     for( const auto & q : m_automaton.getStates( ) )
-        m_solver.addSymbol( Symbol( q.getName( ) ) );
+        solver.addSymbol( Symbol( q.getName( ) ) );
 
     for( const auto & q : m_automaton.getStates( ) )
     {
         if( isInSet( q, m_automaton.getFinalStates( ) ) )
-            m_solver.addEquation( Symbol( q.getName( ) ), new RegExpEpsilon( ) );
+            solver.addEquation( Symbol( q.getName( ) ), new RegExpEpsilon( ) );
         else
-            m_solver.addEquation( Symbol( q.getName( ) ), new RegExpEmpty( ) );
+            solver.addEquation( Symbol( q.getName( ) ), new RegExpEmpty( ) );
     }
 
-
     for( const auto & p : m_automaton.getStates( ) )
     {
         for( const auto & q : m_automaton.getStates( ) )
@@ -49,17 +51,14 @@ void BrzozowskiAlgebraic::initEquations( void )
                 if ( isInSet( TransitionFSM( p, symbol, q ), m_automaton.getTransitions( ) ) )
                     alt->getElements( ).push_back( new RegExpSymbol( symbol.getSymbol( ) ) );
 
-            m_solver.addEquation( Symbol( p.getName( ) ), Symbol( q.getName( ) ), alt );
+            solver.addEquation( Symbol( p.getName( ) ), Symbol( q.getName( ) ), alt );
         }
     }
-}
-
-RegExp BrzozowskiAlgebraic::convert( void )
-{
-    initEquations( );
 
+    // set symbol for which the solver will solve equation system
     Symbol initSymbol( ( * m_automaton.getInitialStates( ).begin( ) ).getName( ) );
-    return m_solver.solve( initSymbol );
+
+    return solver.solve( initSymbol );
 }
 
 } /* namespace conversions */
diff --git a/aconversions/src/fa2re/BrzozowskiAlgebraic.h b/aconversions/src/fa2re/BrzozowskiAlgebraic.h
index 6623b169d0..dbfee0b4bc 100644
--- a/aconversions/src/fa2re/BrzozowskiAlgebraic.h
+++ b/aconversions/src/fa2re/BrzozowskiAlgebraic.h
@@ -27,7 +27,7 @@ namespace conversions
  * Converts FA to RE using Brzozowski's algebraic method using right regular equations.
  * Source : Melichar 2.122
  */
-class BrzozowskiAlgebraic: public conversions::AbstractFAtoREConverter
+class BrzozowskiAlgebraic: public AbstractFAtoREConverter
 {
 public:
     /**
@@ -39,17 +39,15 @@ public:
 
     /**
      * Performs conversion.
-     * @return regular expression equivalent to source automata.
+     * @return regular expression equivalent to input automaton.
      */
     regexp::RegExp convert( void );
 
 private:
-    void initEquations( void );
-
     /**
-     * Regular equation solver.
+     * Input automaton
      */
-    RightRegularEquationSolver m_solver;
+    const automaton::FSM & m_automaton;
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/fa2re/StateElimination.cpp b/aconversions/src/fa2re/StateElimination.cpp
index e849756356..b693a2443a 100644
--- a/aconversions/src/fa2re/StateElimination.cpp
+++ b/aconversions/src/fa2re/StateElimination.cpp
@@ -15,7 +15,7 @@ using namespace std;
 namespace conversions
 {
 
-StateElimination::StateElimination( const FSM & fsm ) : AbstractFAtoREConverter( fsm )
+StateElimination::StateElimination( const FSM & automaton ) : m_automaton( automaton )
 {
 
 }
@@ -59,10 +59,13 @@ RegExp StateElimination::convert( void )
     concat->getElements( ).push_back( iter );
 
     RegExpOptimize opt;
-    m_re.setRegExp( opt.optimize( concat ) );
+
+    RegExp ret;
+    ret.setRegExp( opt.optimize( concat ) );
+
     delete concat;
 
-    return m_re;
+    return ret;
 }
 
 void StateElimination::constructExtendedNFA( void )
diff --git a/aconversions/src/fa2re/StateElimination.h b/aconversions/src/fa2re/StateElimination.h
index f5d27e6bba..6c02f2eb0b 100644
--- a/aconversions/src/fa2re/StateElimination.h
+++ b/aconversions/src/fa2re/StateElimination.h
@@ -99,6 +99,11 @@ private:
      * Extended NFA.
      */
     ExtendedNFA m_MR;
+
+    /**
+     * Input automaton
+     */
+    const automaton::FSM & m_automaton;
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/fa2rg/AbstractFAtoRGConverter.cpp b/aconversions/src/fa2rg/AbstractFAtoRGConverter.cpp
index dedff158fe..499919b351 100644
--- a/aconversions/src/fa2rg/AbstractFAtoRGConverter.cpp
+++ b/aconversions/src/fa2rg/AbstractFAtoRGConverter.cpp
@@ -14,12 +14,6 @@ using namespace grammar;
 namespace conversions
 {
 
-AbstractFAtoRGConverter::AbstractFAtoRGConverter( const FSM & fsm ) : m_fsm( fsm )
-{
-    if( ! m_fsm.isEpsilonFree( ) )
-        throw AlibException( "FSM has epsilon transitions" );
-}
-
 AbstractFAtoRGConverter::~AbstractFAtoRGConverter( void )
 {
 
diff --git a/aconversions/src/fa2rg/AbstractFAtoRGConverter.h b/aconversions/src/fa2rg/AbstractFAtoRGConverter.h
index b05163aa80..76af14f1c6 100644
--- a/aconversions/src/fa2rg/AbstractFAtoRGConverter.h
+++ b/aconversions/src/fa2rg/AbstractFAtoRGConverter.h
@@ -13,7 +13,6 @@
 #include <AlibException.h>
 
 #include "../abstract/Conversion.h"
-#include "StateNonterminalMap.h"
 
 namespace conversions
 {
@@ -24,18 +23,7 @@ namespace conversions
 class AbstractFAtoRGConverter : public Conversion
 {
 public:
-    /**
-     * @param fsm Source automaton.
-     */
-    AbstractFAtoRGConverter( const automaton::FSM & fsm );
-
     ~AbstractFAtoRGConverter( void );
-
-protected:
-    /**
-     * Source automaton.
-     */
-    const automaton::FSM m_fsm;
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/fa2rg/StateNonterminalMap.cpp b/aconversions/src/fa2rg/StateNonterminalMap.cpp
deleted file mode 100644
index cb6f03c1d0..0000000000
--- a/aconversions/src/fa2rg/StateNonterminalMap.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- * StateNonterminalMap.cpp
- *
- *  Created on: 15. 3. 2014
- *      Author: tomas
- */
-
-#include "StateNonterminalMap.h"
-
-using namespace alib;
-using namespace alphabet;
-using namespace automaton;
-using namespace grammar;
-
-namespace conversions
-{
-
-StateNonterminalMap::StateNonterminalMap( const FSM & fsm, RegularGrammar & grammar ) :
-        m_fsm( fsm ),
-        m_grammar( grammar )
-{
-    initMap( );
-}
-
-const Symbol & StateNonterminalMap::getNonTerminal( const State & state )
-{
-    auto it = m_map.find( state );
-
-    // probably harmless to return reference to object stored in map
-    if( it != m_map.end( ) )
-        return it->second;
-
-    throw AlibException( "No nonterminal for this state! Should not happen unless you manipulated with automata after initialize mapper initialize." );
-}
-
-void StateNonterminalMap::initMap( void )
-{
-    for( const auto & state : m_fsm.getStates( ) )
-    {
-        Symbol nonTerminal = m_grammar.createUniqueNonTerminalSymbol( state.getName( ), false );
-        m_map.insert( make_pair( state, nonTerminal ) );
-    }
-}
-
-} /* namespace conversions */
diff --git a/aconversions/src/fa2rg/StateNonterminalMap.h b/aconversions/src/fa2rg/StateNonterminalMap.h
deleted file mode 100644
index eb8053b72c..0000000000
--- a/aconversions/src/fa2rg/StateNonterminalMap.h
+++ /dev/null
@@ -1,60 +0,0 @@
-/*
- * StateNonterminalMap.h
- *
- *  Created on: 15. 3. 2014
- *      Author: tomas
- */
-
-#ifndef STATENONTERMINALMAP_H_
-#define STATENONTERMINALMAP_H_
-
-#include <map>
-
-#include <automaton/FSM/FSM.h>
-#include <grammar/Regular/RegularGrammar.h>
-#include <AlibException.h>
-
-#include "../include/macros.h"
-
-namespace conversions
-{
-
-/**
- * This class maps grammar nonterminals to automata states in order to avoid
- * symbol collision.
- */
-class StateNonterminalMap
-{
-public:
-    /**
-     * Initiates mapping function, also creates nonterminals states in target grammar.
-     *
-     * @param fsm Source FSM.
-     * @param grammar Target grammar.
-     */
-    StateNonterminalMap( const automaton::FSM & fsm, grammar::RegularGrammar & grammar );
-    const alphabet::Symbol & getNonTerminal( const automaton::State & state );
-
-private:
-    void initMap( void );
-
-    /**
-     * Maps automaton's state to grammar's Symbol
-     */
-    std::map<const automaton::State, const alphabet::Symbol> m_map;
-
-    /**
-     * Source automata.
-     */
-    const automaton::FSM m_fsm;
-
-    /**
-     * Target grammar.
-     */
-    grammar::RegularGrammar & m_grammar;
-
-};
-
-} /* namespace conversions */
-
-#endif /* STATENONTERMINALMAP_H_ */
diff --git a/aconversions/src/fa2rg/fa2lrg/AbstractFAtoLRGConverter.cpp b/aconversions/src/fa2rg/fa2lrg/AbstractFAtoLRGConverter.cpp
index 341a5874d1..e6b531f79a 100644
--- a/aconversions/src/fa2rg/fa2lrg/AbstractFAtoLRGConverter.cpp
+++ b/aconversions/src/fa2rg/fa2lrg/AbstractFAtoLRGConverter.cpp
@@ -1,17 +1,8 @@
 #include "AbstractFAtoLRGConverter.h"
 
-using namespace alib;
-using namespace automaton;
-using namespace grammar;
-
 namespace conversions
 {
 
-AbstractFAtoLRGConverter::AbstractFAtoLRGConverter( const FSM & automaton ) : AbstractFAtoRGConverter( automaton )
-{
-
-}
-
 AbstractFAtoLRGConverter::~AbstractFAtoLRGConverter( void )
 {
 
diff --git a/aconversions/src/fa2rg/fa2lrg/AbstractFAtoLRGConverter.h b/aconversions/src/fa2rg/fa2lrg/AbstractFAtoLRGConverter.h
index 360f2515a7..38b61b7a99 100644
--- a/aconversions/src/fa2rg/fa2lrg/AbstractFAtoLRGConverter.h
+++ b/aconversions/src/fa2rg/fa2lrg/AbstractFAtoLRGConverter.h
@@ -20,19 +20,8 @@ public:
     /**
      * @return left regular grammar equivalent to source automata.
      */
-    virtual grammar::LeftRegularGrammar convert( ) = 0;
+    virtual grammar::LeftRegularGrammar convert( void ) = 0;
     virtual ~AbstractFAtoLRGConverter( void );
-
-protected:
-    /**
-     * New left regular grammar.
-     */
-    grammar::LeftRegularGrammar m_grammar;
-
-    /**
-     * @param automaton Original FSM.
-     */
-    AbstractFAtoLRGConverter( const automaton::FSM & automaton );
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/fa2rg/fa2lrg/FAtoLRGConverter.cpp b/aconversions/src/fa2rg/fa2lrg/FAtoLRGConverter.cpp
index ae572db176..ebafba7879 100644
--- a/aconversions/src/fa2rg/fa2lrg/FAtoLRGConverter.cpp
+++ b/aconversions/src/fa2rg/fa2lrg/FAtoLRGConverter.cpp
@@ -3,13 +3,15 @@
 using namespace std;
 using namespace automaton;
 using namespace grammar;
+using namespace alib;
 
 namespace conversions
 {
 
-FAtoLRGConverter::FAtoLRGConverter( const FSM & automaton ) : AbstractFAtoLRGConverter( automaton )
+FAtoLRGConverter::FAtoLRGConverter( const FSM & automaton ) : m_automaton( automaton )
 {
-
+    if( ! automaton.isEpsilonFree( ) )
+        throw AlibException( "FSM has epsilon transitions." );
 }
 
 FAtoLRGConverter::~FAtoLRGConverter( void )
@@ -19,61 +21,69 @@ FAtoLRGConverter::~FAtoLRGConverter( void )
 
 LeftRegularGrammar FAtoLRGConverter::convert( void )
 {
-    for( const auto & symbol : m_fsm.getInputAlphabet( ) )
-        m_grammar.addTerminalSymbol( symbol );
+    LeftRegularGrammar grammar;
+    map<State, Symbol> nonterminalMap;
 
-    StateNonterminalMap symbolMap( m_fsm, m_grammar );
+    for( const auto & symbol : m_automaton.getInputAlphabet( ) )
+        grammar.addTerminalSymbol( symbol );
+
+    for( const auto & state : m_automaton.getStates( ) )
+    {
+        Symbol nt = grammar.createUniqueNonTerminalSymbol( state.getName( ) );
+        nonterminalMap.insert( pair<State,Symbol>( state, nt ) );
+    }
 
     // step 2 - create set of P in G
-    for( const auto & transition : m_fsm.getTransitions( ) )
+    for( const auto & transition : m_automaton.getTransitions( ) )
     {
         // 2a
         list<Symbol> leftSide, rightSide;
-        leftSide.push_back( symbolMap.getNonTerminal( transition.getTo( ) ) );
-        rightSide.push_back( symbolMap.getNonTerminal( transition.getFrom( ) ) );
+        leftSide.push_back( nonterminalMap.find( transition.getTo( ) )->second );
+        rightSide.push_back( nonterminalMap.find( transition.getFrom( ) )->second );
         rightSide.push_back( transition.getInput( ) );
-        m_grammar.addRule( Rule( leftSide, rightSide ) );
+        grammar.addRule( Rule( leftSide, rightSide ) );
 
         // 2b
-        if( isInSet( transition.getFrom( ), m_fsm.getInitialStates( ) ) )
+        if( isInSet( transition.getFrom( ), m_automaton.getInitialStates( ) ) )
         {
             list<Symbol> leftSide, rightSide;
-            leftSide.push_back( symbolMap.getNonTerminal( transition.getTo( ) ) );
+            leftSide.push_back( nonterminalMap.find( transition.getTo( ) )->second );
             rightSide.push_back( transition.getInput( ) );
-            m_grammar.addRule( Rule( leftSide, rightSide ) );
+            grammar.addRule( Rule( leftSide, rightSide ) );
         }
     }
 
     // step 3
-    Symbol newStart = m_grammar.createUniqueNonTerminalSymbol( "S", false );
-    m_grammar.setStartSymbol( newStart );
+    Symbol newStart = grammar.createUniqueNonTerminalSymbol( "S", false );
+    grammar.setStartSymbol( newStart );
 
     //
-    if( isInSet( * m_fsm.getInitialStates( ).begin( ), m_fsm.getFinalStates( ) ) )
+    if( isInSet( * m_automaton.getInitialStates( ).begin( ), m_automaton.getFinalStates( ) ) )
     {
         list<Symbol> leftSide = { newStart }, rightSide;
-        m_grammar.addRule( Rule( leftSide, rightSide ) );
+        grammar.addRule( Rule( leftSide, rightSide ) );
     }
 
     // pro vsecky neterminaly, ktere vznikly z finalnich stavu:
         // kopiruj jejich prave strany k newStart
         // pokud nejsou nikde vpravo, smaz je
 
-    for( const auto & rule : m_grammar.getRules( ) )
+    for( const auto & rule : grammar.getRules( ) )
     {
         const Symbol & leftSide = rule.getLeftSide( ).front( );
 
-        if( isInSet( State( leftSide.getSymbol( ) ), m_fsm.getFinalStates( ) ) )
+        if( isInSet( State( leftSide.getSymbol( ) ), m_automaton.getFinalStates( ) ) )
         {
             list<Symbol> leftSide = { newStart }, rightSide( rule.getRightSide( ) );
-            m_grammar.addRule( Rule( leftSide, rightSide ) );
+            grammar.addRule( Rule( leftSide, rightSide ) );
         }
 
         // jetenhle krok nutny,???
-        // if( leftSide != m_grammar.getStartSymbol( ) && ! m_grammar.isNonTerminalOnRightSideOfAnyRule( leftSide ) )
-        //    m_grammar.removeRule( rule );
+        // if( leftSide != grammar.getStartSymbol( ) && ! grammar.isNonTerminalOnRightSideOfAnyRule( leftSide ) )
+        //    grammar.removeRule( rule );
     }
 
-    return m_grammar;
+    return grammar;
 }
+
 } /* namespace conversions */
diff --git a/aconversions/src/fa2rg/fa2lrg/FAtoLRGConverter.h b/aconversions/src/fa2rg/fa2lrg/FAtoLRGConverter.h
index 348384ecf5..4bc20c401d 100644
--- a/aconversions/src/fa2rg/fa2lrg/FAtoLRGConverter.h
+++ b/aconversions/src/fa2rg/fa2lrg/FAtoLRGConverter.h
@@ -1,6 +1,8 @@
 #ifndef __FATOLRGCONVERTER_H__
 #define __FATOLRGCONVERTER_H__
 
+#include <map>
+
 #include <grammar/Regular/LeftRegularGrammar.h>
 #include <automaton/FSM/FSM.h>
 
@@ -31,9 +33,9 @@ public:
 
 protected:
     /**
-     * New left regular grammar.
+     * input automaton
      */
-    grammar::LeftRegularGrammar m_grammar;
+    const automaton::FSM & m_automaton;
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/fa2rg/fa2rrg/AbstractFAtoRRGConverter.cpp b/aconversions/src/fa2rg/fa2rrg/AbstractFAtoRRGConverter.cpp
index 2201255bce..1af46b4f82 100644
--- a/aconversions/src/fa2rg/fa2rrg/AbstractFAtoRRGConverter.cpp
+++ b/aconversions/src/fa2rg/fa2rrg/AbstractFAtoRRGConverter.cpp
@@ -1,16 +1,8 @@
 #include "AbstractFAtoRRGConverter.h"
 
-using namespace automaton;
-using namespace grammar;
-
 namespace conversions
 {
 
-AbstractFAtoRRGConverter::AbstractFAtoRRGConverter( const FSM & automaton ) : AbstractFAtoRGConverter( automaton )
-{
-
-}
-
 AbstractFAtoRRGConverter::~AbstractFAtoRRGConverter( void )
 {
 
diff --git a/aconversions/src/fa2rg/fa2rrg/AbstractFAtoRRGConverter.h b/aconversions/src/fa2rg/fa2rrg/AbstractFAtoRRGConverter.h
index 44e7edea9e..6df8f25e87 100644
--- a/aconversions/src/fa2rg/fa2rrg/AbstractFAtoRRGConverter.h
+++ b/aconversions/src/fa2rg/fa2rrg/AbstractFAtoRRGConverter.h
@@ -20,19 +20,9 @@ public:
     /**
      * @return right regular grammar equivalent to source automata.
      */
-    virtual grammar::RightRegularGrammar convert( ) = 0;
-    virtual ~AbstractFAtoRRGConverter( void );
-
-protected:
-    /**
-     * New right regular grammar.
-     */
-    grammar::RightRegularGrammar m_grammar;
+    virtual grammar::RightRegularGrammar convert( void ) = 0;
 
-    /**
-     * @param automaton Original automaton.
-     */
-    AbstractFAtoRRGConverter( const automaton::FSM & automaton );
+    virtual ~AbstractFAtoRRGConverter( void );
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/fa2rg/fa2rrg/FAtoRRGConverter.cpp b/aconversions/src/fa2rg/fa2rrg/FAtoRRGConverter.cpp
index 28b1db6147..4a87c0a6d2 100644
--- a/aconversions/src/fa2rg/fa2rrg/FAtoRRGConverter.cpp
+++ b/aconversions/src/fa2rg/fa2rrg/FAtoRRGConverter.cpp
@@ -3,13 +3,15 @@
 using namespace std;
 using namespace automaton;
 using namespace grammar;
+using namespace alib;
 
 namespace conversions
 {
 
-FAtoRRGConverter::FAtoRRGConverter( const FSM & automaton ) : AbstractFAtoRRGConverter( automaton )
+FAtoRRGConverter::FAtoRRGConverter( const FSM & automaton ) : m_automaton( automaton )
 {
-
+    if( ! automaton.isEpsilonFree( ) )
+        throw AlibException( "FSM has epsilon transitions." );
 }
 
 FAtoRRGConverter::~FAtoRRGConverter( void )
@@ -19,73 +21,80 @@ FAtoRRGConverter::~FAtoRRGConverter( void )
 
 RightRegularGrammar FAtoRRGConverter::convert( void )
 {
-    for( const auto & symbol : m_fsm.getInputAlphabet( ) )
-        m_grammar.addTerminalSymbol( symbol );
+    RightRegularGrammar grammar;
+    map<State, Symbol> nonterminalMap;
+
+    for( const auto & symbol : m_automaton.getInputAlphabet( ) )
+        grammar.addTerminalSymbol( symbol );
 
-    StateNonterminalMap symbolMap( m_fsm, m_grammar );
+    for( const auto & state : m_automaton.getStates( ) )
+    {
+        Symbol nt = grammar.createUniqueNonTerminalSymbol( state.getName( ) );
+        nonterminalMap.insert( pair<State,Symbol>( state, nt ) );
+    }
 
     // step 2 - create set of P in G
-    for( const auto & transition : m_fsm.getTransitions( ) )
+    for( const auto & transition : m_automaton.getTransitions( ) )
     {
         // 2a
         list<Symbol> leftSide, rightSide;
-        leftSide.push_back( symbolMap.getNonTerminal( transition.getFrom( ) ) );
+        leftSide.push_back( nonterminalMap.find( transition.getFrom( ) )->second );
         rightSide.push_back( transition.getInput( ) );
-        rightSide.push_back( symbolMap.getNonTerminal( transition.getTo( ) ) );
-        m_grammar.addRule( Rule( leftSide, rightSide ) );
+        rightSide.push_back( nonterminalMap.find( transition.getTo( ) )->second );
+        grammar.addRule( Rule( leftSide, rightSide ) );
 
         // 2b
-        if( isInSet( transition.getTo( ), m_fsm.getFinalStates( ) ) )
+        if( isInSet( transition.getTo( ), m_automaton.getFinalStates( ) ) )
         {
             list<Symbol> leftSide, rightSide;
-            leftSide.push_back( symbolMap.getNonTerminal( transition.getFrom( ) ) );
+            leftSide.push_back( nonterminalMap.find( transition.getFrom( ) )->second );
             rightSide.push_back( transition.getInput( ) );
 
             /*
              *  Rule might already in - consider case:
              *  \delta(A,a) = { F, G }, where both F and G are final states
              */
-            if( ! isInSet( Rule( leftSide, rightSide), m_grammar.getRules( ) ) )
-                m_grammar.addRule( Rule( leftSide, rightSide ) );
+            if( ! isInSet( Rule( leftSide, rightSide), grammar.getRules( ) ) )
+                grammar.addRule( Rule( leftSide, rightSide ) );
         }
     }
 
     // step 3 - set start symbol of G
-    m_grammar.setStartSymbol( symbolMap.getNonTerminal( * m_fsm.getInitialStates( ).begin( ) ) );
+    grammar.setStartSymbol( nonterminalMap.find( * m_automaton.getInitialStates( ).begin( ) )->second );
 
     // step 4
-    if( isInSet( * m_fsm.getInitialStates( ).begin( ), m_fsm.getFinalStates( ) ) )
+    if( isInSet( * m_automaton.getInitialStates( ).begin( ), m_automaton.getFinalStates( ) ) )
     {
         // 4a
-        if( ! m_grammar.isNonTerminalOnRightSideOfAnyRule( m_grammar.getStartSymbol( ) ) )
+        if( ! grammar.isNonTerminalOnRightSideOfAnyRule( grammar.getStartSymbol( ) ) )
         {
             list<Symbol> leftSide, rightSide;
-            leftSide.push_back( m_grammar.getStartSymbol( ) );
-            m_grammar.addRule( Rule( leftSide, rightSide ) );
+            leftSide.push_back( grammar.getStartSymbol( ) );
+            grammar.addRule( Rule( leftSide, rightSide ) );
         }
         else // 4b
         {
-            Symbol newStart = m_grammar.createUniqueNonTerminalSymbol( m_grammar.getStartSymbol( ).getSymbol( ), false );
+            Symbol newStart = grammar.createUniqueNonTerminalSymbol( grammar.getStartSymbol( ).getSymbol( ), false );
 
-            for( const auto & rule : m_grammar.getRules( ) )
+            for( const auto & rule : grammar.getRules( ) )
             {
-                if( rule.getLeftSide( ).front( ) == m_grammar.getStartSymbol( ) )
+                if( rule.getLeftSide( ).front( ) == grammar.getStartSymbol( ) )
                 {
                     list<Symbol> leftSide, rightSide( rule.getRightSide( ) );
                     leftSide.push_back( newStart );
-                    m_grammar.addRule( Rule( leftSide, rightSide ) );
+                    grammar.addRule( Rule( leftSide, rightSide ) );
                 }
             }
-            m_grammar.setStartSymbol( newStart );
+            grammar.setStartSymbol( newStart );
 
             list<Symbol> leftSide, rightSide;
             leftSide.push_back( newStart );
             Rule rr( leftSide, rightSide );
-            m_grammar.addRule( Rule( leftSide, rightSide ) );
+            grammar.addRule( Rule( leftSide, rightSide ) );
         }
     }
 
-    return m_grammar;
+    return grammar;
 }
 
 } /* namespace conversions */
diff --git a/aconversions/src/fa2rg/fa2rrg/FAtoRRGConverter.h b/aconversions/src/fa2rg/fa2rrg/FAtoRRGConverter.h
index 074d36ddd5..dc759f8488 100644
--- a/aconversions/src/fa2rg/fa2rrg/FAtoRRGConverter.h
+++ b/aconversions/src/fa2rg/fa2rrg/FAtoRRGConverter.h
@@ -1,6 +1,8 @@
 #ifndef __FATORRGCONVERTER_H__
 #define __FATORRGCONVERTER_H__
 
+#include <map>
+
 #include <grammar/Regular/RightRegularGrammar.h>
 #include <automaton/FSM/FSM.h>
 
@@ -31,9 +33,9 @@ public:
 
 protected:
     /**
-     * New right regular grammar.
+     * input automaton
      */
-    grammar::RightRegularGrammar m_grammar;
+    const automaton::FSM & m_automaton;
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/re2fa/AbstractREtoFAConverter.cpp b/aconversions/src/re2fa/AbstractREtoFAConverter.cpp
index af481d488e..c99bff419f 100644
--- a/aconversions/src/re2fa/AbstractREtoFAConverter.cpp
+++ b/aconversions/src/re2fa/AbstractREtoFAConverter.cpp
@@ -5,11 +5,6 @@ using namespace regexp;
 namespace conversions
 {
 
-AbstractREtoFAConverter::AbstractREtoFAConverter(const RegExp & re ) : m_re(re)
-{
-
-}
-
 AbstractREtoFAConverter::~AbstractREtoFAConverter(void)
 {
 
diff --git a/aconversions/src/re2fa/AbstractREtoFAConverter.h b/aconversions/src/re2fa/AbstractREtoFAConverter.h
index 69af927a2d..cfea004445 100644
--- a/aconversions/src/re2fa/AbstractREtoFAConverter.h
+++ b/aconversions/src/re2fa/AbstractREtoFAConverter.h
@@ -13,7 +13,7 @@ namespace conversions
 {
 
 /**
- * Abstract regular expression to finite automata converter.
+ * Interface for regular expression to finite automata conversion.
  */
 class AbstractREtoFAConverter : public Conversion
 {
@@ -24,22 +24,6 @@ public:
     virtual automaton::FSM convert( void ) = 0;
 
     virtual ~AbstractREtoFAConverter( void );
-
-protected:
-    /**
-     * @param re Source regular expression.
-     */
-    AbstractREtoFAConverter(const regexp::RegExp & re );
-
-    /**
-     * Source regular expression.
-     */
-    const regexp::RegExp m_re;
-
-    /**
-     * New automaton.
-     */
-    automaton::FSM m_fsm;
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/re2fa/Brzozowski.cpp b/aconversions/src/re2fa/Brzozowski.cpp
index 24415f7739..e6779762db 100644
--- a/aconversions/src/re2fa/Brzozowski.cpp
+++ b/aconversions/src/re2fa/Brzozowski.cpp
@@ -7,6 +7,7 @@
 
 #include "Brzozowski.h"
 
+using namespace std;
 using namespace alib;
 using namespace automaton;
 using namespace regexp;
@@ -14,7 +15,7 @@ using namespace regexp;
 namespace conversions
 {
 
-Brzozowski::Brzozowski( const RegExp & re ) : AbstractREtoFAConverter( re )
+Brzozowski::Brzozowski( const RegExp & re ) : m_re( re )
 {
 
 }
@@ -69,70 +70,42 @@ FSM Brzozowski::convert( void )
     // ------------------------------------------------------------------------
     // 3.
 
-    StateBuilder builder( Q );
+    FSM automaton;
+    int stateId = 0;
+    map<RegExp, State> stateMap;
 
     for( const auto & r : Q )
-        m_fsm.addState( builder.getState( r ) );
+    {
+        State q( toBase26( ++ stateId ) );
+        stateMap.insert( std::pair<RegExp,State>( r, q ) );
+        automaton.addState( q );
+    }
 
     for( const auto & a : alphabet )
-        m_fsm.addInputSymbol( a.getSymbol( ) );
+        automaton.addInputSymbol( a.getSymbol( ) );
 
     for( const auto & r : Q )
     {
         RegExpDerivation deriv( r );
 
-        for( const auto & a: m_fsm.getInputAlphabet( ) )
+        for( const auto & a: automaton.getInputAlphabet( ) )
         {
             RegExp derived = deriv.derivation( a );
             derived = opt.optimize( derived );
 
-            TransitionFSM t( builder.getState( r ), a, builder.getState( derived ) );
-            if( ! isInSet( t, m_fsm.getTransitions( ) ) )
-                m_fsm.addTransition( t );
+            TransitionFSM t( stateMap.find( r )->second, a, stateMap.find( derived )->second );
+            if( ! isInSet( t, automaton.getTransitions( ) ) )
+                automaton.addTransition( t );
         }
     }
 
-    m_fsm.addInitialState( builder.getState( V ) );
+    automaton.addInitialState( stateMap.find( V )->second );
 
     for( const auto & U : Q )
         if( U.containsEmptyString( ) )
-            m_fsm.addFinalState( builder.getState( U ) );
-
-    return m_fsm;
-}
-
-// ----------------------------------------------------------------------------
-
-Brzozowski::StateBuilder::StateBuilder( const set<RegExp> & Q )
-{
-    m_stateId = 0;
-
-    for( const auto & regexp : Q )
-        m_states.insert( pair<RegExp, State>( regexp, State( createNewName( ) ) ) );
-}
-
-const State & Brzozowski::StateBuilder::getState( const RegExp & re ) const
-{
-    auto state = m_states.find( re );
-    if( state != m_states.end() ) return state->second;
-
-    throw AlibException( "Brzozowski::StateBuilder - Regular expression not found!" );
-}
-
-string Brzozowski::StateBuilder::createNewName( void )
-{
-    // http://en.wikipedia.org/wiki/Hexavigesimal
-
-    unsigned int n = m_stateId ++;
-    string name;
-    do
-    {
-        unsigned int remainder = n % 26;
-        name += ( char )( remainder + 'A' );
-        n = (n - remainder) / 26;
-    } while (n > 0);
+            automaton.addFinalState( stateMap.find( U )->second );
 
-    return string( name.rbegin( ), name.rend( ) );
+    return automaton;
 }
 
 } /* namespace conversions */
diff --git a/aconversions/src/re2fa/Brzozowski.h b/aconversions/src/re2fa/Brzozowski.h
index c858dfb5c7..e145355cd7 100644
--- a/aconversions/src/re2fa/Brzozowski.h
+++ b/aconversions/src/re2fa/Brzozowski.h
@@ -10,15 +10,16 @@
 
 #include <map>
 #include <set>
+#include <string>
 #include <deque>
 
 #include <automaton/State.h>
 #include <AlibException.h>
 
 #include "AbstractREtoFAConverter.h"
+#include "../shared/Hexavigesimal.h"
 
 #include "RegExpDerivation.h"
-
 #include "RegExpOptimize.h"
 
 namespace conversions
@@ -46,37 +47,9 @@ public:
 
 private:
     /**
-     * Maps every regular expression to unique state of automata.
+     * input regexp
      */
-    class StateBuilder
-    {
-    public:
-        /**
-         * @param Q set of regular expressions.
-         */
-        StateBuilder( const std::set<regexp::RegExp> & Q );
-
-        /**
-         * Get automata state representing given regular expression.
-         *
-         * @param re Regular expression
-         * @return automata state representing given regular expression.
-         */
-        const automaton::State & getState( const regexp::RegExp & re ) const;
-
-    private:
-        /**
-         * Creates original state name.
-         */
-        std::string createNewName( void );
-
-        /**
-         * Map
-         */
-        std::map<const regexp::RegExp, automaton::State> m_states;
-
-        unsigned int m_stateId;
-    };
+    const regexp::RegExp & m_re;
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/re2fa/Glushkov.cpp b/aconversions/src/re2fa/Glushkov.cpp
index b3b3e6f9d5..9c86441c79 100644
--- a/aconversions/src/re2fa/Glushkov.cpp
+++ b/aconversions/src/re2fa/Glushkov.cpp
@@ -16,7 +16,7 @@ using namespace std;
 namespace conversions
 {
 
-Glushkov::Glushkov( const RegExp & re ) : AbstractREtoFAConverter( re )
+Glushkov::Glushkov( const RegExp & re ) : m_re( re )
 {
 
 }
@@ -28,9 +28,11 @@ Glushkov::~Glushkov( void )
 
 FSM Glushkov::convert( void )
 {
+    FSM automaton;
+
     // step 1
     for( auto const& symbol : m_re.getAlphabet( ) )
-        m_fsm.addInputSymbol( symbol.getSymbol( ) );
+        automaton.addInputSymbol( symbol.getSymbol( ) );
 
     // steps 2, 3, 4
     m_first = GlushkovTraversal::first( m_re );
@@ -46,14 +48,14 @@ FSM Glushkov::convert( void )
 
     // step 5
     State q0( "q0" );
-    m_fsm.addState( q0 );
-    m_fsm.addInitialState( q0 );
+    automaton.addState( q0 );
+    automaton.addInitialState( q0 );
     for( auto const& symbol : GlushkovTraversal::getSymbols( m_re ) )
     {
         State q( to_string( symbol.getId( ) ) );
 
         m_stateMap.insert( std::pair<GlushkovSymbol, State>( symbol, q ) );
-        m_fsm.addState( q );
+        automaton.addState( q );
     }
 
     // step 6
@@ -61,7 +63,7 @@ FSM Glushkov::convert( void )
     {
         State const& q = m_stateMap.find( symbol )->second;
 
-        m_fsm.addTransition( q0, symbol.getInputSymbol( ), q );
+        automaton.addTransition( q0, symbol.getInputSymbol( ), q );
     }
 
     for( auto const& pair : m_pairs )
@@ -69,20 +71,20 @@ FSM Glushkov::convert( void )
         State const& p = m_stateMap.find( pair.getFirst( ) )->second;
         State const& q = m_stateMap.find( pair.getSecond( ) )->second;
 
-        m_fsm.addTransition( p, pair.getSecond( ).getInputSymbol( ), q );
+        automaton.addTransition( p, pair.getSecond( ).getInputSymbol( ), q );
     }
 
     // step 7
     for( auto const& symbol : m_last )
     {
         State const & q = m_stateMap.find( symbol )->second;
-        m_fsm.addFinalState( q );
+        automaton.addFinalState( q );
     }
 
     if( m_re.containsEmptyString( ) )
-        m_fsm.addFinalState( q0 );
+        automaton.addFinalState( q0 );
 
-    return m_fsm;
+    return automaton;
 }
 
 } /* namespace conversions */
diff --git a/aconversions/src/re2fa/Glushkov.h b/aconversions/src/re2fa/Glushkov.h
index 1ce77e74a0..59faa884b4 100644
--- a/aconversions/src/re2fa/Glushkov.h
+++ b/aconversions/src/re2fa/Glushkov.h
@@ -47,6 +47,11 @@ private:
     std::set<GlushkovSymbol> m_first, m_last;
     std::set<GlushkovPair> m_pairs;
 
+    /**
+     * input regexp
+     */
+    const regexp::RegExp & m_re;
+
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/re2fa/Thompson.cpp b/aconversions/src/re2fa/Thompson.cpp
index e0e17d6cc1..c92832ec6e 100644
--- a/aconversions/src/re2fa/Thompson.cpp
+++ b/aconversions/src/re2fa/Thompson.cpp
@@ -13,7 +13,7 @@ using namespace regexp;
 namespace conversions
 {
 
-Thompson::Thompson( const RegExp & re ) : AbstractREtoFAConverter( re )
+Thompson::Thompson( const RegExp & re ) : m_re( re )
 {
 
 }
@@ -26,6 +26,8 @@ Thompson::~Thompson( void )
 
 FSM Thompson::convert( void )
 {
+    m_fsm = FSM( );
+
     for( const auto & symbol : m_re.getAlphabet( ) )
         m_fsm.addInputSymbol( symbol.getSymbol( ) );
 
diff --git a/aconversions/src/re2fa/Thompson.h b/aconversions/src/re2fa/Thompson.h
index 3ba43932c7..3e1455415f 100644
--- a/aconversions/src/re2fa/Thompson.h
+++ b/aconversions/src/re2fa/Thompson.h
@@ -44,6 +44,16 @@ public:
     automaton::FSM convert( void );
 
 private:
+    /**
+     * input regexp
+     */
+    const regexp::RegExp & m_re;
+
+    /**
+     * output FSM ($\varepsilon$--NFA)
+     */
+    automaton::FSM m_fsm;
+
     /**
      * Stores head and tail state of "subautomaton" created in regexp subtree.
      */
diff --git a/aconversions/src/re2rg/AbstractREtoRGConverter.cpp b/aconversions/src/re2rg/AbstractREtoRGConverter.cpp
index f561376cf3..1d5cff0f83 100644
--- a/aconversions/src/re2rg/AbstractREtoRGConverter.cpp
+++ b/aconversions/src/re2rg/AbstractREtoRGConverter.cpp
@@ -12,11 +12,6 @@ using namespace regexp;
 namespace conversions
 {
 
-AbstractREtoRGConverter::AbstractREtoRGConverter( const RegExp & re ) : m_re( re )
-{
-
-}
-
 AbstractREtoRGConverter::~AbstractREtoRGConverter( void )
 {
 
diff --git a/aconversions/src/re2rg/AbstractREtoRGConverter.h b/aconversions/src/re2rg/AbstractREtoRGConverter.h
index 86f6f8e32c..b18bb97152 100644
--- a/aconversions/src/re2rg/AbstractREtoRGConverter.h
+++ b/aconversions/src/re2rg/AbstractREtoRGConverter.h
@@ -17,23 +17,12 @@ namespace conversions
 {
 
 /**
- * Abstract regular expression to grammar converter.
+ * Interface for regular expression to regular grammar conversion.
  */
 class AbstractREtoRGConverter : public Conversion
 {
 public:
     virtual ~AbstractREtoRGConverter( void );
-
-protected:
-    /**
-     * @param re Source regular expression.
-     */
-    AbstractREtoRGConverter( const regexp::RegExp & re );
-
-    /**
-     * Source regular expression.
-     */
-    const regexp::RegExp m_re;
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/re2rg/re2rrg/AbstractREtoRRGConverter.cpp b/aconversions/src/re2rg/re2rrg/AbstractREtoRRGConverter.cpp
index 8011b86bf9..2012a5a800 100644
--- a/aconversions/src/re2rg/re2rrg/AbstractREtoRRGConverter.cpp
+++ b/aconversions/src/re2rg/re2rrg/AbstractREtoRRGConverter.cpp
@@ -12,11 +12,6 @@ using namespace regexp;
 namespace conversions
 {
 
-AbstractREtoRRGConverter::AbstractREtoRRGConverter( const RegExp & re ) : AbstractREtoRGConverter( re )
-{
-
-}
-
 AbstractREtoRRGConverter::~AbstractREtoRRGConverter( void )
 {
 
diff --git a/aconversions/src/re2rg/re2rrg/AbstractREtoRRGConverter.h b/aconversions/src/re2rg/re2rrg/AbstractREtoRRGConverter.h
index 4c2dd5e5d4..36cd9224f2 100644
--- a/aconversions/src/re2rg/re2rrg/AbstractREtoRRGConverter.h
+++ b/aconversions/src/re2rg/re2rrg/AbstractREtoRRGConverter.h
@@ -18,7 +18,7 @@ namespace conversions
 {
 
 /**
- * Abstract regular epxression to right regular grammar converter.
+ * Interface for regular epxression to right regular grammar conversion.
  */
 class AbstractREtoRRGConverter: public AbstractREtoRGConverter
 {
@@ -29,17 +29,6 @@ public:
      * @return right regular grammar equivalent to source regexp.
      */
     virtual grammar::RightRegularGrammar convert( void ) = 0;
-
-protected:
-    /**
-     * @param re Source regular expression.
-     */
-    AbstractREtoRRGConverter( const regexp::RegExp & re );
-
-    /**
-     * New right regular grammar.
-     */
-    grammar::RightRegularGrammar m_grammar;
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.cpp b/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.cpp
index 0797f640ce..8ba4a892b5 100644
--- a/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.cpp
+++ b/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.cpp
@@ -15,7 +15,7 @@ using namespace regexp;
 namespace conversions
 {
 
-BrzozowskiDerivationRRG::BrzozowskiDerivationRRG( const RegExp & regexp ) : AbstractREtoRRGConverter( regexp )
+BrzozowskiDerivationRRG::BrzozowskiDerivationRRG( const RegExp & re ) : m_re( re )
 {
 
 }
@@ -66,11 +66,18 @@ RightRegularGrammar BrzozowskiDerivationRRG::convert( void )
     }
 
     // 3.
+    RightRegularGrammar grammar;
+    map<RegExp, Symbol> nonterminalMap;
+    int nonterminalId = 0;
 
     for( const auto & s : alphabet )
-        m_grammar.addTerminalSymbol( s.getSymbol( ) );
+        grammar.addTerminalSymbol( s.getSymbol( ) );
 
-    NonTerminalBuilder builder( N, m_grammar );
+    for( const auto & r : N )
+    {
+        Symbol nt = grammar.createUniqueNonTerminalSymbol( toBase26( ++ nonterminalId ) );
+        nonterminalMap.insert( pair<RegExp, Symbol>( r, nt ) );
+    }
 
     for( const auto & r : N )
     {
@@ -81,86 +88,47 @@ RightRegularGrammar BrzozowskiDerivationRRG::convert( void )
             RegExp derived = deriv.derivation( a );
             derived = opt.optimize( derived );
 
-            list<Symbol> leftSide = { builder.getNonTerminal( r ) };
-            list<Symbol> rightSide = { a, builder.getNonTerminal( derived ) };
+            list<Symbol> leftSide = { nonterminalMap.find( r )->second };
+            list<Symbol> rightSide = { a, nonterminalMap.find( derived )->second };
 
             Rule r( leftSide, rightSide );
-            m_grammar.addRule( r );
+            grammar.addRule( r );
 
             if( derived.containsEmptyString( ) )
             {
                 list<Symbol> rightSide = { a };
                 Rule r( leftSide, rightSide );
-                m_grammar.addRule( r );
+                grammar.addRule( r );
             }
         }
     }
 
-    m_grammar.setStartSymbol( builder.getNonTerminal( V ) );
+    grammar.setStartSymbol( nonterminalMap.find( V )->second );
 
     if( V.containsEmptyString( ) )
     {
-        list<Symbol> leftSide = { builder.getNonTerminal( V ) };
+        list<Symbol> leftSide = { nonterminalMap.find( V )->second };
         list<Symbol> rightSide;
 
-        if( m_grammar.isNonTerminalOnRightSideOfAnyRule( m_grammar.getStartSymbol( ) ) )
+        if( grammar.isNonTerminalOnRightSideOfAnyRule( grammar.getStartSymbol( ) ) )
         {
-            Symbol newStart = m_grammar.createUniqueNonTerminalSymbol( m_grammar.getStartSymbol( ).getSymbol( ), false );
+            Symbol newStart = grammar.createUniqueNonTerminalSymbol( grammar.getStartSymbol( ).getSymbol( ), false );
 
             list<Symbol> leftSideNewStart = { newStart };
-            for( const auto & rule : m_grammar.getRules( ) )
-                if( rule.getLeftSide( ).front( ) == m_grammar.getStartSymbol( ) )
-                    m_grammar.addRule( Rule( leftSideNewStart, rule.getRightSide( ) ) );
+            for( const auto & rule : grammar.getRules( ) )
+                if( rule.getLeftSide( ).front( ) == grammar.getStartSymbol( ) )
+                    grammar.addRule( Rule( leftSideNewStart, rule.getRightSide( ) ) );
 
-            m_grammar.setStartSymbol( newStart );
-            m_grammar.addRule( Rule( leftSideNewStart, rightSide ) );
+            grammar.setStartSymbol( newStart );
+            grammar.addRule( Rule( leftSideNewStart, rightSide ) );
         }
         else
         {
-            m_grammar.addRule( Rule ( leftSide, rightSide ) );
+            grammar.addRule( Rule ( leftSide, rightSide ) );
         }
     }
 
-    return m_grammar;
-}
-
-// ----------------------------------------------------------------------------
-
-BrzozowskiDerivationRRG::NonTerminalBuilder::NonTerminalBuilder( const set<RegExp> & Q, RightRegularGrammar & grammar ) : m_grammar( grammar )
-{
-    m_nonTerminalId = 0;
-
-    for( const auto & regexp : Q )
-    {
-        const string nonTerminalName = createNewName( );
-        Symbol NT = m_grammar.createUniqueNonTerminalSymbol( nonTerminalName, false );
-
-        m_nonTerminals.insert( pair<RegExp, Symbol>( regexp, NT ) );
-    }
-}
-
-const Symbol & BrzozowskiDerivationRRG::NonTerminalBuilder::getNonTerminal( const RegExp & re ) const
-{
-    auto state = m_nonTerminals.find( re );
-    if( state != m_nonTerminals.end( ) ) return state->second;
-
-    throw AlibException( "BrzozowskiDerivationRRG::NonTerminalBuilder - Regular expression not found!" );
-}
-
-string BrzozowskiDerivationRRG::NonTerminalBuilder::createNewName( void )
-{
-    // http://en.wikipedia.org/wiki/Hexavigesimal
-
-    unsigned int n = m_nonTerminalId ++;
-    string name;
-    do
-    {
-        unsigned int remainder = n % 26;
-        name += ( char )( remainder + 'A' );
-        n = (n - remainder) / 26;
-    } while (n > 0);
-
-    return string( name.rbegin( ), name.rend( ) );
+    return grammar;
 }
 
 } /* namespace conversions */
diff --git a/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.h b/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.h
index 90182cf0cc..83f1218b68 100644
--- a/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.h
+++ b/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.h
@@ -17,6 +17,7 @@
 #include <regexp/RegExp.h>
 
 #include "AbstractREtoRRGConverter.h"
+#include "../../shared/Hexavigesimal.h"
 
 #include "RegExpOptimize.h"
 #include "RegExpDerivation.h"
@@ -45,18 +46,10 @@ public:
     grammar::RightRegularGrammar convert( void );
 
 protected:
-    class NonTerminalBuilder
-    {
-    public:
-        NonTerminalBuilder( const std::set<regexp::RegExp> & Q, grammar::RightRegularGrammar & grammar );
-        const alphabet::Symbol & getNonTerminal( const regexp::RegExp & re ) const;
-
-    private:
-        grammar::RightRegularGrammar & m_grammar;
-        std::map<const regexp::RegExp, alphabet::Symbol> m_nonTerminals;
-        std::string createNewName( void );
-        unsigned int m_nonTerminalId;
-    };
+    /*
+     * input regexp
+     */
+    const regexp::RegExp & m_re;
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/re2rg/re2rrg/GlushkovRRG.cpp b/aconversions/src/re2rg/re2rrg/GlushkovRRG.cpp
index 3973dd030d..e7dc539e77 100644
--- a/aconversions/src/re2rg/re2rrg/GlushkovRRG.cpp
+++ b/aconversions/src/re2rg/re2rrg/GlushkovRRG.cpp
@@ -16,7 +16,7 @@ using namespace std;
 namespace conversions
 {
 
-GlushkovRRG::GlushkovRRG( const RegExp & re ) : AbstractREtoRRGConverter( re )
+GlushkovRRG::GlushkovRRG( const RegExp & re ) : m_re( re )
 {
 
 }
@@ -28,9 +28,11 @@ GlushkovRRG::~GlushkovRRG( void )
 
 RightRegularGrammar GlushkovRRG::convert( void )
 {
+    RightRegularGrammar grammar;
+
     // step 1
     for( auto const& symbol : m_re.getAlphabet( ) )
-        m_grammar.addTerminalSymbol( symbol.getSymbol( ) );
+        grammar.addTerminalSymbol( symbol.getSymbol( ) );
 
     // steps 2, 3, 4
     m_first = GlushkovTraversal::first( m_re );
@@ -41,12 +43,12 @@ RightRegularGrammar GlushkovRRG::convert( void )
     // \e in q0 check is in step 7
 
     // step 5
-    Symbol S = m_grammar.createUniqueNonTerminalSymbol( "S" );
-    m_grammar.setStartSymbol( S );
+    Symbol S = grammar.createUniqueNonTerminalSymbol( "S" );
+    grammar.setStartSymbol( S );
 
     for( auto const& symbol : GlushkovTraversal::getSymbols( m_re ) )
     {
-        Symbol a = m_grammar.createUniqueNonTerminalSymbol( symbol.getInputSymbol( ).getSymbol( ) + to_string( symbol.getId( ) ) );
+        Symbol a = grammar.createUniqueNonTerminalSymbol( symbol.getInputSymbol( ).getSymbol( ) + to_string( symbol.getId( ) ) );
 
         m_symbolMap.insert( std::pair<GlushkovSymbol, Symbol>( symbol, a ) );
     }
@@ -58,7 +60,7 @@ RightRegularGrammar GlushkovRRG::convert( void )
 
         list<Symbol> leftSide = { S };
         list<Symbol> rightSide = { symbol.getInputSymbol( ), a };
-        m_grammar.addRule( Rule( leftSide, rightSide ) );
+        grammar.addRule( Rule( leftSide, rightSide ) );
     }
 
     for( auto const& pair : m_pairs )
@@ -69,7 +71,7 @@ RightRegularGrammar GlushkovRRG::convert( void )
         list<Symbol> leftSide = { a };
         list<Symbol> rightSide = { pair.getSecond( ).getInputSymbol( ), b };
 
-        m_grammar.addRule( Rule( leftSide, rightSide ) );
+        grammar.addRule( Rule( leftSide, rightSide ) );
     }
 
     // step 7
@@ -83,7 +85,7 @@ RightRegularGrammar GlushkovRRG::convert( void )
 
         Symbol const& a = m_symbolMap.find( symbol )->second;
 
-        for( auto const & rule : m_grammar.getRules( ) )
+        for( auto const & rule : grammar.getRules( ) )
         {
             if( isInList( a, rule.getRightSide( ) ) )
             {
@@ -91,8 +93,8 @@ RightRegularGrammar GlushkovRRG::convert( void )
                 list<Symbol> rightSide = { symbol.getInputSymbol( ) };
                 Rule r( leftSide, rightSide );
 
-                if( ! isInSet( r, m_grammar.getRules( ) ) )
-                    m_grammar.addRule( r );
+                if( ! isInSet( r, grammar.getRules( ) ) )
+                    grammar.addRule( r );
             }
         }
     }
@@ -101,10 +103,10 @@ RightRegularGrammar GlushkovRRG::convert( void )
     {
         list<Symbol> leftSide = { S };
         list<Symbol> rightSide = { };
-        m_grammar.addRule( Rule( leftSide, rightSide ) );
+        grammar.addRule( Rule( leftSide, rightSide ) );
     }
 
-    return m_grammar;
+    return grammar;
 }
 
 } /* namespace conversions */
diff --git a/aconversions/src/re2rg/re2rrg/GlushkovRRG.h b/aconversions/src/re2rg/re2rrg/GlushkovRRG.h
index c17d8751ba..e7e10807c7 100644
--- a/aconversions/src/re2rg/re2rrg/GlushkovRRG.h
+++ b/aconversions/src/re2rg/re2rrg/GlushkovRRG.h
@@ -43,6 +43,11 @@ private:
     std::map<GlushkovSymbol, alphabet::Symbol> m_symbolMap;
     std::set<GlushkovSymbol> m_first, m_last;
     std::set<GlushkovPair> m_pairs;
+
+    /*
+     * input regexp
+     */
+    const regexp::RegExp & m_re;
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/rg2fa/AbstractRGtoFAConverter.cpp b/aconversions/src/rg2fa/AbstractRGtoFAConverter.cpp
index c7439b614e..4dce814a34 100644
--- a/aconversions/src/rg2fa/AbstractRGtoFAConverter.cpp
+++ b/aconversions/src/rg2fa/AbstractRGtoFAConverter.cpp
@@ -3,11 +3,6 @@
 namespace conversions
 {
 
-AbstractRGtoFAConverter::AbstractRGtoFAConverter( void )
-{
-
-}
-
 AbstractRGtoFAConverter::~AbstractRGtoFAConverter( void )
 {
 
diff --git a/aconversions/src/rg2fa/AbstractRGtoFAConverter.h b/aconversions/src/rg2fa/AbstractRGtoFAConverter.h
index f4ed104590..6a93df1afd 100644
--- a/aconversions/src/rg2fa/AbstractRGtoFAConverter.h
+++ b/aconversions/src/rg2fa/AbstractRGtoFAConverter.h
@@ -11,7 +11,7 @@ namespace conversions
 {
 
 /**
- * Abstract regular grammar to finite state machine conversion.
+ * Interface for regular grammar to finite automaton conversion.
  */
 class AbstractRGtoFAConverter : public Conversion
 {
@@ -21,14 +21,6 @@ public:
      */
     virtual automaton::FSM convert( void ) = 0;
     virtual ~AbstractRGtoFAConverter( void );
-
-protected:
-    AbstractRGtoFAConverter( void );
-
-    /**
-     * New automaton.
-     */
-    automaton::FSM m_automaton;
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.cpp b/aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.cpp
deleted file mode 100644
index 3fe26c9770..0000000000
--- a/aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * AbstractLRGtoFAConverter.cpp
- *
- *  Created on: 16. 3. 2014
- *      Author: tomas
- */
-
-#include "AbstractLRGtoFAConverter.h"
-
-using namespace grammar;
-
-namespace conversions
-{
-
-AbstractLRGtoFAConverter::AbstractLRGtoFAConverter( const LeftRegularGrammar & lrg ) : m_grammar( lrg )
-{
-
-}
-
-AbstractLRGtoFAConverter::~AbstractLRGtoFAConverter( void )
-{
-
-}
-
-} /* namespace conversions */
diff --git a/aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.h b/aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.h
deleted file mode 100644
index 8e1448ff79..0000000000
--- a/aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.h
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- * AbstractLRGtoFAConverter.h
- *
- *  Created on: 16. 3. 2014
- *      Author: tomas
- */
-
-#ifndef ABSTRACTLRGTOFACONVERTER_H_
-#define ABSTRACTLRGTOFACONVERTER_H_
-
-#include <grammar/Regular/LeftRegularGrammar.h>
-
-#include "../AbstractRGtoFAConverter.h"
-
-namespace conversions
-{
-
-/**
- * Abstract left regular grammar to finite automata conversion.
- */
-class AbstractLRGtoFAConverter: public AbstractRGtoFAConverter
-{
-public:
-    ~AbstractLRGtoFAConverter( void );
-
-protected:
-    /**
-     * @param Source left regular grammar.
-     */
-    AbstractLRGtoFAConverter( const grammar::LeftRegularGrammar & lrg );
-
-    /**
-     * Source grammar.
-     */
-    const grammar::LeftRegularGrammar m_grammar;
-
-};
-
-} /* namespace conversions */
-
-#endif /* ABSTRACTLRGTOFACONVERTER_H_ */
diff --git a/aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.cpp b/aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.cpp
index 81650e2418..dd06004fcb 100644
--- a/aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.cpp
+++ b/aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.cpp
@@ -7,9 +7,9 @@ using namespace grammar;
 namespace conversions
 {
 
-LRGtoFAConverter::LRGtoFAConverter( const LeftRegularGrammar & grammar ) : AbstractLRGtoFAConverter( grammar )
+LRGtoFAConverter::LRGtoFAConverter( const LeftRegularGrammar & grammar ) : m_grammar( grammar )
 {
-    //TODO: if is not LRG throw Exception
+
 }
 
 LRGtoFAConverter::~LRGtoFAConverter( void )
@@ -19,13 +19,15 @@ LRGtoFAConverter::~LRGtoFAConverter( void )
 
 FSM LRGtoFAConverter::convert( void )
 {
+    FSM automaton;
+
     for( const auto & symbol : m_grammar.getTerminalSymbols( ) )
-        m_automaton.addInputSymbol( symbol );
+        automaton.addInputSymbol( symbol );
 
     for( const auto & symbol : m_grammar.getNonTerminalSymbols( ) )
-        m_automaton.addState( State( symbol.getSymbol( ) ) );
+        automaton.addState( State( symbol.getSymbol( ) ) );
 
-    const State & startState = m_automaton.createUniqueState( "q0", true );
+    const State & startState = automaton.createUniqueState( "q0", true );
 
     // step 3, constructing \delta
     for( const auto & rule : m_grammar.getRules( ) )
@@ -39,7 +41,7 @@ FSM LRGtoFAConverter::convert( void )
         if( rule.getRightSide( ).size( ) == 1 )
         {
             const Symbol & input( rule.getRightSide( ).front( ).getSymbol( ) );
-            m_automaton.addTransition( startState, input, current );
+            automaton.addTransition( startState, input, current );
         }
         // if B->Ca => \delta(C,a)=B
         else if( rule.getRightSide( ).size( ) == 2 )
@@ -47,20 +49,20 @@ FSM LRGtoFAConverter::convert( void )
             State next( rule.getRightSide( ).front( ).getSymbol( ) );
             const Symbol & input = rule.getRightSide( ).back( );
 
-            m_automaton.addTransition( next, input, current );
+            automaton.addTransition( next, input, current );
         }
     }
 
     // step 4
-    m_automaton.addInitialState( startState );
+    automaton.addInitialState( startState );
 
     // step 5
-    m_automaton.addFinalState( State( m_grammar.getStartSymbol().getSymbol() ) );
+    automaton.addFinalState( State( m_grammar.getStartSymbol().getSymbol() ) );
     for( const auto & rule : m_grammar.getRules( ) )
         if( m_grammar.isEpsilonRule( rule ) )
-            m_automaton.addFinalState( startState );
+            automaton.addFinalState( startState );
 
-    return m_automaton;
+    return automaton;
 }
 
 } /* namespace conversions */
diff --git a/aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.h b/aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.h
index 28ff087a46..19f42c8905 100644
--- a/aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.h
+++ b/aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.h
@@ -1,7 +1,10 @@
 #ifndef __LRGTOFACONVERTER_H__
 #define __LRGTOFACONVERTER_H__
 
-#include "AbstractLRGtoFAConverter.h"
+#include <grammar/Regular/LeftRegularGrammar.h>
+#include <automaton/FSM/FSM.h>
+
+#include "../AbstractRGtoFAConverter.h"
 
 namespace conversions
 {
@@ -10,7 +13,7 @@ namespace conversions
  * Converts left regular grammar to finite automata.
  * Source: Melichar 2.102.
  */
-class LRGtoFAConverter : public AbstractLRGtoFAConverter
+class LRGtoFAConverter : public AbstractRGtoFAConverter
 {
 public:
     /**
@@ -25,6 +28,12 @@ public:
      * @return FSM equivalent to source grammar.
      */
     automaton::FSM convert( void );
+
+private:
+    /**
+     * input grammar
+     */
+    const grammar::LeftRegularGrammar & m_grammar;
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.cpp b/aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.cpp
deleted file mode 100644
index c67474eb50..0000000000
--- a/aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * AbstractRRGtoFAConverter.cpp
- *
- *  Created on: 16. 3. 2014
- *      Author: tomas
- */
-
-#include "AbstractRRGtoFAConverter.h"
-
-using namespace grammar;
-
-namespace conversions
-{
-
-AbstractRRGtoFAConverter::AbstractRRGtoFAConverter( const RightRegularGrammar & rrg ) : m_grammar( rrg )
-{
-
-}
-
-AbstractRRGtoFAConverter::~AbstractRRGtoFAConverter()
-{
-
-}
-
-} /* namespace conversions */
diff --git a/aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.h b/aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.h
deleted file mode 100644
index 7704aa6f72..0000000000
--- a/aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- * AbstractRRGtoFAConverter.h
- *
- *  Created on: 16. 3. 2014
- *      Author: tomas
- */
-
-#ifndef ABSTRACTRRGTOFACONVERTER_H_
-#define ABSTRACTRRGTOFACONVERTER_H_
-
-#include <grammar/Regular/RightRegularGrammar.h>
-
-#include "../AbstractRGtoFAConverter.h"
-
-namespace conversions
-{
-
-/**
- * Abstract right regular grammar to finite automata conversion.
- */
-class AbstractRRGtoFAConverter: public AbstractRGtoFAConverter
-{
-public:
-    virtual ~AbstractRRGtoFAConverter( void );
-
-protected:
-    /**
-     * @param rrg Source right regular grammar.
-     */
-    AbstractRRGtoFAConverter( const grammar::RightRegularGrammar & rrg );
-
-    /**
-     * Source grammar.
-     */
-    const grammar::RightRegularGrammar m_grammar;
-};
-
-} /* namespace conversions */
-
-#endif /* ABSTRACTRRGTOFACONVERTER_H_ */
diff --git a/aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.cpp b/aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.cpp
index 30e6ee74ed..ea121d2fdb 100644
--- a/aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.cpp
+++ b/aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.cpp
@@ -7,9 +7,9 @@ using namespace grammar;
 namespace conversions
 {
 
-RRGtoFAConverter::RRGtoFAConverter( const RightRegularGrammar & grammar ) : AbstractRRGtoFAConverter( grammar )
+RRGtoFAConverter::RRGtoFAConverter( const RightRegularGrammar & grammar ) : m_grammar( grammar )
 {
-    //TODO: if is not RRG throw Exception
+
 }
 
 RRGtoFAConverter::~RRGtoFAConverter( void )
@@ -20,13 +20,15 @@ RRGtoFAConverter::~RRGtoFAConverter( void )
 
 FSM RRGtoFAConverter::convert( void )
 {
+    FSM automaton;
+
     for( const auto & symbol : m_grammar.getTerminalSymbols( ) )
-        m_automaton.addInputSymbol( symbol );
+        automaton.addInputSymbol( symbol );
 
     for( const auto & symbol : m_grammar.getNonTerminalSymbols( ) )
-        m_automaton.addState( State( symbol.getSymbol( ) ) );
+        automaton.addState( State( symbol.getSymbol( ) ) );
 
-    const State & AState = m_automaton.createUniqueState( "A", true );
+    const State & AState = automaton.createUniqueState( "A", true );
 
     for( const auto & rule : m_grammar.getRules( ) )
     {
@@ -38,27 +40,27 @@ FSM RRGtoFAConverter::convert( void )
         if( rule.getRightSide( ).size( ) == 1 ) // if B->a => \delta(B,a)=AState
         {
             const Symbol & input( rule.getRightSide( ).front( ).getSymbol( ) );
-            m_automaton.addTransition( current, input, AState );
+            automaton.addTransition( current, input, AState );
         }
         else if( rule.getRightSide( ).size( ) == 2 ) // if B->aC => \delta(B,a)=C
         {
             const Symbol & input = rule.getRightSide( ).front( );
             State next( rule.getRightSide( ).back( ).getSymbol( ) );
 
-            m_automaton.addTransition( current, input, next );
+            automaton.addTransition( current, input, next );
         }
     }
 
     // step 4
-    m_automaton.addInitialState( m_grammar.getStartSymbol().getSymbol() );
+    automaton.addInitialState( m_grammar.getStartSymbol().getSymbol() );
 
     // step 5
-    m_automaton.addFinalState( AState );
+    automaton.addFinalState( AState );
     for( const auto & rule : m_grammar.getRules( ) )
         if( m_grammar.isEpsilonRule( rule ) )
-            m_automaton.addFinalState( State( m_grammar.getStartSymbol( ).getSymbol( ) ) );
+            automaton.addFinalState( State( m_grammar.getStartSymbol( ).getSymbol( ) ) );
 
-    return m_automaton;
+    return automaton;
 }
 
 } /* namespace conversions */
diff --git a/aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.h b/aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.h
index 0eae2d9658..854790c761 100644
--- a/aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.h
+++ b/aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.h
@@ -1,7 +1,10 @@
 #ifndef __RRGTOFACONVERTER_H__
 #define __RRGTOFACONVERTER_H__
 
-#include "AbstractRRGtoFAConverter.h"
+#include <grammar/Regular/RightRegularGrammar.h>
+#include <automaton/FSM/FSM.h>
+
+#include "../AbstractRGtoFAConverter.h"
 
 namespace conversions
 {
@@ -10,7 +13,7 @@ namespace conversions
  * Converts left regular grammar to finite automata.
  * Source: Melichar 2.98
  */
-class RRGtoFAConverter : public AbstractRRGtoFAConverter
+class RRGtoFAConverter : public AbstractRGtoFAConverter
 {
 public:
     /**
@@ -25,6 +28,12 @@ public:
      * @return FSM equivalent to source grammar.
      */
     automaton::FSM convert( void );
+
+private:
+    /**
+     * input grammar
+     */
+    const grammar::RightRegularGrammar & m_grammar;
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/rg2re/AbstractRGtoREConverter.cpp b/aconversions/src/rg2re/AbstractRGtoREConverter.cpp
index 60bae347d1..d6df0214fa 100644
--- a/aconversions/src/rg2re/AbstractRGtoREConverter.cpp
+++ b/aconversions/src/rg2re/AbstractRGtoREConverter.cpp
@@ -10,11 +10,6 @@
 namespace conversions
 {
 
-AbstractRGtoREConverter::AbstractRGtoREConverter( void )
-{
-
-}
-
 AbstractRGtoREConverter::~AbstractRGtoREConverter( void )
 {
 
diff --git a/aconversions/src/rg2re/AbstractRGtoREConverter.h b/aconversions/src/rg2re/AbstractRGtoREConverter.h
index afc7790257..bfc2ea1310 100644
--- a/aconversions/src/rg2re/AbstractRGtoREConverter.h
+++ b/aconversions/src/rg2re/AbstractRGtoREConverter.h
@@ -16,7 +16,7 @@ namespace conversions
 {
 
 /**
- * Abstract regular grammar to regular expression conversion.
+ * Interface for regular grammar to regular expression conversion.
  */
 class AbstractRGtoREConverter : public Conversion
 {
@@ -27,14 +27,6 @@ public:
     virtual regexp::RegExp convert( void ) = 0;
 
     virtual ~AbstractRGtoREConverter( void );
-
-protected:
-    AbstractRGtoREConverter( void );
-
-    /**
-     * New regular expression.
-     */
-    regexp::RegExp m_re;
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.cpp b/aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.cpp
deleted file mode 100644
index 10e34c2d20..0000000000
--- a/aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * AbstractLRGtoREConverter.cpp
- *
- *  Created on: 16. 3. 2014
- *      Author: tomas
- */
-
-#include "AbstractLRGtoREConverter.h"
-
-using namespace grammar;
-
-namespace conversions
-{
-
-AbstractLRGtoREConverter::AbstractLRGtoREConverter( const LeftRegularGrammar & lrg ) : m_grammar( lrg )
-{
-
-}
-
-AbstractLRGtoREConverter::~AbstractLRGtoREConverter( void )
-{
-
-}
-
-} /* namespace conversions */
diff --git a/aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.h b/aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.h
deleted file mode 100644
index f753cd70bd..0000000000
--- a/aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * AbstractLRGtoREConverter.h
- *
- *  Created on: 16. 3. 2014
- *      Author: tomas
- */
-
-#ifndef ABSTRACTLRGTORECONVERTER_H_
-#define ABSTRACTLRGTORECONVERTER_H_
-
-#include <grammar/Regular/LeftRegularGrammar.h>
-
-#include "../AbstractRGtoREConverter.h"
-
-namespace conversions
-{
-
-class AbstractLRGtoREConverter: public AbstractRGtoREConverter
-{
-public:
-    virtual ~AbstractLRGtoREConverter( void );
-
-protected:
-    /**
-     * @param lrg source left reg. grammar.
-     */
-    AbstractLRGtoREConverter( const grammar::LeftRegularGrammar & lrg );
-
-    /**
-     * source left reg. grammar.
-     */
-    const grammar::LeftRegularGrammar m_grammar;
-};
-
-} /* namespace conversions */
-
-#endif /* ABSTRACTLRGTORECONVERTER_H_ */
diff --git a/aconversions/src/rg2re/lrg2re/LRGAlgebraic.cpp b/aconversions/src/rg2re/lrg2re/LRGAlgebraic.cpp
index d7036f06c3..b4fed3c3e3 100644
--- a/aconversions/src/rg2re/lrg2re/LRGAlgebraic.cpp
+++ b/aconversions/src/rg2re/lrg2re/LRGAlgebraic.cpp
@@ -14,7 +14,7 @@ using namespace regexp;
 namespace conversions
 {
 
-LRGAlgebraic::LRGAlgebraic( const LeftRegularGrammar & rg ) : AbstractLRGtoREConverter( rg )
+LRGAlgebraic::LRGAlgebraic( const LeftRegularGrammar & lrg ) : m_grammar( lrg )
 {
 
 }
@@ -26,30 +26,32 @@ LRGAlgebraic::~LRGAlgebraic( void )
 
 RegExp LRGAlgebraic::convert( void )
 {
+    LeftRegularEquationSolver solver;
+
     for( const auto & symb : m_grammar.getNonTerminalSymbols( ) )
-        m_solver.addSymbol( symb );
+        solver.addSymbol( symb );
 
     for( const auto & rule : m_grammar.getRules( ) )
     {
         const Symbol & leftSide = rule.getLeftSide( ).front( );
         if( rule.getRightSide( ).size( ) == 0 )
         {
-            m_solver.addEquation( leftSide, new RegExpEpsilon( ) );
+            solver.addEquation( leftSide, new RegExpEpsilon( ) );
         }
         else if( rule.getRightSide( ).size( ) == 1 )
         {
             const Symbol & input = rule.getRightSide( ).front( );
-            m_solver.addEquation( leftSide, new RegExpSymbol( input.getSymbol( ) ) );
+            solver.addEquation( leftSide, new RegExpSymbol( input.getSymbol( ) ) );
         }
         else
         {
             const Symbol nt = rule.getRightSide( ).front( );
             const Symbol input = rule.getRightSide( ).back( );
-            m_solver.addEquation( leftSide, nt, new RegExpSymbol( input.getSymbol( ) ) );
+            solver.addEquation( leftSide, nt, new RegExpSymbol( input.getSymbol( ) ) );
         }
     }
 
-    return m_solver.solve( m_grammar.getStartSymbol( ) );
+    return solver.solve( m_grammar.getStartSymbol( ) );
 }
 
 } /* namespace conversions */
diff --git a/aconversions/src/rg2re/lrg2re/LRGAlgebraic.h b/aconversions/src/rg2re/lrg2re/LRGAlgebraic.h
index ac9b41835f..53e0625151 100644
--- a/aconversions/src/rg2re/lrg2re/LRGAlgebraic.h
+++ b/aconversions/src/rg2re/lrg2re/LRGAlgebraic.h
@@ -8,13 +8,16 @@
 #ifndef LRGALGEBRAIC_H_
 #define LRGALGEBRAIC_H_
 
+#include <grammar/Regular/LeftRegularGrammar.h>
+#include <regexp/RegExp.h>
+
 #include "../../shared/equations/LeftRegularEquationSolver.h"
-#include "AbstractLRGtoREConverter.h"
+#include "../AbstractRGtoREConverter.h"
 
 namespace conversions
 {
 
-class LRGAlgebraic: public AbstractLRGtoREConverter
+class LRGAlgebraic: public AbstractRGtoREConverter
 {
 public:
     /**
@@ -31,9 +34,9 @@ public:
 
 protected:
     /**
-     * Equation solver.
+     * input grammar
      */
-    LeftRegularEquationSolver m_solver;
+    const grammar::LeftRegularGrammar & m_grammar;
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.cpp b/aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.cpp
deleted file mode 100644
index 0a3c41ad10..0000000000
--- a/aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * AbstractRRGtoREConverter.cpp
- *
- *  Created on: 16. 3. 2014
- *      Author: tomas
- */
-
-#include "AbstractRRGtoREConverter.h"
-
-using namespace grammar;
-
-namespace conversions
-{
-
-AbstractRRGtoREConverter::AbstractRRGtoREConverter( const RightRegularGrammar & rrg ) : m_grammar( rrg )
-{
-
-}
-
-AbstractRRGtoREConverter::~AbstractRRGtoREConverter( void )
-{
-
-}
-
-} /* namespace conversions */
diff --git a/aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.h b/aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.h
deleted file mode 100644
index ce21d1c6fd..0000000000
--- a/aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/*
- * AbstractRRGtoREConverter.h
- *
- *  Created on: 16. 3. 2014
- *      Author: tomas
- */
-
-#ifndef ABSTRACTRRGTORECONVERTER_H_
-#define ABSTRACTRRGTORECONVERTER_H_
-
-#include <grammar/Regular/RightRegularGrammar.h>
-
-#include "../AbstractRGtoREConverter.h"
-
-namespace conversions
-{
-
-class AbstractRRGtoREConverter: public AbstractRGtoREConverter
-{
-public:
-    virtual ~AbstractRRGtoREConverter( void );
-
-protected:
-    /**
-     * @param rrg Source right regular grammar.
-     */
-    AbstractRRGtoREConverter( const grammar::RightRegularGrammar & rrg );
-
-    /**
-     * Source left regular grammar.
-     */
-    const grammar::RightRegularGrammar m_grammar;
-};
-
-} /* namespace conversions */
-
-#endif /* ABSTRACTRRGTORECONVERTER_H_ */
diff --git a/aconversions/src/rg2re/rrg2re/RRGAlgebraic.cpp b/aconversions/src/rg2re/rrg2re/RRGAlgebraic.cpp
index 71c92816fe..a1060197ca 100644
--- a/aconversions/src/rg2re/rrg2re/RRGAlgebraic.cpp
+++ b/aconversions/src/rg2re/rrg2re/RRGAlgebraic.cpp
@@ -14,7 +14,7 @@ using namespace regexp;
 namespace conversions
 {
 
-RRGAlgebraic::RRGAlgebraic( const RightRegularGrammar & rg ) : AbstractRRGtoREConverter( rg )
+RRGAlgebraic::RRGAlgebraic( const RightRegularGrammar & rrg ) : m_grammar( rrg )
 {
 
 }
@@ -26,30 +26,32 @@ RRGAlgebraic::~RRGAlgebraic( void )
 
 RegExp RRGAlgebraic::convert( void )
 {
+    RightRegularEquationSolver solver;
+
     for( const auto & symb : m_grammar.getNonTerminalSymbols( ) )
-        m_solver.addSymbol( symb );
+        solver.addSymbol( symb );
 
     for( const auto & rule : m_grammar.getRules( ) )
     {
         const Symbol & leftSide = rule.getLeftSide( ).front( );
         if( rule.getRightSide( ).size( ) == 0 )
         {
-            m_solver.addEquation( leftSide, new RegExpEpsilon( ) );
+            solver.addEquation( leftSide, new RegExpEpsilon( ) );
         }
         else if( rule.getRightSide( ).size( ) == 1 )
         {
             const Symbol & input = rule.getRightSide( ).front( );
-            m_solver.addEquation( leftSide, new RegExpSymbol( input.getSymbol( ) ) );
+            solver.addEquation( leftSide, new RegExpSymbol( input.getSymbol( ) ) );
         }
         else
         {
             const Symbol input = rule.getRightSide( ).front( );
             const Symbol nt = rule.getRightSide( ).back( );
-            m_solver.addEquation( leftSide, nt, new RegExpSymbol( input.getSymbol( ) ) );
+            solver.addEquation( leftSide, nt, new RegExpSymbol( input.getSymbol( ) ) );
         }
     }
 
-    return m_solver.solve( m_grammar.getStartSymbol( ) );
+    return solver.solve( m_grammar.getStartSymbol( ) );
 }
 
 } /* namespace conversions */
diff --git a/aconversions/src/rg2re/rrg2re/RRGAlgebraic.h b/aconversions/src/rg2re/rrg2re/RRGAlgebraic.h
index dd9d8ea1a2..cb40fea3e4 100644
--- a/aconversions/src/rg2re/rrg2re/RRGAlgebraic.h
+++ b/aconversions/src/rg2re/rrg2re/RRGAlgebraic.h
@@ -8,13 +8,16 @@
 #ifndef RRGALGEBRAIC_H_
 #define RRGALGEBRAIC_H_
 
+#include <grammar/Regular/RightRegularGrammar.h>
+#include <regexp/RegExp.h>
+
 #include "../../shared/equations/RightRegularEquationSolver.h"
-#include "AbstractRRGtoREConverter.h"
+#include "../AbstractRGtoREConverter.h"
 
 namespace conversions
 {
 
-class RRGAlgebraic: public AbstractRRGtoREConverter
+class RRGAlgebraic: public AbstractRGtoREConverter
 {
 public:
     /**
@@ -31,9 +34,9 @@ public:
 
 protected:
     /**
-     * Equation solver.
+     * input grammar
      */
-    RightRegularEquationSolver m_solver;
+    const grammar::RightRegularGrammar & m_grammar;
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/rg2rg/lrg2rrg/AbstractLRGtoRRGConverter.cpp b/aconversions/src/rg2rg/lrg2rrg/AbstractLRGtoRRGConverter.cpp
index 210887b68a..212a0b1e22 100644
--- a/aconversions/src/rg2rg/lrg2rrg/AbstractLRGtoRRGConverter.cpp
+++ b/aconversions/src/rg2rg/lrg2rrg/AbstractLRGtoRRGConverter.cpp
@@ -12,11 +12,6 @@ using namespace grammar;
 namespace conversions
 {
 
-AbstractLRGtoRRGConverter::AbstractLRGtoRRGConverter( const LeftRegularGrammar & lrg ) : m_lrg( lrg )
-{
-
-}
-
 AbstractLRGtoRRGConverter::~AbstractLRGtoRRGConverter( void )
 {
 
diff --git a/aconversions/src/rg2rg/lrg2rrg/AbstractLRGtoRRGConverter.h b/aconversions/src/rg2rg/lrg2rrg/AbstractLRGtoRRGConverter.h
index 9a5a3064b6..bcbbe93676 100644
--- a/aconversions/src/rg2rg/lrg2rrg/AbstractLRGtoRRGConverter.h
+++ b/aconversions/src/rg2rg/lrg2rrg/AbstractLRGtoRRGConverter.h
@@ -28,22 +28,6 @@ public:
      * @return right regular grammar which is equivalent to source left regular grammar.
      */
     virtual grammar::RightRegularGrammar convert( void ) = 0;
-
-protected:
-    /**
-     * @param lrg Original left regular grammar.
-     */
-    AbstractLRGtoRRGConverter( const grammar::LeftRegularGrammar & lrg );
-
-    /**
-     * Original left regular grammar.
-     */
-    const grammar::LeftRegularGrammar m_lrg;
-
-    /**
-     * New right regular grammar.
-     */
-    grammar::RightRegularGrammar m_rrg;
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/rg2rg/lrg2rrg/LeftToRightRegularGrammar.cpp b/aconversions/src/rg2rg/lrg2rrg/LeftToRightRegularGrammar.cpp
index 80d5559eb2..755cf1ba54 100644
--- a/aconversions/src/rg2rg/lrg2rrg/LeftToRightRegularGrammar.cpp
+++ b/aconversions/src/rg2rg/lrg2rrg/LeftToRightRegularGrammar.cpp
@@ -14,7 +14,7 @@ using namespace std;
 namespace conversions
 {
 
-LeftToRightRegularGrammar::LeftToRightRegularGrammar( const grammar::LeftRegularGrammar & lrg ) : AbstractLRGtoRRGConverter( lrg )
+LeftToRightRegularGrammar::LeftToRightRegularGrammar( const grammar::LeftRegularGrammar & lrg ) : m_lrg( lrg )
 {
 
 }
@@ -26,15 +26,17 @@ LeftToRightRegularGrammar::~LeftToRightRegularGrammar( void )
 
 RightRegularGrammar LeftToRightRegularGrammar::convert( void )
 {
+    RightRegularGrammar rrg;
+
     for( const auto & symbol : m_lrg.getNonTerminalSymbols( ) )
-        m_rrg.addNonTerminalSymbol( symbol );
+        rrg.addNonTerminalSymbol( symbol );
 
     for( const auto & symbol : m_lrg.getTerminalSymbols( ) )
-        m_rrg.addTerminalSymbol( symbol );
+        rrg.addTerminalSymbol( symbol );
 
     // 1.
-    Symbol s = m_rrg.createUniqueNonTerminalSymbol( m_lrg.getStartSymbol( ).getSymbol( ), false );
-    m_rrg.setStartSymbol( s );
+    Symbol s = rrg.createUniqueNonTerminalSymbol( m_lrg.getStartSymbol( ).getSymbol( ), false );
+    rrg.setStartSymbol( s );
 
     // 2.
     for( const auto & rule : m_lrg.getRules( ) )
@@ -43,38 +45,38 @@ RightRegularGrammar LeftToRightRegularGrammar::convert( void )
         {
             list<Symbol> leftSide = { rule.getRightSide( ).front( ) };
             list<Symbol> rightSide = { rule.getRightSide( ).back( ), rule.getLeftSide( ).front( ) };
-            m_rrg.addRule( Rule( leftSide, rightSide ) );
+            rrg.addRule( Rule( leftSide, rightSide ) );
 
             if( rule.getLeftSide( ).front( ) == m_lrg.getStartSymbol( ) )
             {
                 list<Symbol> leftSide = { rule.getRightSide( ).front( ) };
                 list<Symbol> rightSide = { rule.getRightSide( ).back( ) };
-                m_rrg.addRule( Rule( leftSide, rightSide ) );
+                rrg.addRule( Rule( leftSide, rightSide ) );
             }
         }
         else if( rule.getRightSide( ).size( ) == 1 )
         {
-            list<Symbol> leftSide = { m_rrg.getStartSymbol( ) };
+            list<Symbol> leftSide = { rrg.getStartSymbol( ) };
             list<Symbol> rightSide = { rule.getRightSide( ).front( ), rule.getLeftSide( ).front( ) };
-            m_rrg.addRule( Rule( leftSide, rightSide ) );
+            rrg.addRule( Rule( leftSide, rightSide ) );
 
             if( rule.getLeftSide( ).front( ) == m_lrg.getStartSymbol( ) )
             {
-                list<Symbol> leftSide = { m_rrg.getStartSymbol( ) };
+                list<Symbol> leftSide = { rrg.getStartSymbol( ) };
                 list<Symbol> rightSide = { rule.getRightSide( ).front( ) };
-                m_rrg.addRule( Rule( leftSide, rightSide ) );
+                rrg.addRule( Rule( leftSide, rightSide ) );
             }
         }
         else
         {
             // assert leftSide == rrg.getStartSymbol( )
-            list<Symbol> leftSide = { m_rrg.getStartSymbol( ) };
+            list<Symbol> leftSide = { rrg.getStartSymbol( ) };
             list<Symbol> rightSide;
-            m_rrg.addRule( Rule( leftSide, rightSide) );
+            rrg.addRule( Rule( leftSide, rightSide) );
         }
     }
 
-    return m_rrg;
+    return rrg;
 }
 
 } /* namespace conversions */
diff --git a/aconversions/src/rg2rg/lrg2rrg/LeftToRightRegularGrammar.h b/aconversions/src/rg2rg/lrg2rrg/LeftToRightRegularGrammar.h
index 6feae684b9..8e65008481 100644
--- a/aconversions/src/rg2rg/lrg2rrg/LeftToRightRegularGrammar.h
+++ b/aconversions/src/rg2rg/lrg2rrg/LeftToRightRegularGrammar.h
@@ -28,6 +28,12 @@ public:
      * @return right regular grammar which is equivalent to source left regular grammar.
      */
     grammar::RightRegularGrammar convert( void );
+
+protected:
+    /**
+     * input grammar
+     */
+    const grammar::LeftRegularGrammar & m_lrg;
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/rg2rg/rrg2lrg/AbstractRRGtoLRGConverter.cpp b/aconversions/src/rg2rg/rrg2lrg/AbstractRRGtoLRGConverter.cpp
index 79857d39b0..c904f0c912 100644
--- a/aconversions/src/rg2rg/rrg2lrg/AbstractRRGtoLRGConverter.cpp
+++ b/aconversions/src/rg2rg/rrg2lrg/AbstractRRGtoLRGConverter.cpp
@@ -12,11 +12,6 @@ using namespace grammar;
 namespace conversions
 {
 
-AbstractRRGtoLRGConverter::AbstractRRGtoLRGConverter( const RightRegularGrammar & rrg ) : m_rrg( rrg )
-{
-
-}
-
 AbstractRRGtoLRGConverter::~AbstractRRGtoLRGConverter( void )
 {
 
diff --git a/aconversions/src/rg2rg/rrg2lrg/AbstractRRGtoLRGConverter.h b/aconversions/src/rg2rg/rrg2lrg/AbstractRRGtoLRGConverter.h
index 5cb8e7b38c..ce556b3086 100644
--- a/aconversions/src/rg2rg/rrg2lrg/AbstractRRGtoLRGConverter.h
+++ b/aconversions/src/rg2rg/rrg2lrg/AbstractRRGtoLRGConverter.h
@@ -28,22 +28,6 @@ public:
      * @return left regular grammar which is equivalent to source right regular grammar.
      */
     virtual grammar::LeftRegularGrammar convert( void ) = 0;
-
-protected:
-    /**
-     * @param rrg Source right regular grammar.
-     */
-    AbstractRRGtoLRGConverter( const grammar::RightRegularGrammar & rrg );
-
-    /**
-     * Source right regular grammar.
-     */
-    const grammar::RightRegularGrammar m_rrg;
-
-    /**
-     * New left regular grammar.
-     */
-    grammar::LeftRegularGrammar m_lrg;
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/rg2rg/rrg2lrg/RightToLeftRegularGrammar.cpp b/aconversions/src/rg2rg/rrg2lrg/RightToLeftRegularGrammar.cpp
index 3549005164..e90b736c45 100644
--- a/aconversions/src/rg2rg/rrg2lrg/RightToLeftRegularGrammar.cpp
+++ b/aconversions/src/rg2rg/rrg2lrg/RightToLeftRegularGrammar.cpp
@@ -14,7 +14,7 @@ using namespace std;
 namespace conversions
 {
 
-RightToLeftRegularGrammar::RightToLeftRegularGrammar( const RightRegularGrammar & rrg ) : AbstractRRGtoLRGConverter( rrg )
+RightToLeftRegularGrammar::RightToLeftRegularGrammar( const RightRegularGrammar & rrg ) : m_rrg( rrg )
 {
 
 }
@@ -26,15 +26,17 @@ RightToLeftRegularGrammar::~RightToLeftRegularGrammar( void )
 
 LeftRegularGrammar RightToLeftRegularGrammar::convert( void )
 {
+    LeftRegularGrammar lrg;
+
     for( const auto & symbol : m_rrg.getNonTerminalSymbols( ) )
-        m_lrg.addNonTerminalSymbol( symbol );
+        lrg.addNonTerminalSymbol( symbol );
 
     for( const auto & symbol : m_rrg.getTerminalSymbols( ) )
-        m_lrg.addTerminalSymbol( symbol );
+        lrg.addTerminalSymbol( symbol );
 
     // 1.
-    Symbol s = m_lrg.createUniqueNonTerminalSymbol( m_rrg.getStartSymbol( ).getSymbol( ), false );
-    m_lrg.setStartSymbol( s );
+    Symbol s = lrg.createUniqueNonTerminalSymbol( m_rrg.getStartSymbol( ).getSymbol( ), false );
+    lrg.setStartSymbol( s );
 
     // 2.
     for( const auto & rule : m_rrg.getRules( ) )
@@ -43,38 +45,38 @@ LeftRegularGrammar RightToLeftRegularGrammar::convert( void )
         {
             list<Symbol> leftSide = { rule.getRightSide( ).back( ) };
             list<Symbol> rightSide = { rule.getLeftSide( ).front( ), rule.getRightSide( ).front( ) };
-            m_lrg.addRule( Rule( leftSide, rightSide ) );
+            lrg.addRule( Rule( leftSide, rightSide ) );
 
             if( rule.getLeftSide( ).front( ) == m_rrg.getStartSymbol( ) )
             {
                 list<Symbol> leftSide = { rule.getRightSide( ).back( ) };
                 list<Symbol> rightSide = { rule.getRightSide( ).front( ) };
-                m_lrg.addRule( Rule( leftSide, rightSide ) );
+                lrg.addRule( Rule( leftSide, rightSide ) );
             }
         }
         else if( rule.getRightSide( ).size( ) == 1 )
         {
-            list<Symbol> leftSide = { m_lrg.getStartSymbol( ) };
+            list<Symbol> leftSide = { lrg.getStartSymbol( ) };
             list<Symbol> rightSide = { rule.getLeftSide( ).front( ), rule.getRightSide( ).front( ) };
-            m_lrg.addRule( Rule( leftSide, rightSide ) );
+            lrg.addRule( Rule( leftSide, rightSide ) );
 
             if( rule.getLeftSide( ).front( ) == m_rrg.getStartSymbol( ) )
             {
-                list<Symbol> leftSide = { m_lrg.getStartSymbol( ) };
+                list<Symbol> leftSide = { lrg.getStartSymbol( ) };
                 list<Symbol> rightSide = { rule.getRightSide( ).front( ) };
-                m_lrg.addRule( Rule( leftSide, rightSide ) );
+                lrg.addRule( Rule( leftSide, rightSide ) );
             }
         }
         else
         {
             // assert leftSide == rrg.getStartSymbol( )
-            list<Symbol> leftSide = { m_lrg.getStartSymbol( ) };
+            list<Symbol> leftSide = { lrg.getStartSymbol( ) };
             list<Symbol> rightSide;
-            m_lrg.addRule( Rule( leftSide, rightSide) );
+            lrg.addRule( Rule( leftSide, rightSide) );
         }
     }
 
-    return m_lrg;
+    return lrg;
 }
 
 } /* namespace conversions */
diff --git a/aconversions/src/rg2rg/rrg2lrg/RightToLeftRegularGrammar.h b/aconversions/src/rg2rg/rrg2lrg/RightToLeftRegularGrammar.h
index 0a956c7c11..23a94c318b 100644
--- a/aconversions/src/rg2rg/rrg2lrg/RightToLeftRegularGrammar.h
+++ b/aconversions/src/rg2rg/rrg2lrg/RightToLeftRegularGrammar.h
@@ -31,6 +31,12 @@ public:
      * @return left regular grammar which is equivalent to source right regular grammar.
      */
     grammar::LeftRegularGrammar convert( void );
+
+private:
+    /**
+     *
+     */
+     const grammar::RightRegularGrammar & m_rrg;
 };
 
 } /* namespace conversions */
diff --git a/aconversions/src/shared/Hexavigesimal.cpp b/aconversions/src/shared/Hexavigesimal.cpp
new file mode 100644
index 0000000000..77bb1f3412
--- /dev/null
+++ b/aconversions/src/shared/Hexavigesimal.cpp
@@ -0,0 +1,31 @@
+/*
+ * Hexavigesimal.cpp
+ *
+ *  Created on: 19. 4. 2014
+ *      Author: tomas
+ */
+
+#include "Hexavigesimal.h"
+
+using namespace std;
+
+namespace conversions
+{
+
+string toBase26( int id )
+{
+    // http://en.wikipedia.org/wiki/Hexavigesimal
+
+    unsigned int n = id;
+    string name;
+    do
+    {
+        unsigned int remainder = n % 26;
+        name += ( char )( remainder + 'A' );
+        n = (n - remainder) / 26;
+    } while (n > 0);
+
+    return string( name.rbegin( ), name.rend( ) );
+}
+
+} /* namespace conversions */
diff --git a/aconversions/src/shared/Hexavigesimal.h b/aconversions/src/shared/Hexavigesimal.h
new file mode 100644
index 0000000000..2c01e12d3d
--- /dev/null
+++ b/aconversions/src/shared/Hexavigesimal.h
@@ -0,0 +1,24 @@
+/*
+ * Hexavigesimal.h
+ *
+ *  Created on: 19. 4. 2014
+ *      Author: tomas
+ */
+
+#ifndef HEXAVIGESIMAL_H_
+#define HEXAVIGESIMAL_H_
+
+#include <string>
+
+namespace conversions
+{
+
+/**
+ * Maps 1 -> A, 2 -> B, ..., AA, AB, AC, ... , AAA, AAB, ...
+ * http://en.wikipedia.org/wiki/Hexavigesimal
+ */
+std::string toBase26( int n );
+
+} /* namespace conversions */
+
+#endif /* HEXAVIGESIMAL_H_ */
-- 
GitLab