diff --git a/aconversions/src/aconversion/ConversionHandler.cpp b/aconversions/src/aconversion/ConversionHandler.cpp
index b18f150a4adaafc5cc2217087d6742cec7a15846..c7f8637b50b559c74cce895c0bb7c2e11ad5430e 100644
--- a/aconversions/src/aconversion/ConversionHandler.cpp
+++ b/aconversions/src/aconversion/ConversionHandler.cpp
@@ -17,204 +17,338 @@ using namespace std;
namespace conversions
{
-ConversionHandler::ConversionHandler( list<Token> & tokens, const string & target, const string & algorithm ) : m_tokens( tokens )
+ConversionHandler::ConversionHandler( list<Token> & tokens, const string & target, const string & algorithm, ostream & out ) :
+ m_tokens( tokens ),
+ m_source( parseFormalismFromTokens( ) ),
+ m_target( parseFormalismFromString( target ) ),
+ m_algorithm( parseAlgorithmFromString( algorithm ) ),
+ m_out( out )
{
- m_source = parseFormalismFromString( m_tokens.front( ).getData( ) );
- m_target = parseFormalismFromString( target );
- if( m_source == m_target && m_source != REGULAR_GRAMMAR )
- throw AlibException( "Cannot convert between same formalisms." );
-
- m_algorithm = parseAlgorithmFromString( algorithm );
- if( m_algorithm == DEFAULT )
- m_algorithm = getDefaultAlgorithm( );
-
- if( ! checkAlgorithm( ) )
- throw AlibException( "Invalid conversion. See help." );
}
-void ConversionHandler::convert( ostream & out )
+void ConversionHandler::convert( void )
{
if( m_source == FINITE_AUTOMATA )
- convertAutomata( out );
- if( m_source == REGULAR_EXPRESSION )
- convertRegExp( out );
- if( m_source == REGULAR_GRAMMAR )
- convertGrammar( out );
+ convertFSM( );
+ else if( m_source == REGULAR_EXPRESSION )
+ convertRE( );
+ else if( isGrammar( m_source ) )
+ convertRG( );
+ else
+ throw AlibException( "ConversionHandler: Unknown source formalism." );
}
-void ConversionHandler::convertGrammar( ostream & out )
+// ----------------------------------------------------------------------------
+
+void ConversionHandler::convertFSM( void )
{
- const UnknownGrammar ug = GrammarParser::parse( m_tokens );
+ if( m_target == FINITE_AUTOMATA )
+ throw AlibException( "ConversionHandler: No valid conversion from FSM to FSM." );
+ else if( m_target == REGULAR_EXPRESSION )
+ convertFSMtoRE( );
+ else if( isGrammar( m_target ) )
+ convertFSMtoRG( );
+ else
+ throw AlibException( "ConversionHandler: Unknown target formalism." );
+}
+void ConversionHandler::convertRE( void )
+{
if( m_target == FINITE_AUTOMATA )
- {
- AbstractRGtoFAConverter* conv;
- RightRegularGrammar rrg;
- LeftRegularGrammar lrg;
- bool rightGrammar = true;
+ convertREtoFSM( );
+ else if( m_target == REGULAR_EXPRESSION )
+ throw AlibException( "ConversionHandler: No valid conversion from RE to RE." );
+ else if( isGrammar( m_target ) )
+ convertREtoRG( );
+ else
+ throw AlibException( "ConversionHandler: Unknown target formalism." );
+}
- try
- {
- GrammarFactory::buildRightRegularGrammar( ug );
- }
- catch( AlibException & e )
- {
- rightGrammar = false;
- }
+void ConversionHandler::convertRG( void )
+{
+ if( m_target == FINITE_AUTOMATA )
+ convertRGtoFSM( );
+ else if( m_target == REGULAR_EXPRESSION )
+ convertRGtoRE( );
+ else if( isGrammar( m_target ) )
+ convertRGtoRG( );
+ else
+ throw AlibException( "ConversionHandler: Unknown target formalism." );
+}
- if( rightGrammar )
- {
- rrg = GrammarFactory::buildRightRegularGrammar( ug );
- conv = new RRGtoFAConverter( rrg );
- }
- else
- {
- lrg = GrammarFactory::buildLeftRegularGrammar( ug );
- conv = new LRGtoFAConverter( lrg );
- }
+// ----------------------------------------------------------------------------
+
+void ConversionHandler::convertFSMtoRE( void )
+{
+ const FSM fsm = AutomatonFactory::buildFSM( AutomatonParser::parse( m_tokens ) );
- conv->convert( ).toXML( out );
- delete conv;
+ AbstractFAtoREConverter* conv;
- }
- else if( m_target == REGULAR_EXPRESSION )
+ switch( m_algorithm )
{
- AbstractRGtoREConverter* conv;
- RightRegularGrammar rrg;
- LeftRegularGrammar lrg;
- bool rightGrammar = true;
+ case BRZOZOWSKI_ALGEBRAIC:
+ conv = new BrzozowskiAlgebraic( fsm );
+ break;
+
+ case STATE_ELIMINATION:
+ default:
+ conv = new StateElimination( fsm );
+ break;
+ }
- try
- {
- GrammarFactory::buildRightRegularGrammar( ug );
- }
- catch( AlibException & e )
- {
- rightGrammar = false;
- }
+ conv->convert( ).toXML( m_out );
+ delete conv;
+}
- if( m_algorithm == BRZOZOWSKI_ALGEBRAIC && rightGrammar )
- {
- rrg = GrammarFactory::buildRightRegularGrammar( ug );
- conv = new RRGAlgebraic( rrg );
- }
- else if( m_algorithm == BRZOZOWSKI_ALGEBRAIC && ! rightGrammar )
- {
- lrg = GrammarFactory::buildLeftRegularGrammar( ug );
- conv = new LRGAlgebraic( lrg );
- }
- else throw AlibException( "wtf?" );
+void ConversionHandler::convertFSMtoRG( void )
+{
+ if( m_target == RIGHT_REGULAR_GRAMMAR || REGULAR_GRAMMAR )
+ convertFSMtoRRG( );
+ else if( m_target == LEFT_REGULAR_GRAMMAR )
+ convertFSMtoLRG( );
+ else
+ throw AlibException( "ConversionHandler::Unknown target formalism" );
+}
+
+void ConversionHandler::convertFSMtoRRG( void )
+{
+ const FSM fsm = AutomatonFactory::buildFSM( AutomatonParser::parse( m_tokens ) );
- conv->convert( ).toXML( out );
- delete conv;
+ AbstractFAtoRRGConverter* conv;
+
+ switch( m_algorithm )
+ {
+ default:
+ conv = new FAtoRRGConverter( fsm );
+ break;
}
- else if( m_target == REGULAR_GRAMMAR )
+
+ conv->convert( ).toXML( m_out );
+ delete conv;
+}
+
+void ConversionHandler::convertFSMtoLRG( void )
+{
+ const FSM fsm = AutomatonFactory::buildFSM( AutomatonParser::parse( m_tokens ) );
+
+ AbstractFAtoLRGConverter* conv;
+
+ switch( m_algorithm )
{
- RightRegularGrammar rrg;
- LeftRegularGrammar lrg;
- bool rightGrammar = true;
+ default:
+ conv = new FAtoLRGConverter( fsm );
+ break;
+ }
- try
- {
- GrammarFactory::buildRightRegularGrammar( ug );
- }
- catch( AlibException & e )
- {
- rightGrammar = false;
- }
+ conv->convert( ).toXML( m_out );
+ delete conv;
+}
- if( rightGrammar )
- {
- AbstractRRGtoLRGConverter* conv;
- rrg = GrammarFactory::buildRightRegularGrammar( ug );
- conv = new RightToLeftRegularGrammar( rrg );
- conv->convert( ).toXML( out );
- delete conv;
- }
- else
- {
- AbstractLRGtoRRGConverter* conv;
- lrg = GrammarFactory::buildLeftRegularGrammar( ug );
- conv = new LeftToRightRegularGrammar( lrg );
- conv->convert( ).toXML( out );
- delete conv;
- }
+// ----------------------------------------------------------------------------
+
+void ConversionHandler::convertREtoFSM( void )
+{
+ const RegExp regexp = RegExpParser::parse( m_tokens );
+ AbstractREtoFAConverter* conv;
+
+ switch( m_algorithm )
+ {
+ case BRZOZOWSKI_DERIVATION:
+ conv = new Brzozowski( regexp );
+ break;
+ case THOMPSON_NFA:
+ conv = new Thompson( regexp );
+ break;
+ case GLUSHKOV_NFA:
+ default:
+ conv = new Glushkov( regexp );
+ break;
}
+
+ conv->convert( ).toXML( m_out );
+ delete conv;
+}
+
+void ConversionHandler::convertREtoRG( void )
+{
+ if( m_target == RIGHT_REGULAR_GRAMMAR || REGULAR_GRAMMAR )
+ convertREtoRRG( );
+ else if( m_target == LEFT_REGULAR_GRAMMAR )
+ throw AlibException( "ConversionHandler:: RE to LRG is not implemented. Please convert to RRG and then to LRG." );
+ else
+ throw AlibException( "ConversionHandler::Unknown target formalism" );
}
-void ConversionHandler::convertRegExp( ostream & out )
+void ConversionHandler::convertREtoRRG( void )
{
const RegExp regexp = RegExpParser::parse( m_tokens );
+ AbstractREtoRRGConverter* conv;
- if( m_target == FINITE_AUTOMATA )
+ switch( m_algorithm )
{
- AbstractREtoFAConverter* conv;
- if( m_algorithm == THOMPSON )
- conv = new Thompson( regexp );
- else if( m_algorithm == BRZOZOWSKI_DERIVATION )
- conv = new Brzozowski( regexp );
- else
- conv = new Glushkov( regexp );
+ case BRZOZOWSKI_DERIVATION:
+ conv = new BrzozowskiDerivationRRG( regexp );
+ break;
+ default:
+ conv = new GlushkovRRG( regexp );
+ break;
+ }
+
+ conv->convert( ).toXML( m_out );
+ delete conv;
+}
+
+// ----------------------------------------------------------------------------
+
+void ConversionHandler::convertRGtoFSM( void )
+{
+ if( m_source == LEFT_REGULAR_GRAMMAR )
+ convertLRGtoFSM( );
+ else if( m_source == RIGHT_REGULAR_GRAMMAR )
+ convertRRGtoFSM( );
+ else if( m_source == LEFT_LINEAR_GRAMMAR )
+ throw AlibException( "ConversionHandler: Conversions from linear grammars are not yet implemented." );
+ else if( m_source == RIGHT_LINEAR_GRAMMAR )
+ throw AlibException( "ConversionHandler: Conversions from linear grammars are not yet implemented." );
+ else
+ throw AlibException( "ConversionHandler: Unknown target formalism." );
+}
+
+void ConversionHandler::convertRGtoRG( void )
+{
+ if( m_source == LEFT_REGULAR_GRAMMAR )
+ convertLRGtoRRG( );
+ else if( m_source == RIGHT_REGULAR_GRAMMAR )
+ convertRRGtoLRG( );
+ else if( m_source == LEFT_LINEAR_GRAMMAR )
+ throw AlibException( "ConversionHandler: Conversions from linear grammars are not yet implemented." );
+ else if( m_source == RIGHT_LINEAR_GRAMMAR )
+ throw AlibException( "ConversionHandler: Conversions from linear grammars are not yet implemented." );
+ else
+ throw AlibException( "ConversionHandler: Unknown target formalism." );
+}
+
+void ConversionHandler::convertRGtoRE( void )
+{
+ if( m_source == LEFT_REGULAR_GRAMMAR )
+ convertLRGtoRE( );
+ else if( m_source == RIGHT_REGULAR_GRAMMAR )
+ convertRRGtoRE( );
+ else if( m_source == LEFT_LINEAR_GRAMMAR )
+ throw AlibException( "ConversionHandler: Conversions from linear grammars are not yet implemented." );
+ else if( m_source == RIGHT_LINEAR_GRAMMAR )
+ throw AlibException( "ConversionHandler: Conversions from linear grammars are not yet implemented." );
+ else
+ throw AlibException( "ConversionHandler: Unknown target formalism." );
+}
+
+void ConversionHandler::convertLRGtoFSM( void )
+{
+ const LeftRegularGrammar lrg = GrammarFactory::buildLeftRegularGrammar( GrammarParser::parse( m_tokens ) );
- conv->convert( ).toXML( out );
- delete conv;
+ AbstractLRGtoFAConverter* conv;
+ switch( m_algorithm )
+ {
+ default:
+ conv = new LRGtoFAConverter( lrg );
+ break;
}
- else if( m_target == REGULAR_GRAMMAR )
+
+ conv->convert( ).toXML( m_out );
+ delete conv;
+}
+
+void ConversionHandler::convertRRGtoFSM( void )
+{
+ const RightRegularGrammar rrg = GrammarFactory::buildRightRegularGrammar( GrammarParser::parse( m_tokens ) );
+
+ AbstractRRGtoFAConverter* conv;
+
+ switch( m_algorithm )
{
- if( m_algorithm == BRZOZOWSKI_RRG )
- {
- AbstractREtoRRGConverter* conv;
+ default:
+ conv = new RRGtoFAConverter( rrg );
+ break;
+ }
- conv = new BrzozowskiDerivationRRG( regexp );
- conv->convert( ).toXML( out );
- delete conv;
- }
- else if ( m_algorithm == GLUSHKOV_RRG )
- {
- AbstractREtoRRGConverter* conv;
+ conv->convert( ).toXML( m_out );
+ delete conv;
+}
- conv = new GlushkovRRG( regexp );
- conv->convert( ).toXML( out );
- delete conv;
- }
+void ConversionHandler::convertLRGtoRE( void )
+{
+ const LeftRegularGrammar lrg = GrammarFactory::buildLeftRegularGrammar( GrammarParser::parse( m_tokens ) );
+
+ AbstractLRGtoREConverter* conv;
+
+ switch( m_algorithm )
+ {
+ case BRZOZOWSKI_ALGEBRAIC:
+ default:
+ conv = new LRGAlgebraic( lrg );
+ break;
}
+
+ conv->convert( ).toXML( m_out );
+ delete conv;
}
-void ConversionHandler::convertAutomata( ostream & out )
+void ConversionHandler::convertRRGtoRE( void )
{
- const FSM fsm = AutomatonFactory::buildFSM( AutomatonParser::parse( m_tokens ) );
+ const RightRegularGrammar rrg = GrammarFactory::buildRightRegularGrammar( GrammarParser::parse( m_tokens ) );
+
+ AbstractRRGtoREConverter* conv;
- if( m_target == REGULAR_EXPRESSION )
+ switch( m_algorithm )
{
- AbstractFAtoREConverter* conv;
+ case BRZOZOWSKI_ALGEBRAIC:
+ default:
+ conv = new RRGAlgebraic( rrg );
+ break;
+ }
+
+ conv->convert( ).toXML( m_out );
+ delete conv;
+}
- if( m_algorithm == BRZOZOWSKI_ALGEBRAIC )
- conv = new BrzozowskiAlgebraic( fsm );
- else
- conv = new StateElimination( fsm );
+void ConversionHandler::convertLRGtoRRG( void )
+{
+ const LeftRegularGrammar lrg = GrammarFactory::buildLeftRegularGrammar( GrammarParser::parse( m_tokens ) );
+
+ AbstractLRGtoRRGConverter* conv;
- conv->convert( ).toXML( out );
- delete conv;
+ switch( m_algorithm )
+ {
+ default:
+ conv = new LeftToRightRegularGrammar( lrg );
+ break;
}
- else if( m_target == REGULAR_GRAMMAR )
+
+ conv->convert( ).toXML( m_out );
+ delete conv;
+}
+
+void ConversionHandler::convertRRGtoLRG( void )
+{
+ const RightRegularGrammar rrg = GrammarFactory::buildRightRegularGrammar( GrammarParser::parse( m_tokens ) );
+
+ AbstractRRGtoLRGConverter* conv;
+
+ switch( m_algorithm )
{
- if( m_algorithm == FA_LRG )
- {
- AbstractFAtoLRGConverter* conv = new FAtoLRGConverter( fsm );
- conv->convert( ).toXML( out );
- delete conv;
- }
- else
- {
- AbstractFAtoRRGConverter* conv = new FAtoRRGConverter( fsm );
- conv->convert( ).toXML( out );
- delete conv;
- }
+ default:
+ conv = new RightToLeftRegularGrammar( rrg );
+ break;
}
+
+ conv->convert( ).toXML( m_out );
+ delete conv;
}
+// ----------------------------------------------------------------------------
+
ConversionHandler::TFormalism ConversionHandler::parseFormalismFromString( const std::string & _target ) const
{
string target;
@@ -223,94 +357,100 @@ ConversionHandler::TFormalism ConversionHandler::parseFormalismFromString( const
if( target == "fa" || target == "automaton" || target == "fsm" )
return FINITE_AUTOMATA;
- if( target == "re" || target == "regexp" )
+
+ if( target == "re" || target == "regexp" || target == "regex" )
return REGULAR_EXPRESSION;
+
if( target == "rg" || target == "grammar" )
return REGULAR_GRAMMAR;
- throw AlibException( "Unknown target type" );
+ if( target == "rrg" )
+ return RIGHT_REGULAR_GRAMMAR;
+
+ if( target == "lrg" )
+ return LEFT_REGULAR_GRAMMAR;
+
+ throw AlibException( "ConversionHandler::Unknown target type" );
}
-ConversionHandler::TAlgorithm ConversionHandler::parseAlgorithmFromString( const std::string & _algorithm ) const
+ConversionHandler::TFormalism ConversionHandler::parseFormalismFromTokens( void ) const
{
- string algorithm;
- for( const auto & c : _algorithm )
- algorithm.append( 1, tolower( c ) );
+ string xmlMark = m_tokens.front( ).getData( );
- if( algorithm == "" ) return DEFAULT;
+ if( xmlMark == "automaton" )
+ return FINITE_AUTOMATA;
- /* FA to RE */
- /* RG to RE */
- if( algorithm == "elimination" ) return STATE_ELIMINATION;
- if( algorithm == "algebraic" ) return BRZOZOWSKI_ALGEBRAIC;
+ if( xmlMark == "regexp" )
+ return REGULAR_EXPRESSION;
- /* FA to RG */
- if( algorithm == "left" ) return FA_LRG;
- if( algorithm == "right" ) return FA_RRG;
+ if( xmlMark == "grammar" )
+ {
+ bool ll, rl, lr, rr;
+ ll = rl = lr = rr = true;
- /* RE to FA */
- if( algorithm == "brzozowski" ) return BRZOZOWSKI_DERIVATION;
- if( algorithm == "glushkov" ) return GLUSHKOV;
- if( algorithm == "thompson" ) return THOMPSON;
+ list<Token> tokens_copy = m_tokens;
+ UnknownGrammar grammar = GrammarParser::parse( tokens_copy );
- /* RE to RG */
- if( algorithm == "brzozowskirrg") return BRZOZOWSKI_RRG;
- if( algorithm == "glushkovrrg") return GLUSHKOV_RRG;
+ try
+ {
+ GrammarFactory::buildRightRegularGrammar( grammar );
+ }
+ catch( AlibException & e )
+ {
+ rr = false;
+ }
+ if( rr ) return RIGHT_REGULAR_GRAMMAR;
- /* RG to FA */
- if( algorithm == "rg" ) return RG_FA;
+ try
+ {
+ GrammarFactory::buildLeftRegularGrammar( grammar );
+ }
+ catch( AlibException & e )
+ {
+ lr = false;
+ }
+ if( lr ) return LEFT_REGULAR_GRAMMAR;
- /* RG to RG */
- if( algorithm == "rg" ) return LRG_RRG;
+ try
+ {
+ GrammarFactory::buildRightLinearGrammar( grammar );
+ }
+ catch( AlibException & e )
+ {
+ rl = false;
+ }
+ if( rl ) return RIGHT_LINEAR_GRAMMAR;
- throw AlibException( "Invalid conversion. See help." );
-}
+ try
+ {
+ GrammarFactory::buildLeftLinearGrammar( grammar );
+ }
+ catch( AlibException & e )
+ {
+ ll = false;
+ }
+ if( ll ) return LEFT_LINEAR_GRAMMAR;
+ }
-ConversionHandler::TAlgorithm ConversionHandler::getDefaultAlgorithm( void ) const
-{
- if( m_source == FINITE_AUTOMATA && m_target == REGULAR_EXPRESSION ) return STATE_ELIMINATION;
- if( m_source == FINITE_AUTOMATA && m_target == REGULAR_GRAMMAR ) return FA_RRG;
- if( m_source == REGULAR_EXPRESSION && m_target == FINITE_AUTOMATA ) return GLUSHKOV;
- if( m_source == REGULAR_EXPRESSION && m_target == REGULAR_GRAMMAR ) return GLUSHKOV_RRG;
- if( m_source == REGULAR_GRAMMAR && m_target == FINITE_AUTOMATA ) return RG_FA;
- if( m_source == REGULAR_GRAMMAR && m_target == REGULAR_EXPRESSION ) return BRZOZOWSKI_ALGEBRAIC;
- if( m_source == REGULAR_GRAMMAR && m_target == REGULAR_GRAMMAR ) return LRG_RRG;
-
- throw AlibException( "ConversionHandler::getDefaultAlgorithm - unreachable code" );
+ throw AlibException( "ConversionHandler: Invalid input formalism." );
+ // return UNKNOWN;
}
-bool ConversionHandler::checkAlgorithm( void ) const
+ConversionHandler::TAlgorithm ConversionHandler::parseAlgorithmFromString( const std::string & _algorithm ) const
{
- if( m_algorithm == DEFAULT ) return true;
+ string algorithm;
+ for( const auto & c : _algorithm )
+ algorithm.append( 1, tolower( c ) );
- /* FA to RE */
- /* FA to RG */
- if( m_source == FINITE_AUTOMATA )
- return ( m_target == REGULAR_EXPRESSION &&
- ( m_algorithm == BRZOZOWSKI_ALGEBRAIC || m_algorithm == STATE_ELIMINATION ) ) ||
- ( m_target == REGULAR_GRAMMAR &&
- ( m_algorithm == FA_LRG || m_algorithm == FA_RRG ) );
-
- /* RE to FA */
- /* RE to RG */
- if( m_source == REGULAR_EXPRESSION )
- return ( m_target == FINITE_AUTOMATA &&
- ( m_algorithm == BRZOZOWSKI_DERIVATION || m_algorithm == GLUSHKOV || m_algorithm == THOMPSON ) ) ||
- ( m_target == REGULAR_GRAMMAR &&
- ( m_algorithm == BRZOZOWSKI_RRG || m_algorithm == GLUSHKOV_RRG ) );
-
- /* RG to FA */
- /* RG to RE */
- /* RG to RG */
- if( m_source == REGULAR_GRAMMAR )
- return ( m_target == FINITE_AUTOMATA &&
- ( m_algorithm == RG_FA ) ) ||
- ( m_target == REGULAR_EXPRESSION &&
- ( m_algorithm == BRZOZOWSKI_ALGEBRAIC ) ) ||
- ( m_target == REGULAR_GRAMMAR &&
- ( m_algorithm == LRG_RRG ) );
-
- return false;
+ if( algorithm == "elimination" ) return STATE_ELIMINATION;
+ if( algorithm == "algebraic" ) return BRZOZOWSKI_ALGEBRAIC;
+ if( algorithm == "brzozowski" ) return BRZOZOWSKI_DERIVATION;
+ if( algorithm == "glushkov" ) return GLUSHKOV_NFA;
+ if( algorithm == "thompson" ) return THOMPSON_NFA;
+
+ if( algorithm == "" ) return DEFAULT;
+
+ throw AlibException( "ConversionHandler:: Invalid algorithm. See help." );
}
} /* namespace conversions */
diff --git a/aconversions/src/aconversion/ConversionHandler.h b/aconversions/src/aconversion/ConversionHandler.h
index 28f911930a29df642ce9e36823cdbe89aff6ec5f..0b273043a3d974f5873d3e6cf8d217ffdf8da40b 100644
--- a/aconversions/src/aconversion/ConversionHandler.h
+++ b/aconversions/src/aconversion/ConversionHandler.h
@@ -19,19 +19,26 @@
#include "../fa2re/StateElimination.h"
#include "../fa2re/BrzozowskiAlgebraic.h"
+
#include "../re2fa/Glushkov.h"
#include "../re2fa/Thompson.h"
#include "../re2fa/Brzozowski.h"
+
#include "../fa2rg/fa2lrg/FAtoLRGConverter.h"
#include "../fa2rg/fa2rrg/FAtoRRGConverter.h"
-#include "../rg2fa/LRGtoFAConverter.h"
-#include "../rg2fa/RRGtoFAConverter.h"
-#include "../rg2re/RRGAlgebraic.h"
-#include "../rg2re/LRGAlgebraic.h"
-#include "../re2rg/re2rrg/BrzozowskiDerivationRRG.h"
-#include "../lrg2rrg/LeftToRightRegularGrammar.h"
-#include "../rrg2lrg/RightToLeftRegularGrammar.h"
+
+#include "../rg2fa/lrg2fa/LRGtoFAConverter.h"
+#include "../rg2fa/rrg2fa/RRGtoFAConverter.h"
+
+#include "../rg2re/rrg2re/RRGAlgebraic.h"
+#include "../rg2re/lrg2re/LRGAlgebraic.h"
+
#include "../re2rg/re2rrg/GlushkovRRG.h"
+#include "../re2rg/re2rrg/BrzozowskiDerivationRRG.h"
+
+#include "../rg2rg/lrg2rrg/LeftToRightRegularGrammar.h"
+#include "../rg2rg/rrg2lrg/RightToLeftRegularGrammar.h"
+
namespace conversions
{
@@ -48,54 +55,86 @@ public:
STATE_ELIMINATION,
/* FA to RG */
- FA_LRG,
- FA_RRG,
+ // FA to LRG,
+ // FA to RRG
/* RE to FA */
BRZOZOWSKI_DERIVATION,
- THOMPSON,
- GLUSHKOV,
+ THOMPSON_NFA,
+ GLUSHKOV_NFA,
/* RE to RG */
- BRZOZOWSKI_RRG,
- GLUSHKOV_RRG,
+
/* RG to FA */
- RG_FA,
+ // LRG to FSM
+ // RRG to FSM
/* RG to RE */
- // BRZOZOWSKI_ALGEBRAIC,
- // STATE_ELIMINATION,
+ // BRZOZOWSKI_ALGEBRAIC
/* RG to RG */
- LRG_RRG,
+ // RRG to LRG
+ // LRG to RRG
+
};
enum TFormalism
{
FINITE_AUTOMATA,
+
REGULAR_GRAMMAR,
+ LEFT_REGULAR_GRAMMAR,
+ RIGHT_REGULAR_GRAMMAR,
+
+ LINEAR_GRAMMAR,
+ LEFT_LINEAR_GRAMMAR,
+ RIGHT_LINEAR_GRAMMAR,
+
REGULAR_EXPRESSION,
+
UNKNOWN,
};
+ #define isGrammar(x) ( (x) == REGULAR_GRAMMAR || (x) == LEFT_REGULAR_GRAMMAR || (x) == RIGHT_REGULAR_GRAMMAR \
+ || (x) == LINEAR_GRAMMAR || (x) == LEFT_LINEAR_GRAMMAR || (x) == RIGHT_LINEAR_GRAMMAR )
- ConversionHandler( std::list<sax::Token> & tokens, const std::string & target, const std::string & algorithm );
- void convert( std::ostream & out );
+ ConversionHandler( std::list<sax::Token> & tokens, const std::string & target, const std::string & algorithm, std::ostream & out );
+ void convert( void );
private:
- TFormalism m_source, m_target;
- TAlgorithm m_algorithm;
- std::list<sax::Token> & m_tokens;
-
TFormalism parseFormalismFromString( const std::string & _target ) const;
+ TFormalism parseFormalismFromTokens( void ) const;
TAlgorithm parseAlgorithmFromString( const std::string & _algorithm ) const;
- TAlgorithm getDefaultAlgorithm( void ) const;
- void convertAutomata( std::ostream & out );
- void convertGrammar( std::ostream & out );
- void convertRegExp( std::ostream & out );
- bool checkAlgorithm( void ) const;
+ void convertFSM( void );
+ void convertFSMtoRE( void );
+ void convertFSMtoRG( void );
+ void convertFSMtoLRG( void );
+ void convertFSMtoRRG( void );
+
+ void convertRE( void );
+ void convertREtoFSM( void );
+ void convertREtoRG( void );
+ void convertREtoRRG( void );
+
+ void convertRG( void );
+ void convertRGtoFSM( void );
+ void convertLRGtoFSM( void );
+ void convertRRGtoFSM( void );
+
+ void convertRGtoRE( void );
+ void convertLRGtoRE( void );
+ void convertRRGtoRE( void );
+
+ void convertRGtoRG( void );
+ void convertLRGtoRRG( void );
+ void convertRRGtoLRG( void );
+
+ std::list<sax::Token> & m_tokens;
+ TFormalism m_source, m_target;
+ TAlgorithm m_algorithm;
+ std::ostream & m_out;
};
} /* namespace conversions */
diff --git a/aconversions/src/aconversion/aconversion.cpp b/aconversions/src/aconversion/aconversion.cpp
index 6bcd97c276762bd66e6a9dfa277f273a84a285f8..efc38b7991040294c1e0c014c74d9d7608fd2d82 100644
--- a/aconversions/src/aconversion/aconversion.cpp
+++ b/aconversions/src/aconversion/aconversion.cpp
@@ -25,43 +25,61 @@ void help( void )
cout << "aconversion 0.01" << endl;
cout << "Converts between regular expressions, regular grammars and finite automata." << endl;
cout << "Usage: aconversion -t FORMALISM [SWITCH...]" << endl << endl;
- cout << " -t, --target=FORMALISM \t Specifies target formalism, valid values are 'FA', 'FSM' or 'automaton' for finite automata, 'RE' or 'regexp' for regular expression and 'RG' or 'grammar' for regular grammar." << endl;
+ cout << " -t, --target=FORMALISM \t Specifies target formalism. See --list-algorithms for available formalisms." << endl;
cout << " -a, --algorithm=ALGORITHM \t Specifies algorithm to use. See --list-algorithms." << endl;
- cout << " -l, --list-algorithms \t Lists algorithms to use." << endl;
+ cout << " -l, --list-algorithms \t Lists available algorithms." << endl;
cout << endl;
}
void list_algorithms( void )
{
+ cout << "List of formalisms:" << endl;
+ cout << "\t For finite automata use 'automata', 'fsm' or 'fa'." << endl;
+ cout << "\t For regular expression use 'regexp', 're' or 'regex'." << endl;
+ cout << "\t For right regular grammar use 'rg', 'rrg' or 'grammar'." << endl;
+ cout << "\t For left regular grammar use 'lrg'." << endl;
+ cout << "This list is case-insensitive." << endl;
+
+ cout << endl;
+
cout << "List of available algorithms:" << endl;
- cout << " |" << endl;
- cout << " +- FA to RE:" << endl;
- cout << " | +- 'algebraic' - Converts to RE using Brzozowski algebraic method." << endl;
- cout << " | +- 'elimination' [Default] - Performs state elimination algorithm on NFA." << endl;
+ cout << endl;
+ cout << "FA to RE:" << endl;
+ cout << "\t" << "'algebraic' - Uses Brzozowski algebraic method (regular equations)." << endl;
+ cout << "\t" << "'elimination' [Default] - Performs state elimination algorithm on NFA." << endl;
+
+ cout << endl;
+ cout << "FA to RRG:" << endl;
+ cout << "\t" << "[Default] - Converts to right regular grammar." << endl;
- cout << " +- FA to RG:" << endl;
- cout << " | +- 'left' - Converts to left regular grammar." << endl;
- cout << " | +- 'right' [Default] - Converts to right regular grammar." << endl;
+ cout << endl;
+ cout << "FA to LRG:" << endl;
+ cout << "\t" << "[Default] - Converts to left regular grammar." << endl;
- cout << " +- RE to FA:" << endl;
- cout << " | +- 'brzozowski' - Converts to finite automata using Brzozowski's Derivation method." << endl;
- cout << " | +- 'thompson' - Converts to finite automata using Thompson's NFA Construction algorithm." << endl;
- cout << " | +- 'glushkov' [Default] - Converts to finite automata using Gluskov's NFA algorithm." << endl;
+ cout << endl;
+ cout << "RE to FA:" << endl;
+ cout << "\t" << "'brzozowski' - Uses Brzozowski's derivation method (WARNING: May get stuck in infinite loop)." << endl;
+ cout << "\t" << "'thompson' - Converts to finite automata using Thompson's NFA Construction algorithm." << endl;
+ cout << "\t" << "'glushkov' [Default] - Converts to finite automata using Gluskov's NFA algorithm." << endl;
- cout << " +- RE to RG:" << endl;
- cout << " | +- 'brzozowskirrg' - Converts to right regular grammar using Brzozowski's Derivation Method." << endl;
- cout << " | +- 'glushkovrrg' [Default] - Converts to right regular grammar using Glushkov's algorithm." << endl;
+ cout << endl;
+ cout << "RE to RRG:" << endl;
+ cout << "\t" << "'brzozowski' - Uses Brzozowski's derivation method (WARNING: May get stuck in infinite loop)." << endl;
+ cout << "\t" << "'glushkov' [Default] - Converts to finite automata using Gluskov's NFA algorithm." << endl;
- cout << " +- RG to FA:" << endl;
- cout << " | +- 'rg' [Default] - Converts right or left regular grammar to finite automata." << endl;
+ cout << endl;
+ cout << "RG to FA:" << endl;
+ cout << "\t" << "[Default] - Converts right or left regular grammar to finite automata." << endl;
- cout << " +- RG to RE:" << endl;
- cout << " | +- 'algebraic' [Default] - Converts left or right regular grammar to regexp using Brzozowski's Algebraic method." << endl;
+ cout << endl;
+ cout << "RG to RE:" << endl;
+ cout << "\t" << "'algebraic' [Default] - Uses Brzozowski algebraic method (regular equations)." << endl;
- cout << " +- (L/R)RG to (R/L)RG:" << endl;
- cout << " | +- 'rg' [Default] - Converts right to left regular grammar or vice versa." << endl;
+ cout << endl;
+ cout << "RG to RG:" << endl;
+ cout << "\t" << "[Default] - Converts right to left regular grammar or vice versa." << endl;
}
int main(int argc, char* argv[])
@@ -105,8 +123,8 @@ int main(int argc, char* argv[])
try
{
- ConversionHandler conv( tokens, target, algorithm );
- conv.convert( cout );
+ ConversionHandler conv( tokens, target, algorithm, cout );
+ conv.convert( );
}
catch( AlibException & e )
{
diff --git a/aconversions/src/fa2re/AbstractFAtoREConverter.h b/aconversions/src/fa2re/AbstractFAtoREConverter.h
index 0dee38f1d39f5e318bcbe93e83c9dead556bb3ee..e541a9c4b616cf354a9859aef90a71ccb614ca8e 100644
--- a/aconversions/src/fa2re/AbstractFAtoREConverter.h
+++ b/aconversions/src/fa2re/AbstractFAtoREConverter.h
@@ -20,7 +20,7 @@ public:
protected:
AbstractFAtoREConverter( const automaton::FSM & automaton );
- const automaton::FSM & m_automaton;
+ const automaton::FSM m_automaton;
regexp::RegExp m_re;
};
diff --git a/aconversions/src/fa2rg/AbstractFAtoRGConverter.h b/aconversions/src/fa2rg/AbstractFAtoRGConverter.h
index 796e1fa84cfcc50a260fba08ceb52d6bc23d9fbd..0c0dd826da38209a04b968bafa518f6409562bad 100644
--- a/aconversions/src/fa2rg/AbstractFAtoRGConverter.h
+++ b/aconversions/src/fa2rg/AbstractFAtoRGConverter.h
@@ -25,7 +25,7 @@ public:
~AbstractFAtoRGConverter( void );
protected:
- const automaton::FSM & m_fsm;
+ const automaton::FSM m_fsm;
};
} /* namespace conversions */
diff --git a/aconversions/src/re2fa/AbstractREtoFAConverter.h b/aconversions/src/re2fa/AbstractREtoFAConverter.h
index e7fd3b85242f2ed5d8bd7bc72da692975fb46742..7d348a0981b03d2693e6f75c2d14c78f7d26cdca 100644
--- a/aconversions/src/re2fa/AbstractREtoFAConverter.h
+++ b/aconversions/src/re2fa/AbstractREtoFAConverter.h
@@ -21,7 +21,7 @@ public:
protected:
AbstractREtoFAConverter(const regexp::RegExp & re );
- const regexp::RegExp & m_re;
+ const regexp::RegExp m_re;
automaton::FSM m_fsm;
};
diff --git a/aconversions/src/re2fa/Glushkov.cpp b/aconversions/src/re2fa/Glushkov.cpp
index ccf00c4b0d2893398e9d54d50d8a2781c7c75593..98fa8e88eafa4aed3cbabba49ef1a26b6a5f4c00 100644
--- a/aconversions/src/re2fa/Glushkov.cpp
+++ b/aconversions/src/re2fa/Glushkov.cpp
@@ -105,7 +105,8 @@ bool Glushkov::NumberedSymbol::operator<( const NumberedSymbol & x ) const
Glushkov::NumberedSymbol::NumberedSymbol( const RegExpSymbol * symbol, int i ) :
m_i( i ),
m_alphabetSymbol( symbol->getSymbol( ) ),
- m_state( State( "[" + m_alphabetSymbol.getSymbol( ) + "], id " + to_string( m_i ) ) )
+ //m_state( State( "[" + m_alphabetSymbol.getSymbol( ) + "], id " + to_string( m_i ) ) )
+ m_state( State( to_string( m_i ) ) )
{
}
diff --git a/aconversions/src/re2rg/AbstractREtoRGConverter.h b/aconversions/src/re2rg/AbstractREtoRGConverter.h
index e3a54c2a533d041cc9fdbe6bdd1beaf1f2aaac05..a97b41cce5df8031d37abab633981f9f933d1207 100644
--- a/aconversions/src/re2rg/AbstractREtoRGConverter.h
+++ b/aconversions/src/re2rg/AbstractREtoRGConverter.h
@@ -24,7 +24,7 @@ public:
protected:
AbstractREtoRGConverter( const regexp::RegExp & re );
- const regexp::RegExp & m_re;
+ const regexp::RegExp m_re;
};
} /* namespace conversions */
diff --git a/aconversions/src/re2rg/re2rrg/GlushkovRRG.cpp b/aconversions/src/re2rg/re2rrg/GlushkovRRG.cpp
index 0fb53d9938b96d3f23ed1d0aedf8b88ad686ab67..4416d1fcb63c7107721d7938be4dc5c76583550f 100644
--- a/aconversions/src/re2rg/re2rrg/GlushkovRRG.cpp
+++ b/aconversions/src/re2rg/re2rrg/GlushkovRRG.cpp
@@ -29,11 +29,11 @@ GlushkovRRG::~GlushkovRRG( void )
RightRegularGrammar GlushkovRRG::convert( void )
{
// step 1
- initNumberSymbols( );
-
for( const auto & symbol : RegExpAlphabet::getSymbols( m_re ) )
m_grammar.addTerminalSymbol( symbol.getSymbol( ) );
+ initNumberSymbols( );
+
// steps 2, 3, 4
constructBeginSymbolSet( );
constructEndSymbolSet( );
@@ -136,7 +136,8 @@ bool GlushkovRRG::NumberedSymbol::operator<( const NumberedSymbol & x ) const
GlushkovRRG::NumberedSymbol::NumberedSymbol( const RegExpSymbol * symbol, grammar::RightRegularGrammar & g, int i ) :
m_i( i ),
m_alphabetSymbol( symbol->getSymbol( ) ),
- m_nonTerminal( g.createUniqueNonTerminalSymbol( "[" + m_alphabetSymbol.getSymbol( ) + "], id " + to_string( m_i ), false ) )
+ // m_nonTerminal( g.createUniqueNonTerminalSymbol( "[" + m_alphabetSymbol.getSymbol( ) + "], id " + to_string( m_i ), false ) )
+ m_nonTerminal( g.createUniqueNonTerminalSymbol( to_string( m_i ), false ) )
{
}
diff --git a/aconversions/src/rg2fa/AbstractRGtoFAConverter.cpp b/aconversions/src/rg2fa/AbstractRGtoFAConverter.cpp
index a6b56bdd8a5c1c9c195d6ce331c8cf9eb53f93fd..c7439b614ea9ffce7cc6765f2dc23f2641dc9011 100644
--- a/aconversions/src/rg2fa/AbstractRGtoFAConverter.cpp
+++ b/aconversions/src/rg2fa/AbstractRGtoFAConverter.cpp
@@ -1,13 +1,9 @@
#include "AbstractRGtoFAConverter.h"
-using namespace alphabet;
-using namespace automaton;
-using namespace grammar;
-
namespace conversions
{
-AbstractRGtoFAConverter::AbstractRGtoFAConverter( const RegularGrammar& grammar ) : m_grammar( grammar )
+AbstractRGtoFAConverter::AbstractRGtoFAConverter( void )
{
}
@@ -17,16 +13,4 @@ AbstractRGtoFAConverter::~AbstractRGtoFAConverter( void )
}
-void AbstractRGtoFAConverter::createInputAlphabet( void )
-{
- for( set<Symbol>::const_iterator i = m_grammar.getTerminalSymbols().begin(); i != m_grammar.getTerminalSymbols().end(); i++ )
- m_automaton . addInputSymbol( *i );
-}
-
-void AbstractRGtoFAConverter::createStates( void )
-{
- for( set<Symbol>::const_iterator i = m_grammar.getNonTerminalSymbols().begin(); i != m_grammar.getNonTerminalSymbols().end(); i++ )
- m_automaton . addState( State( i-> getSymbol() ) );
-}
-
} /* namespace conversions */
diff --git a/aconversions/src/rg2fa/AbstractRGtoFAConverter.h b/aconversions/src/rg2fa/AbstractRGtoFAConverter.h
index 8555e31f75a7b4c07342fd4990e8fbb66e98ff63..226fff1e31f242660d3493d7f4186ce77daf449f 100644
--- a/aconversions/src/rg2fa/AbstractRGtoFAConverter.h
+++ b/aconversions/src/rg2fa/AbstractRGtoFAConverter.h
@@ -2,8 +2,6 @@
#define __ABSTRACTRGTOFACONVERTER_H__
#include <automaton/FSM/FSM.h>
-#include <grammar/Regular/RegularGrammar.h>
-
#include <AlibException.h>
#include "../include/macros.h"
@@ -19,11 +17,8 @@ public:
virtual ~AbstractRGtoFAConverter( void );
protected:
- AbstractRGtoFAConverter( const grammar::RegularGrammar& grammar );
- void createStates( void );
- void createInputAlphabet( void );
+ AbstractRGtoFAConverter( void );
- const grammar::RegularGrammar& m_grammar;
automaton::FSM m_automaton;
};
diff --git a/aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.cpp b/aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..3fe26c9770e867ad7d3c7714064c194c7c3b428e
--- /dev/null
+++ b/aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.cpp
@@ -0,0 +1,25 @@
+/*
+ * 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
new file mode 100644
index 0000000000000000000000000000000000000000..e88a28f5e1593aeb3ad003f0524dcc7d33b7b0bf
--- /dev/null
+++ b/aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.h
@@ -0,0 +1,31 @@
+/*
+ * 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
+{
+
+class AbstractLRGtoFAConverter: public AbstractRGtoFAConverter
+{
+public:
+ ~AbstractLRGtoFAConverter( void );
+
+protected:
+ AbstractLRGtoFAConverter( const grammar::LeftRegularGrammar & lrg );
+ const grammar::LeftRegularGrammar m_grammar;
+
+};
+
+} /* namespace conversions */
+
+#endif /* ABSTRACTLRGTOFACONVERTER_H_ */
diff --git a/aconversions/src/rg2fa/LRGtoFAConverter.cpp b/aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.cpp
similarity index 84%
rename from aconversions/src/rg2fa/LRGtoFAConverter.cpp
rename to aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.cpp
index fdea21b7a2aea75fffae7c475898b165bdb33d53..53d0c68b11dac2e3fc70d8f54623392629bc407d 100644
--- a/aconversions/src/rg2fa/LRGtoFAConverter.cpp
+++ b/aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.cpp
@@ -7,7 +7,7 @@ using namespace grammar;
namespace conversions
{
-LRGtoFAConverter::LRGtoFAConverter( const LeftRegularGrammar & grammar ) : AbstractRGtoFAConverter( grammar )
+LRGtoFAConverter::LRGtoFAConverter( const LeftRegularGrammar & grammar ) : AbstractLRGtoFAConverter( grammar )
{
//TODO: if is not LRG throw Exception
}
@@ -19,8 +19,11 @@ LRGtoFAConverter::~LRGtoFAConverter( void )
FSM LRGtoFAConverter::convert( void )
{
- createInputAlphabet( );
- createStates( );
+ for( const auto & symbol : m_grammar.getTerminalSymbols( ) )
+ m_automaton.addInputSymbol( symbol );
+
+ for( const auto & symbol : m_grammar.getNonTerminalSymbols( ) )
+ m_automaton.addState( State( symbol.getSymbol( ) ) );
const State & startState = m_automaton.createUniqueState( "q0", true );
diff --git a/aconversions/src/rg2fa/LRGtoFAConverter.h b/aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.h
similarity index 63%
rename from aconversions/src/rg2fa/LRGtoFAConverter.h
rename to aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.h
index f0f9a39b9e687f49f0c3c09b2bc6eb60ae1ea532..f36e9df91808cff28a6038c587dcfa56102a2ad8 100644
--- a/aconversions/src/rg2fa/LRGtoFAConverter.h
+++ b/aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.h
@@ -1,15 +1,12 @@
#ifndef __LRGTOFACONVERTER_H__
#define __LRGTOFACONVERTER_H__
-#include <automaton/FSM/FSM.h>
-#include <grammar/Regular/LeftRegularGrammar.h>
-
-#include "AbstractRGtoFAConverter.h"
+#include "AbstractLRGtoFAConverter.h"
namespace conversions
{
-class LRGtoFAConverter : public AbstractRGtoFAConverter
+class LRGtoFAConverter : public AbstractLRGtoFAConverter
{
public:
LRGtoFAConverter( const grammar::LeftRegularGrammar & grammar );
diff --git a/aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.cpp b/aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..c67474eb5058a25a39d01358416d8104ea02621f
--- /dev/null
+++ b/aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.cpp
@@ -0,0 +1,25 @@
+/*
+ * 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
new file mode 100644
index 0000000000000000000000000000000000000000..54347239fa655d8f02c10d88531dd9cded66e554
--- /dev/null
+++ b/aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.h
@@ -0,0 +1,30 @@
+/*
+ * 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
+{
+
+class AbstractRRGtoFAConverter: public conversions::AbstractRGtoFAConverter
+{
+public:
+ virtual ~AbstractRRGtoFAConverter( void );
+
+protected:
+ AbstractRRGtoFAConverter( const grammar::RightRegularGrammar & rrg );
+ const grammar::RightRegularGrammar m_grammar;
+};
+
+} /* namespace conversions */
+
+#endif /* ABSTRACTRRGTOFACONVERTER_H_ */
diff --git a/aconversions/src/rg2fa/RRGtoFAConverter.cpp b/aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.cpp
similarity index 84%
rename from aconversions/src/rg2fa/RRGtoFAConverter.cpp
rename to aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.cpp
index ffe18ba402d300560510bf6419b36030e07eac49..9788b5f3e7fc47189c31e6f84dcd60319113c9e7 100644
--- a/aconversions/src/rg2fa/RRGtoFAConverter.cpp
+++ b/aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.cpp
@@ -7,7 +7,7 @@ using namespace grammar;
namespace conversions
{
-RRGtoFAConverter::RRGtoFAConverter( const RightRegularGrammar & grammar ) : AbstractRGtoFAConverter( grammar )
+RRGtoFAConverter::RRGtoFAConverter( const RightRegularGrammar & grammar ) : AbstractRRGtoFAConverter( grammar )
{
//TODO: if is not RRG throw Exception
}
@@ -20,8 +20,11 @@ RRGtoFAConverter::~RRGtoFAConverter( void )
FSM RRGtoFAConverter::convert( void )
{
- createInputAlphabet( );
- createStates( );
+ for( const auto & symbol : m_grammar.getTerminalSymbols( ) )
+ m_automaton.addInputSymbol( symbol );
+
+ for( const auto & symbol : m_grammar.getNonTerminalSymbols( ) )
+ m_automaton.addState( State( symbol.getSymbol( ) ) );
const State & AState = m_automaton.createUniqueState( "A", true );
diff --git a/aconversions/src/rg2fa/RRGtoFAConverter.h b/aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.h
similarity index 63%
rename from aconversions/src/rg2fa/RRGtoFAConverter.h
rename to aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.h
index f8230cbe839f34a00dc337abb60620e70def06db..32d5117e134ed8990c88d3d4a16982f63f0226da 100644
--- a/aconversions/src/rg2fa/RRGtoFAConverter.h
+++ b/aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.h
@@ -1,15 +1,12 @@
#ifndef __RRGTOFACONVERTER_H__
#define __RRGTOFACONVERTER_H__
-#include <grammar/Regular/RightRegularGrammar.h>
-#include <automaton/FSM/FSM.h>
-
-#include "AbstractRGtoFAConverter.h"
+#include "AbstractRRGtoFAConverter.h"
namespace conversions
{
-class RRGtoFAConverter : public AbstractRGtoFAConverter
+class RRGtoFAConverter : public AbstractRRGtoFAConverter
{
public:
RRGtoFAConverter( const grammar::RightRegularGrammar & grammar );
diff --git a/aconversions/src/rg2re/AbstractRGtoREConverter.cpp b/aconversions/src/rg2re/AbstractRGtoREConverter.cpp
index 95fb644460a43cbb7ffa6f820411f0b2cf6717e8..60bae347d1021ee6066a20e4afb6eca2dd8f8a15 100644
--- a/aconversions/src/rg2re/AbstractRGtoREConverter.cpp
+++ b/aconversions/src/rg2re/AbstractRGtoREConverter.cpp
@@ -7,12 +7,10 @@
#include "AbstractRGtoREConverter.h"
-using namespace grammar;
-
namespace conversions
{
-AbstractRGtoREConverter::AbstractRGtoREConverter( const RegularGrammar & grammar ) : m_grammar( grammar )
+AbstractRGtoREConverter::AbstractRGtoREConverter( void )
{
}
diff --git a/aconversions/src/rg2re/AbstractRGtoREConverter.h b/aconversions/src/rg2re/AbstractRGtoREConverter.h
index 7eda2748b1f772c9565264b9f3fb5ffcb3cf320f..a333f37ae2e16844d6181c96485a9ddd366fd3ce 100644
--- a/aconversions/src/rg2re/AbstractRGtoREConverter.h
+++ b/aconversions/src/rg2re/AbstractRGtoREConverter.h
@@ -8,7 +8,6 @@
#ifndef ABSTRACTRGTORECONVERTER_H_
#define ABSTRACTRGTORECONVERTER_H_
-#include <grammar/Regular/RegularGrammar.h>
#include <regexp/RegExp.h>
#include "../abstract/Conversion.h"
@@ -23,9 +22,8 @@ public:
virtual ~AbstractRGtoREConverter( void );
protected:
- AbstractRGtoREConverter( const grammar::RegularGrammar& grammar );
+ AbstractRGtoREConverter( void );
- const grammar::RegularGrammar& m_grammar;
regexp::RegExp m_re;
};
diff --git a/aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.cpp b/aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..10e34c2d20eda3f79c716f373a143bf4358660ff
--- /dev/null
+++ b/aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.cpp
@@ -0,0 +1,25 @@
+/*
+ * 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
new file mode 100644
index 0000000000000000000000000000000000000000..f6d406336b86eb6e5374e4b1da896b08dddb8add
--- /dev/null
+++ b/aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.h
@@ -0,0 +1,30 @@
+/*
+ * 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:
+ AbstractLRGtoREConverter( const grammar::LeftRegularGrammar & lrg );
+ const grammar::LeftRegularGrammar m_grammar;
+};
+
+} /* namespace conversions */
+
+#endif /* ABSTRACTLRGTORECONVERTER_H_ */
diff --git a/aconversions/src/rg2re/LRGAlgebraic.cpp b/aconversions/src/rg2re/lrg2re/LRGAlgebraic.cpp
similarity index 97%
rename from aconversions/src/rg2re/LRGAlgebraic.cpp
rename to aconversions/src/rg2re/lrg2re/LRGAlgebraic.cpp
index 909a47320af903155549af01def8b134af181fe4..deb33731f0cf1fcdc59ab89e85bba7951562c887 100644
--- a/aconversions/src/rg2re/LRGAlgebraic.cpp
+++ b/aconversions/src/rg2re/lrg2re/LRGAlgebraic.cpp
@@ -14,7 +14,7 @@ using namespace regexp;
namespace conversions
{
-LRGAlgebraic::LRGAlgebraic( const LeftRegularGrammar & rg ) : AbstractRGtoREConverter( rg )
+LRGAlgebraic::LRGAlgebraic( const LeftRegularGrammar & rg ) : AbstractLRGtoREConverter( rg )
{
}
diff --git a/aconversions/src/rg2re/LRGAlgebraic.h b/aconversions/src/rg2re/lrg2re/LRGAlgebraic.h
similarity index 64%
rename from aconversions/src/rg2re/LRGAlgebraic.h
rename to aconversions/src/rg2re/lrg2re/LRGAlgebraic.h
index e1cec275f6373127262f93d59cd6229c5dc7eddf..e0abf34ada5a77b763fd7fd90aed6e1d0fa8ff57 100644
--- a/aconversions/src/rg2re/LRGAlgebraic.h
+++ b/aconversions/src/rg2re/lrg2re/LRGAlgebraic.h
@@ -8,16 +8,13 @@
#ifndef LRGALGEBRAIC_H_
#define LRGALGEBRAIC_H_
-#include <grammar/Regular/LeftRegularGrammar.h>
-#include <regexp/RegExp.h>
-
-#include "../shared/equations/LeftRegularEquationSolver.h"
-#include "AbstractRGtoREConverter.h"
+#include "../../shared/equations/LeftRegularEquationSolver.h"
+#include "AbstractLRGtoREConverter.h"
namespace conversions
{
-class LRGAlgebraic: public AbstractRGtoREConverter
+class LRGAlgebraic: public AbstractLRGtoREConverter
{
public:
LRGAlgebraic( const grammar::LeftRegularGrammar & rg );
diff --git a/aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.cpp b/aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..0a3c41ad1041a5f3772ccdc1e2f0623ff51cf325
--- /dev/null
+++ b/aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.cpp
@@ -0,0 +1,25 @@
+/*
+ * 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
new file mode 100644
index 0000000000000000000000000000000000000000..83de063ecdaaea294493887c225807247a06148d
--- /dev/null
+++ b/aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.h
@@ -0,0 +1,31 @@
+/*
+ * 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:
+ AbstractRRGtoREConverter( const grammar::RightRegularGrammar & rrg );
+
+ const grammar::RightRegularGrammar m_grammar;
+};
+
+} /* namespace conversions */
+
+#endif /* ABSTRACTRRGTORECONVERTER_H_ */
diff --git a/aconversions/src/rg2re/RRGAlgebraic.cpp b/aconversions/src/rg2re/rrg2re/RRGAlgebraic.cpp
similarity index 97%
rename from aconversions/src/rg2re/RRGAlgebraic.cpp
rename to aconversions/src/rg2re/rrg2re/RRGAlgebraic.cpp
index d0f7cbdf4fc328eaa3d1821f623b610cabbdb91b..87a2b7a2d543853b9b4b37353ddba0e208abf7cf 100644
--- a/aconversions/src/rg2re/RRGAlgebraic.cpp
+++ b/aconversions/src/rg2re/rrg2re/RRGAlgebraic.cpp
@@ -14,7 +14,7 @@ using namespace regexp;
namespace conversions
{
-RRGAlgebraic::RRGAlgebraic( const RightRegularGrammar & rg ) : AbstractRGtoREConverter( rg )
+RRGAlgebraic::RRGAlgebraic( const RightRegularGrammar & rg ) : AbstractRRGtoREConverter( rg )
{
}
diff --git a/aconversions/src/rg2re/RRGAlgebraic.h b/aconversions/src/rg2re/rrg2re/RRGAlgebraic.h
similarity index 64%
rename from aconversions/src/rg2re/RRGAlgebraic.h
rename to aconversions/src/rg2re/rrg2re/RRGAlgebraic.h
index b1f59bba91ca9da5074fb557e8a0a9a44cc0a1ce..85b907effbd71e9f2f4c0f52f1e1d75d1ff7f1b3 100644
--- a/aconversions/src/rg2re/RRGAlgebraic.h
+++ b/aconversions/src/rg2re/rrg2re/RRGAlgebraic.h
@@ -8,16 +8,13 @@
#ifndef RRGALGEBRAIC_H_
#define RRGALGEBRAIC_H_
-#include <grammar/Regular/RightRegularGrammar.h>
-#include <regexp/RegExp.h>
-
-#include "../shared/equations/RightRegularEquationSolver.h"
-#include "AbstractRGtoREConverter.h"
+#include "../../shared/equations/RightRegularEquationSolver.h"
+#include "AbstractRRGtoREConverter.h"
namespace conversions
{
-class RRGAlgebraic: public AbstractRGtoREConverter
+class RRGAlgebraic: public AbstractRRGtoREConverter
{
public:
RRGAlgebraic( const grammar::RightRegularGrammar & rg );
diff --git a/aconversions/src/lrg2rrg/AbstractLRGtoRRGConverter.cpp b/aconversions/src/rg2rg/lrg2rrg/AbstractLRGtoRRGConverter.cpp
similarity index 100%
rename from aconversions/src/lrg2rrg/AbstractLRGtoRRGConverter.cpp
rename to aconversions/src/rg2rg/lrg2rrg/AbstractLRGtoRRGConverter.cpp
diff --git a/aconversions/src/lrg2rrg/AbstractLRGtoRRGConverter.h b/aconversions/src/rg2rg/lrg2rrg/AbstractLRGtoRRGConverter.h
similarity index 88%
rename from aconversions/src/lrg2rrg/AbstractLRGtoRRGConverter.h
rename to aconversions/src/rg2rg/lrg2rrg/AbstractLRGtoRRGConverter.h
index eedc24309a9a2d87be797d47a8185d82e60921ae..637f25bedc1a3f8016becb872f015442be642782 100644
--- a/aconversions/src/lrg2rrg/AbstractLRGtoRRGConverter.h
+++ b/aconversions/src/rg2rg/lrg2rrg/AbstractLRGtoRRGConverter.h
@@ -11,7 +11,7 @@
#include <grammar/Regular/LeftRegularGrammar.h>
#include <grammar/Regular/RightRegularGrammar.h>
-#include "../abstract/Conversion.h"
+#include "../../abstract/Conversion.h"
namespace conversions
{
@@ -25,7 +25,7 @@ public:
protected:
AbstractLRGtoRRGConverter( const grammar::LeftRegularGrammar & lrg );
- const grammar::LeftRegularGrammar & m_lrg;
+ const grammar::LeftRegularGrammar m_lrg;
grammar::RightRegularGrammar m_rrg;
};
diff --git a/aconversions/src/lrg2rrg/LeftToRightRegularGrammar.cpp b/aconversions/src/rg2rg/lrg2rrg/LeftToRightRegularGrammar.cpp
similarity index 100%
rename from aconversions/src/lrg2rrg/LeftToRightRegularGrammar.cpp
rename to aconversions/src/rg2rg/lrg2rrg/LeftToRightRegularGrammar.cpp
diff --git a/aconversions/src/lrg2rrg/LeftToRightRegularGrammar.h b/aconversions/src/rg2rg/lrg2rrg/LeftToRightRegularGrammar.h
similarity index 100%
rename from aconversions/src/lrg2rrg/LeftToRightRegularGrammar.h
rename to aconversions/src/rg2rg/lrg2rrg/LeftToRightRegularGrammar.h
diff --git a/aconversions/src/rrg2lrg/AbstractRRGtoLRGConverter.cpp b/aconversions/src/rg2rg/rrg2lrg/AbstractRRGtoLRGConverter.cpp
similarity index 100%
rename from aconversions/src/rrg2lrg/AbstractRRGtoLRGConverter.cpp
rename to aconversions/src/rg2rg/rrg2lrg/AbstractRRGtoLRGConverter.cpp
diff --git a/aconversions/src/rrg2lrg/AbstractRRGtoLRGConverter.h b/aconversions/src/rg2rg/rrg2lrg/AbstractRRGtoLRGConverter.h
similarity index 88%
rename from aconversions/src/rrg2lrg/AbstractRRGtoLRGConverter.h
rename to aconversions/src/rg2rg/rrg2lrg/AbstractRRGtoLRGConverter.h
index 54aa96b4483e7d3590797258da1cc35fb3683150..0c2cca11c2cf1c7ef3f5fcdfdcd3c182a98903a0 100644
--- a/aconversions/src/rrg2lrg/AbstractRRGtoLRGConverter.h
+++ b/aconversions/src/rg2rg/rrg2lrg/AbstractRRGtoLRGConverter.h
@@ -8,7 +8,7 @@
#ifndef ABSTRACTRRGTOLRGCONVERTER_H_
#define ABSTRACTRRGTOLRGCONVERTER_H_
-#include "../abstract/Conversion.h"
+#include "../../abstract/Conversion.h"
#include <grammar/Regular/LeftRegularGrammar.h>
#include <grammar/Regular/RightRegularGrammar.h>
@@ -24,7 +24,7 @@ public:
virtual grammar::LeftRegularGrammar convert( void ) = 0;
protected:
- const grammar::RightRegularGrammar & m_rrg;
+ const grammar::RightRegularGrammar m_rrg;
grammar::LeftRegularGrammar m_lrg;
};
diff --git a/aconversions/src/rrg2lrg/RightToLeftRegularGrammar.cpp b/aconversions/src/rg2rg/rrg2lrg/RightToLeftRegularGrammar.cpp
similarity index 100%
rename from aconversions/src/rrg2lrg/RightToLeftRegularGrammar.cpp
rename to aconversions/src/rg2rg/rrg2lrg/RightToLeftRegularGrammar.cpp
diff --git a/aconversions/src/rrg2lrg/RightToLeftRegularGrammar.h b/aconversions/src/rg2rg/rrg2lrg/RightToLeftRegularGrammar.h
similarity index 100%
rename from aconversions/src/rrg2lrg/RightToLeftRegularGrammar.h
rename to aconversions/src/rg2rg/rrg2lrg/RightToLeftRegularGrammar.h