diff --git a/aconversions2/src/ConversionHandler.cpp b/aconversions2/src/ConversionHandler.cpp
index 26cee600864052786d13011fa8a68cf9b9945772..0e90d271fbfc9f7f94443ca38f0d815b004b3ffc 100644
--- a/aconversions2/src/ConversionHandler.cpp
+++ b/aconversions2/src/ConversionHandler.cpp
@@ -352,7 +352,7 @@ void ConversionHandler::convertRTEtoPDA ( void ) {
break;
}
case GLUSHKOV_RTE_V3: {
- automaton::NPDA < > automaton = rte::convert::ToPostfixPushdownAutomatonGlushkovV3::convert ( rte );
+ automaton::Automaton automaton = rte::convert::ToPostfixPushdownAutomatonGlushkovV3::convert ( rte );
measurements::end ( );
measurements::start ( "Output write", measurements::Type::AUXILIARY );
diff --git a/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkovV3.cpp b/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkovV3.cpp
index 6dcaeb5deb957c238c7f850d9ebb75933067bb30..86dd2065403a09ed2d0d114a78fa9473b5866bfb 100644
--- a/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkovV3.cpp
+++ b/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkovV3.cpp
@@ -7,17 +7,16 @@
#include "ToPostfixPushdownAutomatonGlushkovV3.h"
-#include "alphabet/BottomOfTheStackSymbol.h"
-#include "alphabet/EndSymbol.h"
-
#include <automaton/Automaton.h>
+#include <alphabet/BottomOfTheStackSymbol.h>
+#include <alphabet/EndSymbol.h>
-#include "global/GlobalData.h"
+#include <global/GlobalData.h>
+#include <registration/AlgoRegistration.hpp>
#include "../glushkov/GlushkovFollowV3.h"
#include "../glushkov/GlushkovIndexate.h"
#include "../glushkov/GlushkovFirst.h"
-#include <registration/AlgoRegistration.hpp>
namespace rte {
@@ -27,13 +26,6 @@ automaton::Automaton ToPostfixPushdownAutomatonGlushkovV3::convert ( const rte::
return dispatch ( rte.getData ( ) );
}
-/*
-std::vector < DefaultSymbolType > phi ( const std::vector < std::ranked_symbol < > > & follow ) {
- return std::transform < DefaultSymbolType > ( follow, []( const std::ranked_symbol < > & symbol ) { return DefaultSymbolType ( alphabet::RankedSymbol < > ( symbol ) ); } );
-}
-
-*/
-
template < class SymbolType, class RankType >
bool ToPostfixPushdownAutomatonGlushkovV3::isSubstSymbolPresent ( const std::set < std::ranked_symbol < SymbolType, RankType > > & container, const TAlphabet < SymbolType, RankType > & substAlphabet ) {
std::vector < std::ranked_symbol < > > intersection;
@@ -75,8 +67,8 @@ ToPostfixPushdownAutomatonGlushkovV3::convert ( const rte::FormalRTE < > & rte )
DefaultStateType q = DefaultStateType ( 'q' );
DefaultStateType f = DefaultStateType ( 'f' );
- auto bots = std::variant < alphabet::BottomOfTheStackSymbol, std::set < std::ranked_symbol < SymbolType, RankType > > >::template from < alphabet::BottomOfTheStackSymbol > ( );
- automaton::NPDA < SymbolType, DefaultEpsilonType, std::variant < alphabet::BottomOfTheStackSymbol, std::set < std::ranked_symbol < SymbolType, RankType > > >, DefaultStateType > automaton ( q, bots );
+ auto BotS = std::variant < alphabet::BottomOfTheStackSymbol, std::set < std::ranked_symbol < SymbolType, RankType > > >::template from < alphabet::BottomOfTheStackSymbol > ( );
+ automaton::NPDA < SymbolType, DefaultEpsilonType, std::variant < alphabet::BottomOfTheStackSymbol, std::set < std::ranked_symbol < SymbolType, RankType > > >, DefaultStateType > automaton ( q, BotS );
automaton.addState ( f );
automaton.addFinalState ( f );
@@ -86,13 +78,22 @@ ToPostfixPushdownAutomatonGlushkovV3::convert ( const rte::FormalRTE < > & rte )
automaton.addInputSymbol ( alphabet::EndSymbol::instance < DefaultSymbolType > ( ) );
- // step 4; create pushdown store alphabet; it consists of elements of indexed RTE alphabet and BotS symbol
- /*
+ // step 4; create pushdown store alphabet;
+
+ // simple
for ( const std::ranked_symbol < > & symb : indexedRTE.getAlphabet ( ) )
- automaton.addPushdownStoreSymbol ( DefaultSymbolType ( alphabet::RankedSymbol < > ( symb ) ) );
- */
+ automaton.addPushdownStoreSymbol ( std::variant < alphabet::BottomOfTheStackSymbol, std::set < std::ranked_symbol < SymbolType, RankType > > > ( { symb } ) );
- /* DEBUG */
+ // complex
+ for ( const std::pair < const std::ranked_symbol < >, std::set < GlushkovFollowV3::TFollowTuple < SymbolType, RankType > > >& kv : followSet ) {
+ for ( const GlushkovFollowV3::TFollowTuple < SymbolType, RankType > & followTuple : kv.second ) {
+ for ( const std::set < std::ranked_symbol < > > & symb : followTuple ) {
+ automaton.addPushdownStoreSymbol ( std::variant < alphabet::BottomOfTheStackSymbol, std::set < std::ranked_symbol < SymbolType, RankType > > > ( symb ) );
+ }
+ }
+ }
+
+ /* DEBUG */
if ( common::GlobalData::verbose ) {
std::cerr << "RTE:" << std::endl;
@@ -108,46 +109,177 @@ ToPostfixPushdownAutomatonGlushkovV3::convert ( const rte::FormalRTE < > & rte )
std::cerr << std::endl;
- for ( const auto & kv : followSet ) {
+ // std::map < std::ranked_symbol < >, std::set < GlushkovFollowV3::TFollowTuple < SymbolType, RankType > > > followSet;
+ for ( const std::pair < const std::ranked_symbol < >, std::set < GlushkovFollowV3::TFollowTuple < SymbolType, RankType > > >& kv : followSet ) {
std::cerr << "Follow(RTE, " << kv.first << "):" << std::endl;
if ( kv.second.empty ( ) )
std::cerr << "\t" << "{}" << std::endl;
- for ( const auto & follow : kv.second ) {
- for ( const auto & symbol : follow )
- std::cerr << "\t" << symbol << std::endl;
+ for ( const GlushkovFollowV3::TFollowTuple < SymbolType, RankType > & followTuple : kv.second ) { // TFollowTuple = vector < set < ranked_symbol > >
+ std::cerr << " \t - FollowTuple:" << std::endl;
+ for ( const std::set < std::ranked_symbol < > > & child : followTuple )
+ std::cerr << "\t\t - " << child << std::endl;
std::cerr << std::endl;
}
std::cerr << std::endl;
}
+
+ std::cerr << "---------------------------------------------------------" << std::endl;
+ std::cerr << "PDA:" << std::endl;
+ std::cerr << "pds symbols" << std::endl;
+
+ for ( const auto & symb : automaton.getPushdownStoreAlphabet ( ) )
+ std::cerr << "\t" << symb << std::endl;
+ std::cerr << std::endl;
}
/* DEBUG END */
- /*
+
+ /* TRANSITIONS */
+ // Pattern 3
+ for ( const std::ranked_symbol < > & symb : indexedRTE.getAlphabet ( ) ) {
+ if ( symb.getRank ( ) == primitive::Unsigned ( 0 ) ) {
+ std::vector < std::variant < alphabet::BottomOfTheStackSymbol, std::set < std::ranked_symbol < SymbolType, RankType > > > > push;
+ push.push_back( std::set < std::ranked_symbol < SymbolType, RankType > > { symb } );
+
+ automaton.addTransition ( q, rte::GlushkovIndexate::getSymbolFromGlushkovPair ( symb ).getSymbol ( ), { }, q, push );
+ if ( common::GlobalData::verbose ) {
+ std::cerr << "1: " << rte::GlushkovIndexate::getSymbolFromGlushkovPair ( symb ).getSymbol ( ) << " | " << std::endl <<
+ "\t" << "[]" << std::endl <<
+ "\t ->" << std::endl <<
+ "\t" << push << std::endl << std::endl;
+ }
+ }
+ }
+
+
+ // Pattern 2
for ( const std::ranked_symbol < > & symb : indexedRTE.getAlphabet ( ) ) {
- if ( symb.getRank ( ) == primitive::Unsigned ( 0 ) )
- automaton.addTransition ( q, rte::GlushkovIndexate::getSymbolFromGlushkovPair ( symb ).getSymbol ( ), { }, q, { DefaultSymbolType ( alphabet::RankedSymbol < > ( symb ) ) } );
- else;
- //for ( const std::vector < std::ranked_symbol < > > & follow : followSet[symb] ) {
- //std::vector < DefaultSymbolType > fstring = phi ( follow );
- //std::reverse ( fstring.begin ( ), fstring.end ( ) );
- //automaton.addTransition ( q, rte::GlushkovIndexate::getSymbolFromGlushkovPair ( symb ).getSymbol ( ), fstring, q, { DefaultSymbolType ( alphabet::RankedSymbol < > ( symb ) ) } );
- //}
+ if ( symb.getRank ( ) != primitive::Unsigned ( 0 ) ) {
+ for ( const GlushkovFollowV3::TFollowTuple < SymbolType, RankType > & followTuple : followSet [ symb ] ) { //tuple = vector < set < symb > >
+ std::vector < std::variant < alphabet::BottomOfTheStackSymbol, std::set < std::ranked_symbol < SymbolType, RankType > > > > pop, push;
+
+ /*
+ for ( const auto & e : symbFollowTuple )
+ pop.push_back ( e );
+ std::reverse ( pop.begin ( ), pop.end ( ) ); // <------------ WTF. CRASHES HERE
+ */
+ for ( const auto & e : followTuple )
+ pop.insert ( pop.begin ( ), e );
+
+ push.push_back( std::set < std::ranked_symbol < SymbolType, RankType > > { symb } );
+
+ automaton.addTransition ( q, rte::GlushkovIndexate::getSymbolFromGlushkovPair ( symb ).getSymbol ( ), pop, q, push );
+ if ( common::GlobalData::verbose ) {
+ std::cerr << "2: " << rte::GlushkovIndexate::getSymbolFromGlushkovPair ( symb ).getSymbol ( ) << " | " << std::endl <<
+ "\t" << pop << std::endl <<
+ "\t ->" << std::endl <<
+ "\t" << push << std::endl << std::endl;
+ }
+ }
+ }
+ }
+ // Pattern 1
+ for ( const std::ranked_symbol < > & symb : indexedRTE.getAlphabet ( ) ) {
+ // 1a
+ if ( symb.getRank ( ) == primitive::Unsigned ( 0 ) ) {
+ /* If symb \in some symbolSet of followSet [ i ], then symb | \varepsilon -> symbolSet */
+
+ for ( const std::pair < const std::ranked_symbol < >, std::set < GlushkovFollowV3::TFollowTuple < SymbolType, RankType > > >& kv : followSet ) {
+ for ( const GlushkovFollowV3::TFollowTuple < SymbolType, RankType > & followTuple : kv.second ) { // TFollowTuple = vector < set < ranked_symbol > >
+ for ( const std::set < std::ranked_symbol < > > & symbolSet : followTuple ) {
+ if ( symbolSet.count ( symb ) ) {
+ std::vector < std::variant < alphabet::BottomOfTheStackSymbol, std::set < std::ranked_symbol < SymbolType, RankType > > > > push;
+ push.push_back( symbolSet );
+ automaton.addTransition ( q, rte::GlushkovIndexate::getSymbolFromGlushkovPair ( symb ).getSymbol ( ), { }, q, push );
+
+ if ( common::GlobalData::verbose ) {
+ std::cerr << "1a: " << rte::GlushkovIndexate::getSymbolFromGlushkovPair ( symb ).getSymbol ( ) << " | " << std::endl <<
+ "\t" << "[ ]" << std::endl <<
+ "\t ->" << std::endl <<
+ "\t" << push << std::endl << std::endl;
+ }
+ }
+ }
+ }
+ }
+ } else { // 1b
+ /* If symb \in some symbolSet of followSet [ i ], then symb | followTuple -> symbolSet */
+ for ( const std::pair < const std::ranked_symbol < >, std::set < GlushkovFollowV3::TFollowTuple < SymbolType, RankType > > >& kv : followSet ) {
+ for ( const GlushkovFollowV3::TFollowTuple < SymbolType, RankType > & followTuple : kv.second ) { // TFollowTuple = vector < set < ranked_symbol > >
+ for ( const std::set < std::ranked_symbol < > > & symbolSet : followTuple ) {
+ if ( symbolSet.count ( symb ) ) {
+ std::vector < std::variant < alphabet::BottomOfTheStackSymbol, std::set < std::ranked_symbol < SymbolType, RankType > > > > pop, push;
+
+ for ( const GlushkovFollowV3::TFollowTuple < SymbolType, RankType > & symbFollowTuple : followSet [ symb ] ) {
+ /*
+ for ( const auto & e : symbFollowTuple )
+ pop.push_back ( e );
+ std::reverse ( pop.begin ( ), pop.end ( ) ); // <------------ WTF. CRASHES HERE
+ */
+ for ( const auto & e : symbFollowTuple )
+ pop.insert ( pop.begin ( ), e );
+
+ push.push_back( symbolSet );
+ automaton.addTransition ( q, rte::GlushkovIndexate::getSymbolFromGlushkovPair ( symb ).getSymbol ( ), pop, q, push );
+
+ if ( common::GlobalData::verbose ) {
+ std::cerr << "1b: " << rte::GlushkovIndexate::getSymbolFromGlushkovPair ( symb ).getSymbol ( ) << " | " << std::endl <<
+ "\t" << pop << std::endl <<
+ "\t ->" << std::endl <<
+ "\t" << push << std::endl << std::endl;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
}
- */
- /*
+ if ( common::GlobalData::verbose ) {
+ std::cerr << "transitions:" << std::endl;
+
+ for ( const auto & transitionKV : automaton.getTransitions ( ) ) {
+ // const std::map <
+ // std::tuple < StateType, std::variant < EpsilonType, InputSymbolType >, std::vector < PushdownStoreSymbolType > >,
+ // std::set < std::pair < StateType, std::vector < PushdownStoreSymbolType > > >
+ // >
+
+ const auto & input = std::get < 1 > ( transitionKV.first );
+ const auto & pop = std::get < 2 > ( transitionKV.first );
+
+ for ( const auto & transitionRHS : transitionKV.second ) {
+ const auto & push = transitionRHS.second;
+
+ std::cerr << "\t" << input << " | " << std::endl;
+ if ( pop.size( ) == 0 )
+ std::cerr << "\t\t" << "[]" << std::endl;
+ for ( const auto & e : pop )
+ std::cerr << "\t\t" << e << std::endl;
+ std::cerr << "\t\t" << " --> " << std::endl;
+ for ( const auto & e : push )
+ std::cerr << "\t\t" << e << std::endl;
+ }
+
+ }
+ std::cerr << std::endl;
+ }
+
+ // Final
for ( const std::ranked_symbol < > & symb : firstSet ) {
- std::vector < DefaultSymbolType > pop;
- pop.push_back ( DefaultSymbolType ( alphabet::RankedSymbol < > ( symb ) ) );
- pop.push_back ( alphabet::BottomOfTheStackSymbol::instance < DefaultSymbolType > ( ) );
+ std::vector < std::variant < alphabet::BottomOfTheStackSymbol, std::set < std::ranked_symbol < SymbolType, RankType > > > > pop;
+ pop.push_back ( std::set < std::ranked_symbol < SymbolType, RankType > > { symb } );
+ pop.push_back ( BotS );
automaton.addTransition ( q, alphabet::EndSymbol::instance < DefaultSymbolType > ( ), pop, f, { } );
}
- */
+
+
+ /* TRANSITIONS END */
return automaton;
}
diff --git a/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkovV3.h b/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkovV3.h
index 2be717f8d4749118eb3c44dbb026434ace9c1149..f6f888faff4599166ba9b5061294a7130f6ab568 100644
--- a/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkovV3.h
+++ b/alib2algo/src/rte/convert/ToPostfixPushdownAutomatonGlushkovV3.h
@@ -16,7 +16,8 @@
#include <rte/RTE.h>
#include <rte/formal/FormalRTE.h>
-// #include <rte/unbounded/UnboundedRegExp.h>
+#include <container/ObjectsVariant.h>
+#include <container/ObjectsSet.h>
namespace rte {