diff --git a/aconversions/src/aconversion/ConversionHandler.cpp b/aconversions/src/aconversion/ConversionHandler.cpp
index 59fd49fc8cebb8d70aaec984095218a51714fa8b..a17dd35f0564b91ad86a147213c68965d9c1af49 100644
--- a/aconversions/src/aconversion/ConversionHandler.cpp
+++ b/aconversions/src/aconversion/ConversionHandler.cpp
@@ -118,15 +118,18 @@ void ConversionHandler::convertAutomata( ostream & out )
}
else if( m_target == REGULAR_GRAMMAR )
{
- AbstractFAtoRGConverter* conv;
-
if( m_algorithm == FA_LRG )
- conv = new FAtoLRGConverter( fsm );
+ {
+ AbstractFAtoLRGConverter* conv = new FAtoLRGConverter( fsm );
+ conv->convert( ).toXML( out );
+ delete conv;
+ }
else
- conv = new FAtoRRGConverter( fsm );
-
- conv->convert( ).toXML( out );
- delete conv;
+ {
+ AbstractFAtoRRGConverter* conv = new FAtoRRGConverter( fsm );
+ conv->convert( ).toXML( out );
+ delete conv;
+ }
}
}
diff --git a/aconversions/src/aconversion/ConversionHandler.h b/aconversions/src/aconversion/ConversionHandler.h
index 2ae45faf67a66b9cc2a9b0e4a0b8ff85d1f95e39..26fd073dbb7399cc3048e5ca587c01189d001eaa 100644
--- a/aconversions/src/aconversion/ConversionHandler.h
+++ b/aconversions/src/aconversion/ConversionHandler.h
@@ -22,8 +22,8 @@
#include "../re2fa/Glushkov.h"
#include "../re2fa/Thompson.h"
#include "../re2fa/Brzozowski.h"
-#include "../fa2rg/FAtoLRGConverter.h"
-#include "../fa2rg/FAtoRRGConverter.h"
+#include "../fa2rg/fa2lrg/FAtoLRGConverter.h"
+#include "../fa2rg/fa2rrg/FAtoRRGConverter.h"
#include "../rg2fa/LRGtoFAConverter.h"
#include "../rg2fa/RRGtoFAConverter.h"
diff --git a/aconversions/src/fa2rg/AbstractFAtoRGConverter.cpp b/aconversions/src/fa2rg/AbstractFAtoRGConverter.cpp
index a8eb28195b03b6d0b03ea2ee6970d511ed56259b..0f457e2fb8a0ab22bab2e888eea16d6c080b177c 100644
--- a/aconversions/src/fa2rg/AbstractFAtoRGConverter.cpp
+++ b/aconversions/src/fa2rg/AbstractFAtoRGConverter.cpp
@@ -1,3 +1,10 @@
+/*
+ * AbstractFAtoRGConverter.cpp
+ *
+ * Created on: 27. 2. 2014
+ * Author: tomas
+ */
+
#include "AbstractFAtoRGConverter.h"
using namespace alib;
@@ -7,27 +14,22 @@ using namespace grammar;
namespace conversions
{
-AbstractFAtoRGConverter::AbstractFAtoRGConverter( const FSM & automaton, RegularGrammar * grammar) : m_automaton( automaton ), m_g( grammar )
+AbstractFAtoRGConverter::AbstractFAtoRGConverter( const FSM & fsm ) : m_fsm( fsm )
{
- if( ! m_automaton.isEpsilonFree( ) )
- throw AlibException( "FSM has epsilon transitions" );
-}
-
-AbstractFAtoRGConverter::~AbstractFAtoRGConverter( void )
-{
-
+ if( ! m_fsm.isEpsilonFree( ) )
+ throw AlibException( "FSM has epsilon transitions" );
}
-void AbstractFAtoRGConverter::createTerminalSymbols( void )
+void AbstractFAtoRGConverter::createNonTerminalSymbols( RegularGrammar & rg ) const
{
- for( std::set<Symbol>::const_iterator i = m_automaton.getInputAlphabet( ).begin( ); i != m_automaton.getInputAlphabet( ).end( ); i++ )
- m_g->addTerminalSymbol( *i );
+ for( const auto & state : m_fsm.getStates( ) )
+ rg.addNonTerminalSymbol( Symbol( state.getName( ) ) );
}
-void AbstractFAtoRGConverter::createNonTerminalSymbols( void )
+void AbstractFAtoRGConverter::createTerminalSymbols( RegularGrammar & rg ) const
{
- for( std::set<automaton::State>::const_iterator i = m_automaton.getStates( ).begin( ); i != m_automaton.getStates( ).end( ); i++ )
- m_g->addNonTerminalSymbol( alphabet::Symbol( i->getName( ) ) );
+ for( const auto & symbol : m_fsm.getInputAlphabet( ) )
+ rg.addTerminalSymbol( symbol );
}
} /* namespace conversions */
diff --git a/aconversions/src/fa2rg/AbstractFAtoRGConverter.h b/aconversions/src/fa2rg/AbstractFAtoRGConverter.h
index c6b632f2261de3473de5362c6d212bf4678f9c46..495c1b50814a4a4820ecf04dfe790a29016a5e36 100644
--- a/aconversions/src/fa2rg/AbstractFAtoRGConverter.h
+++ b/aconversions/src/fa2rg/AbstractFAtoRGConverter.h
@@ -1,11 +1,17 @@
-#ifndef __ABSTRACTFATORGCONVERTER_H__
-#define __ABSTRACTFATORGCONVERTER_H__
+/*
+ * AbstractFAtoRGConverter.h
+ *
+ * Created on: 27. 2. 2014
+ * Author: tomas
+ */
+
+#ifndef ABSTRACTFATORGCONVERTER_H_
+#define ABSTRACTFATORGCONVERTER_H_
#include <automaton/FSM/FSM.h>
#include <grammar/Regular/RegularGrammar.h>
#include <AlibException.h>
-#include "../include/macros.h"
#include "../abstract/Conversion.h"
namespace conversions
@@ -14,18 +20,15 @@ namespace conversions
class AbstractFAtoRGConverter : public Conversion
{
public:
- virtual grammar::RegularGrammar & convert( ) = 0;
- virtual ~AbstractFAtoRGConverter( void );
+ AbstractFAtoRGConverter( const automaton::FSM & fsm );
protected:
- AbstractFAtoRGConverter( const automaton::FSM & automaton, grammar::RegularGrammar * grammar );
- void createNonTerminalSymbols( void );
- void createTerminalSymbols( void );
+ const automaton::FSM & m_fsm;
- const automaton::FSM & m_automaton;
- grammar::RegularGrammar * m_g;
+ void createNonTerminalSymbols( grammar::RegularGrammar & grammar ) const;
+ void createTerminalSymbols( grammar::RegularGrammar & grammar ) const;
};
} /* namespace conversions */
-#endif /* __ABSTRACTFATORGCONVERTER_H__ */
+#endif /* ABSTRACTFATORGCONVERTER_H_ */
diff --git a/aconversions/src/fa2rg/fa2lrg/AbstractFAtoLRGConverter.cpp b/aconversions/src/fa2rg/fa2lrg/AbstractFAtoLRGConverter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..341a5874d15fa867e4902e7e1512ddb5a0b87109
--- /dev/null
+++ b/aconversions/src/fa2rg/fa2lrg/AbstractFAtoLRGConverter.cpp
@@ -0,0 +1,20 @@
+#include "AbstractFAtoLRGConverter.h"
+
+using namespace alib;
+using namespace automaton;
+using namespace grammar;
+
+namespace conversions
+{
+
+AbstractFAtoLRGConverter::AbstractFAtoLRGConverter( const FSM & automaton ) : AbstractFAtoRGConverter( automaton )
+{
+
+}
+
+AbstractFAtoLRGConverter::~AbstractFAtoLRGConverter( void )
+{
+
+}
+
+} /* namespace conversions */
diff --git a/aconversions/src/fa2rg/fa2lrg/AbstractFAtoLRGConverter.h b/aconversions/src/fa2rg/fa2lrg/AbstractFAtoLRGConverter.h
new file mode 100644
index 0000000000000000000000000000000000000000..86a43b10fd0e0d6c3e8791c230147a24bb0a67e8
--- /dev/null
+++ b/aconversions/src/fa2rg/fa2lrg/AbstractFAtoLRGConverter.h
@@ -0,0 +1,28 @@
+#ifndef __ABSTRACTFATOLRGCONVERTER_H__
+#define __ABSTRACTFATOLRGCONVERTER_H__
+
+#include <automaton/FSM/FSM.h>
+#include <grammar/Regular/LeftRegularGrammar.h>
+#include <AlibException.h>
+
+#include "../../include/macros.h"
+#include "../AbstractFAtoRGConverter.h"
+
+namespace conversions
+{
+
+class AbstractFAtoLRGConverter : public AbstractFAtoRGConverter
+{
+public:
+ virtual grammar::LeftRegularGrammar convert( ) = 0;
+ virtual ~AbstractFAtoLRGConverter( void );
+
+protected:
+ grammar::LeftRegularGrammar m_grammar;
+
+ AbstractFAtoLRGConverter( const automaton::FSM & automaton );
+};
+
+} /* namespace conversions */
+
+#endif /* __ABSTRACTFATOLRGCONVERTER_H__ */
diff --git a/aconversions/src/fa2rg/FAtoLRGConverter.cpp b/aconversions/src/fa2rg/fa2lrg/FAtoLRGConverter.cpp
similarity index 77%
rename from aconversions/src/fa2rg/FAtoLRGConverter.cpp
rename to aconversions/src/fa2rg/fa2lrg/FAtoLRGConverter.cpp
index 00dd36a5364a8af9fe96ed0a40dbca4f7e886f92..ee3906c784ec419db525bebf4145329eca0a1975 100644
--- a/aconversions/src/fa2rg/FAtoLRGConverter.cpp
+++ b/aconversions/src/fa2rg/fa2lrg/FAtoLRGConverter.cpp
@@ -9,7 +9,7 @@ using namespace grammar;
namespace conversions
{
-FAtoLRGConverter::FAtoLRGConverter( const FSM & automaton ) : AbstractFAtoRGConverter( automaton, new LeftRegularGrammar() ), m_grammar(* dynamic_cast<LeftRegularGrammar*>( m_g ))
+FAtoLRGConverter::FAtoLRGConverter( const FSM & automaton ) : AbstractFAtoLRGConverter( automaton )
{
}
@@ -19,13 +19,13 @@ FAtoLRGConverter::~FAtoLRGConverter( void )
}
-LeftRegularGrammar & FAtoLRGConverter::convert( void )
+LeftRegularGrammar FAtoLRGConverter::convert( void )
{
- createTerminalSymbols( );
- createNonTerminalSymbols( );
+ createTerminalSymbols( m_grammar );
+ createNonTerminalSymbols( m_grammar );
// step 2 - create set of P in G
- for( const auto & transition : m_automaton.getTransitions( ) )
+ for( const auto & transition : m_fsm.getTransitions( ) )
{
// 2a
list<Symbol> leftSide, rightSide;
@@ -35,7 +35,7 @@ LeftRegularGrammar & FAtoLRGConverter::convert( void )
m_grammar.addRule( Rule( leftSide, rightSide ) );
// 2b
- if( isInSet( transition.getFrom( ), m_automaton.getInitialStates( ) ) )
+ if( isInSet( transition.getFrom( ), m_fsm.getInitialStates( ) ) )
{
list<Symbol> leftSide, rightSide;
leftSide.push_back( Symbol( transition.getTo( ).getName( ) ) );
@@ -49,7 +49,7 @@ LeftRegularGrammar & FAtoLRGConverter::convert( void )
m_grammar.setStartSymbol( newStart );
//
- if( isInSet( * m_automaton.getInitialStates( ).begin( ), m_automaton.getFinalStates( ) ) )
+ if( isInSet( * m_fsm.getInitialStates( ).begin( ), m_fsm.getFinalStates( ) ) )
{
list<Symbol> leftSide = { newStart }, rightSide;
m_grammar.addRule( Rule( leftSide, rightSide ) );
@@ -63,7 +63,7 @@ LeftRegularGrammar & FAtoLRGConverter::convert( void )
{
const Symbol & leftSide = * rule.getLeftSide( ).begin( );
- if( isInSet( State( leftSide.getSymbol( ) ), m_automaton.getFinalStates( ) ) )
+ if( isInSet( State( leftSide.getSymbol( ) ), m_fsm.getFinalStates( ) ) )
{
list<Symbol> leftSide = { newStart }, rightSide( rule.getRightSide( ) );
m_grammar.addRule( Rule( leftSide, rightSide ) );
diff --git a/aconversions/src/fa2rg/FAtoLRGConverter.h b/aconversions/src/fa2rg/fa2lrg/FAtoLRGConverter.h
similarity index 65%
rename from aconversions/src/fa2rg/FAtoLRGConverter.h
rename to aconversions/src/fa2rg/fa2lrg/FAtoLRGConverter.h
index 328d7edd43321928f387b14ded82aed7d83c6b94..69848392c1745cdfe0850eeec490ff3cb9e33068 100644
--- a/aconversions/src/fa2rg/FAtoLRGConverter.h
+++ b/aconversions/src/fa2rg/fa2lrg/FAtoLRGConverter.h
@@ -1,23 +1,23 @@
#ifndef __FATOLRGCONVERTER_H__
#define __FATOLRGCONVERTER_H__
-#include "AbstractFAtoRGConverter.h"
-
#include <grammar/Regular/LeftRegularGrammar.h>
#include <automaton/FSM/FSM.h>
+#include "AbstractFAtoLRGConverter.h"
+
namespace conversions
{
-class FAtoLRGConverter: public AbstractFAtoRGConverter
+class FAtoLRGConverter: public AbstractFAtoLRGConverter
{
public:
FAtoLRGConverter( const automaton::FSM & automaton );
~FAtoLRGConverter( void );
- grammar::LeftRegularGrammar & convert( );
+ grammar::LeftRegularGrammar convert( void );
protected:
- grammar::LeftRegularGrammar& m_grammar;
+ grammar::LeftRegularGrammar m_grammar;
};
} /* namespace conversions */
diff --git a/aconversions/src/fa2rg/fa2rrg/AbstractFAtoRRGConverter.cpp b/aconversions/src/fa2rg/fa2rrg/AbstractFAtoRRGConverter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..2201255bceca77d744dae1e2098a154e8b58e244
--- /dev/null
+++ b/aconversions/src/fa2rg/fa2rrg/AbstractFAtoRRGConverter.cpp
@@ -0,0 +1,19 @@
+#include "AbstractFAtoRRGConverter.h"
+
+using namespace automaton;
+using namespace grammar;
+
+namespace conversions
+{
+
+AbstractFAtoRRGConverter::AbstractFAtoRRGConverter( const FSM & automaton ) : AbstractFAtoRGConverter( automaton )
+{
+
+}
+
+AbstractFAtoRRGConverter::~AbstractFAtoRRGConverter( void )
+{
+
+}
+
+} /* namespace conversions */
diff --git a/aconversions/src/fa2rg/fa2rrg/AbstractFAtoRRGConverter.h b/aconversions/src/fa2rg/fa2rrg/AbstractFAtoRRGConverter.h
new file mode 100644
index 0000000000000000000000000000000000000000..28d5e30d0ef042df118081d7febe5ddb769d2df6
--- /dev/null
+++ b/aconversions/src/fa2rg/fa2rrg/AbstractFAtoRRGConverter.h
@@ -0,0 +1,28 @@
+#ifndef __ABSTRACTFATORRGCONVERTER_H__
+#define __ABSTRACTFATORRGCONVERTER_H__
+
+#include <automaton/FSM/FSM.h>
+#include <grammar/Regular/RightRegularGrammar.h>
+#include <AlibException.h>
+
+#include "../../include/macros.h"
+#include "../AbstractFAtoRGConverter.h"
+
+namespace conversions
+{
+
+class AbstractFAtoRRGConverter : public AbstractFAtoRGConverter
+{
+public:
+ virtual grammar::RightRegularGrammar convert( ) = 0;
+ virtual ~AbstractFAtoRRGConverter( void );
+
+protected:
+ grammar::RightRegularGrammar m_grammar;
+
+ AbstractFAtoRRGConverter( const automaton::FSM & automaton );
+};
+
+} /* namespace conversions */
+
+#endif /* __ABSTRACTFATORRGCONVERTER_H__ */
diff --git a/aconversions/src/fa2rg/FAtoRRGConverter.cpp b/aconversions/src/fa2rg/fa2rrg/FAtoRRGConverter.cpp
similarity index 81%
rename from aconversions/src/fa2rg/FAtoRRGConverter.cpp
rename to aconversions/src/fa2rg/fa2rrg/FAtoRRGConverter.cpp
index b0f6f461b7c50ba5383ec4105d187f795cc234cc..59ecc0d1d697a83b65b879196c3c3a4db3aa283a 100644
--- a/aconversions/src/fa2rg/FAtoRRGConverter.cpp
+++ b/aconversions/src/fa2rg/fa2rrg/FAtoRRGConverter.cpp
@@ -7,7 +7,7 @@ using namespace grammar;
namespace conversions
{
-FAtoRRGConverter::FAtoRRGConverter( const FSM & automaton ) : AbstractFAtoRGConverter( automaton, new RightRegularGrammar() ), m_grammar(* dynamic_cast<RightRegularGrammar*>( m_g ))
+FAtoRRGConverter::FAtoRRGConverter( const FSM & automaton ) : AbstractFAtoRRGConverter( automaton )
{
}
@@ -17,13 +17,13 @@ FAtoRRGConverter::~FAtoRRGConverter( void )
}
-RightRegularGrammar & FAtoRRGConverter::convert( void )
+RightRegularGrammar FAtoRRGConverter::convert( void )
{
- createTerminalSymbols( );
- createNonTerminalSymbols( );
+ createTerminalSymbols( m_grammar );
+ createNonTerminalSymbols( m_grammar );
// step 2 - create set of P in G
- for( const auto & transition : m_automaton.getTransitions( ) )
+ for( const auto & transition : m_fsm.getTransitions( ) )
{
// 2a
list<Symbol> leftSide, rightSide;
@@ -33,7 +33,7 @@ RightRegularGrammar & FAtoRRGConverter::convert( void )
m_grammar.addRule( Rule( leftSide, rightSide ) );
// 2b
- if( isInSet( transition.getTo( ), m_automaton.getFinalStates( ) ) )
+ if( isInSet( transition.getTo( ), m_fsm.getFinalStates( ) ) )
{
list<Symbol> leftSide, rightSide;
leftSide.push_back( Symbol( transition.getFrom( ).getName( ) ) );
@@ -43,10 +43,10 @@ RightRegularGrammar & FAtoRRGConverter::convert( void )
}
// step 3 - set start symbol of G
- m_grammar.setStartSymbol( Symbol( m_automaton.getInitialStates( ).begin( )->getName( ) ) );
+ m_grammar.setStartSymbol( Symbol( m_fsm.getInitialStates( ).begin( )->getName( ) ) );
// step 4
- if( isInSet( State( m_grammar.getStartSymbol( ).getSymbol( ) ), m_automaton.getFinalStates( ) ) )
+ if( isInSet( State( m_grammar.getStartSymbol( ).getSymbol( ) ), m_fsm.getFinalStates( ) ) )
{
// 4a
if( ! m_grammar.isNonTerminalOnRightSideOfAnyRule( m_grammar.getStartSymbol( ) ) )
diff --git a/aconversions/src/fa2rg/FAtoRRGConverter.h b/aconversions/src/fa2rg/fa2rrg/FAtoRRGConverter.h
similarity index 64%
rename from aconversions/src/fa2rg/FAtoRRGConverter.h
rename to aconversions/src/fa2rg/fa2rrg/FAtoRRGConverter.h
index 7738b8ade917ecb2211974d3699339c3029a65d0..575e500945924f3effa50f09e5076b58f5bd1c04 100644
--- a/aconversions/src/fa2rg/FAtoRRGConverter.h
+++ b/aconversions/src/fa2rg/fa2rrg/FAtoRRGConverter.h
@@ -4,20 +4,20 @@
#include <grammar/Regular/RightRegularGrammar.h>
#include <automaton/FSM/FSM.h>
-#include "AbstractFAtoRGConverter.h"
+#include "AbstractFAtoRRGConverter.h"
namespace conversions
{
-class FAtoRRGConverter : public AbstractFAtoRGConverter
+class FAtoRRGConverter : public AbstractFAtoRRGConverter
{
public:
FAtoRRGConverter( const automaton::FSM & automaton );
~FAtoRRGConverter( void );
- grammar::RightRegularGrammar & convert ( );
+ grammar::RightRegularGrammar convert ( void );
protected:
- grammar::RightRegularGrammar& m_grammar;
+ grammar::RightRegularGrammar m_grammar;
};
} /* namespace conversions */