diff --git a/aconversions/src/abstract/Conversion.h b/aconversions/src/abstract/Conversion.h
index 9fa35307205e6949823db8e150b1dcc545bf829c..3d8036596167e1018fe160f01703563afa7aa5f0 100644
--- a/aconversions/src/abstract/Conversion.h
+++ b/aconversions/src/abstract/Conversion.h
@@ -11,6 +11,10 @@
namespace conversions
{
+/**
+ * Base conversion class for all the conversions.
+ * Although this class brings order into chaos, feel free to remove it.
+ */
class Conversion
{
public:
diff --git a/aconversions/src/aconversion/ConversionHandler.h b/aconversions/src/aconversion/ConversionHandler.h
index 0b273043a3d974f5873d3e6cf8d217ffdf8da40b..76f059eeb484268dd1d72286266e28b5f4e55748 100644
--- a/aconversions/src/aconversion/ConversionHandler.h
+++ b/aconversions/src/aconversion/ConversionHandler.h
@@ -43,6 +43,10 @@
namespace conversions
{
+/**
+ * Wraps all conversions.
+ * Determine what formalism input, what is desired output and algorithm. Then perform conversion.
+ */
class ConversionHandler
{
public:
diff --git a/aconversions/src/fa2re/AbstractFAtoREConverter.h b/aconversions/src/fa2re/AbstractFAtoREConverter.h
index e541a9c4b616cf354a9859aef90a71ccb614ca8e..4ea9b2e98c08a8851edc92de6a3555686664c276 100644
--- a/aconversions/src/fa2re/AbstractFAtoREConverter.h
+++ b/aconversions/src/fa2re/AbstractFAtoREConverter.h
@@ -11,16 +11,33 @@
namespace conversions
{
+/**
+ * Abstract finite automata to regular expression converter.
+ */
class AbstractFAtoREConverter : public Conversion
{
public:
+ /**
+ * @return regular expression equivalent to source automata.
+ */
virtual regexp::RegExp convert( ) = 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;
};
diff --git a/aconversions/src/fa2re/BrzozowskiAlgebraic.h b/aconversions/src/fa2re/BrzozowskiAlgebraic.h
index 4298c474f508ce3a34c303b48adc4d7a4ada4869..6623b169d0dac2eee8474e85e7b17a92d6455957 100644
--- a/aconversions/src/fa2re/BrzozowskiAlgebraic.h
+++ b/aconversions/src/fa2re/BrzozowskiAlgebraic.h
@@ -24,19 +24,31 @@ namespace conversions
// https://github.com/ferno/greenery/blob/bcc0a136335edbe94cd7725fc6e8cce0268d850c/fsm.py
/**
- * Converts FA to RE using Brzozowski's algebraic method applied on right
- * regular equations.
+ * Converts FA to RE using Brzozowski's algebraic method using right regular equations.
+ * Source : Melichar 2.122
*/
class BrzozowskiAlgebraic: public conversions::AbstractFAtoREConverter
{
public:
+ /**
+ * @param fsm Source automata
+ */
BrzozowskiAlgebraic( const automaton::FSM & fsm );
+
~BrzozowskiAlgebraic( void );
+
+ /**
+ * Performs conversion.
+ * @return regular expression equivalent to source automata.
+ */
regexp::RegExp convert( void );
private:
void initEquations( void );
+ /**
+ * Regular equation solver.
+ */
RightRegularEquationSolver m_solver;
};
diff --git a/aconversions/src/fa2re/StateElimination.h b/aconversions/src/fa2re/StateElimination.h
index 240ce7547dea785eafcea80e54626bfd902c0b9d..f5d27e6bba50ba8fa1bff7e64efc767b0ca6025a 100644
--- a/aconversions/src/fa2re/StateElimination.h
+++ b/aconversions/src/fa2re/StateElimination.h
@@ -21,23 +21,47 @@
namespace conversions
{
-class StateElimination: public conversions::AbstractFAtoREConverter
+/**
+ * Converts FSM to RE using State Elimination algorithm.
+ * Source: Melichar 2.118
+ */
+class StateElimination: public AbstractFAtoREConverter
{
public:
+ /**
+ * @param fsm Source automata.
+ */
StateElimination( const automaton::FSM & fsm );
+
~StateElimination( void );
+
+ /**
+ * Performs conversion.
+ * @return regular expression equivalent to source automata.
+ */
regexp::RegExp convert( void );
private:
+ /**
+ * Representation of extended NFA transition function (Q x R_T -> Q, R_T = regexp over alphabet T)
+ */
struct TransitionExtendedNFA
{
const automaton::State m_from, m_to;
regexp::RegExpElement* m_regexp;
+ /**
+ * @param from From state
+ * @param to To state
+ * @param regexp Expression
+ */
TransitionExtendedNFA( const automaton::State & from, regexp::RegExpElement* regexp ,const automaton::State & to );
bool operator<( const TransitionExtendedNFA & rhs ) const;
};
+ /**
+ * Stores extended NFA.
+ */
struct ExtendedNFA
{
std::set<automaton::State> m_states, m_finalStates, m_initialStates;
@@ -49,11 +73,31 @@ private:
};
void constructExtendedNFA( void );
+
void extendExtendedNFA( void );
+
+ /**
+ * Eliminates given state
+ * @param q given state
+ */
void eliminate( const automaton::State & q );
+
+ /**
+ * Cleanup
+ */
void deleteTransitions( void );
+
+ /**
+ * gets regexp representing transition from state P to state Q
+ * @param p from state
+ * @param q to state
+ * @return RegExpElement
+ */
regexp::RegExpElement* transition( const automaton::State & p, const automaton::State & q ) const;
+ /**
+ * Extended NFA.
+ */
ExtendedNFA m_MR;
};
diff --git a/aconversions/src/fa2rg/AbstractFAtoRGConverter.h b/aconversions/src/fa2rg/AbstractFAtoRGConverter.h
index 0c0dd826da38209a04b968bafa518f6409562bad..b05163aa80744c9f477defd3b0ea388c484af43f 100644
--- a/aconversions/src/fa2rg/AbstractFAtoRGConverter.h
+++ b/aconversions/src/fa2rg/AbstractFAtoRGConverter.h
@@ -18,13 +18,23 @@
namespace conversions
{
+/**
+ * Abstract finite automata to regular grammar conversion.
+ */
class AbstractFAtoRGConverter : public Conversion
{
public:
+ /**
+ * @param fsm Source automaton.
+ */
AbstractFAtoRGConverter( const automaton::FSM & fsm );
+
~AbstractFAtoRGConverter( void );
protected:
+ /**
+ * Source automaton.
+ */
const automaton::FSM m_fsm;
};
diff --git a/aconversions/src/fa2rg/StateNonterminalMap.cpp b/aconversions/src/fa2rg/StateNonterminalMap.cpp
index 092670809232c289bd9a93892e5fa65e8abaa243..cb6f03c1d06443be194db2a0a7c03b9b836dba93 100644
--- a/aconversions/src/fa2rg/StateNonterminalMap.cpp
+++ b/aconversions/src/fa2rg/StateNonterminalMap.cpp
@@ -30,17 +30,6 @@ const Symbol & StateNonterminalMap::getNonTerminal( const State & state )
if( it != m_map.end( ) )
return it->second;
-
- // oops automata might have changed
- // who the hell edits automata in process of converting to grammar?
- if( isInSet( state, m_fsm.getStates( ) ) )
- {
- Symbol nonTerminal = m_grammar.createUniqueNonTerminalSymbol( state.getName( ), false );
- m_map.insert( make_pair( state, nonTerminal ) );
- return m_map.find( state )->second;
- }
-
-
throw AlibException( "No nonterminal for this state! Should not happen unless you manipulated with automata after initialize mapper initialize." );
}
diff --git a/aconversions/src/fa2rg/StateNonterminalMap.h b/aconversions/src/fa2rg/StateNonterminalMap.h
index 799491e7576bff6134c237472c17f8ac85f2218c..eb8053b72c16b0ad7beeb63c966c80ec7b4c72b7 100644
--- a/aconversions/src/fa2rg/StateNonterminalMap.h
+++ b/aconversions/src/fa2rg/StateNonterminalMap.h
@@ -19,9 +19,19 @@
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 );
@@ -33,7 +43,14 @@ private:
*/
std::map<const automaton::State, const alphabet::Symbol> m_map;
- const automaton::FSM & m_fsm;
+ /**
+ * Source automata.
+ */
+ const automaton::FSM m_fsm;
+
+ /**
+ * Target grammar.
+ */
grammar::RegularGrammar & m_grammar;
};
diff --git a/aconversions/src/fa2rg/fa2lrg/AbstractFAtoLRGConverter.h b/aconversions/src/fa2rg/fa2lrg/AbstractFAtoLRGConverter.h
index 86a43b10fd0e0d6c3e8791c230147a24bb0a67e8..360f2515a7556a6553cfc909c956c08861867ef4 100644
--- a/aconversions/src/fa2rg/fa2lrg/AbstractFAtoLRGConverter.h
+++ b/aconversions/src/fa2rg/fa2lrg/AbstractFAtoLRGConverter.h
@@ -11,15 +11,27 @@
namespace conversions
{
+/**
+ * Abstract finite automata to right regular grammar.
+ */
class AbstractFAtoLRGConverter : public AbstractFAtoRGConverter
{
public:
+ /**
+ * @return left regular grammar equivalent to source automata.
+ */
virtual grammar::LeftRegularGrammar convert( ) = 0;
virtual ~AbstractFAtoLRGConverter( void );
protected:
+ /**
+ * New left regular grammar.
+ */
grammar::LeftRegularGrammar m_grammar;
+ /**
+ * @param automaton Original FSM.
+ */
AbstractFAtoLRGConverter( const automaton::FSM & automaton );
};
diff --git a/aconversions/src/fa2rg/fa2lrg/FAtoLRGConverter.h b/aconversions/src/fa2rg/fa2lrg/FAtoLRGConverter.h
index 69848392c1745cdfe0850eeec490ff3cb9e33068..348384ecf50efa0d0452fe611277c116e40e18f2 100644
--- a/aconversions/src/fa2rg/fa2lrg/FAtoLRGConverter.h
+++ b/aconversions/src/fa2rg/fa2lrg/FAtoLRGConverter.h
@@ -9,14 +9,30 @@
namespace conversions
{
+/**
+ * Finite automata to right regular grammar converter.
+ * Source: My own :)
+ */
class FAtoLRGConverter: public AbstractFAtoLRGConverter
{
public:
+ /**
+ * @param automaton Original automaton.
+ */
FAtoLRGConverter( const automaton::FSM & automaton );
+
~FAtoLRGConverter( void );
+
+ /**
+ * Performs conversion.
+ * @return left regular grammar equivalent to source automata.
+ */
grammar::LeftRegularGrammar convert( void );
protected:
+ /**
+ * New left regular grammar.
+ */
grammar::LeftRegularGrammar m_grammar;
};
diff --git a/aconversions/src/fa2rg/fa2rrg/AbstractFAtoRRGConverter.h b/aconversions/src/fa2rg/fa2rrg/AbstractFAtoRRGConverter.h
index 28d5e30d0ef042df118081d7febe5ddb769d2df6..44e7edea9e868687d20be4e27e2b9944e878a22e 100644
--- a/aconversions/src/fa2rg/fa2rrg/AbstractFAtoRRGConverter.h
+++ b/aconversions/src/fa2rg/fa2rrg/AbstractFAtoRRGConverter.h
@@ -11,15 +11,27 @@
namespace conversions
{
+/**
+ * Abstract finite automata to right regular grammar.
+ */
class AbstractFAtoRRGConverter : public AbstractFAtoRGConverter
{
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;
+ /**
+ * @param automaton Original automaton.
+ */
AbstractFAtoRRGConverter( const automaton::FSM & automaton );
};
diff --git a/aconversions/src/fa2rg/fa2rrg/FAtoRRGConverter.h b/aconversions/src/fa2rg/fa2rrg/FAtoRRGConverter.h
index 575e500945924f3effa50f09e5076b58f5bd1c04..074d36ddd5b39e0c98ebb2d4d0cd80b5d4b5fea9 100644
--- a/aconversions/src/fa2rg/fa2rrg/FAtoRRGConverter.h
+++ b/aconversions/src/fa2rg/fa2rrg/FAtoRRGConverter.h
@@ -9,14 +9,30 @@
namespace conversions
{
+/**
+ * Finite automata to right regular grammar converter.
+ * Source: Melichar 2.104
+ */
class FAtoRRGConverter : public AbstractFAtoRRGConverter
{
public:
+ /**
+ * @param automaton Source automata.
+ */
FAtoRRGConverter( const automaton::FSM & automaton );
+
~FAtoRRGConverter( void );
+
+ /**
+ * Performs conversion.
+ * @return left regular grammar equivalent to source automata.
+ */
grammar::RightRegularGrammar convert ( void );
protected:
+ /**
+ * New right regular grammar.
+ */
grammar::RightRegularGrammar m_grammar;
};
diff --git a/aconversions/src/re2fa/AbstractREtoFAConverter.h b/aconversions/src/re2fa/AbstractREtoFAConverter.h
index 7d348a0981b03d2693e6f75c2d14c78f7d26cdca..69af927a2d72b3c6f92882ad0032b72d4b9e282f 100644
--- a/aconversions/src/re2fa/AbstractREtoFAConverter.h
+++ b/aconversions/src/re2fa/AbstractREtoFAConverter.h
@@ -12,16 +12,33 @@
namespace conversions
{
+/**
+ * Abstract regular expression to finite automata converter.
+ */
class AbstractREtoFAConverter : public Conversion
{
public:
+ /**
+ * @return FSM equivalent to original regular expression.
+ */
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;
};
diff --git a/aconversions/src/re2fa/Brzozowski.cpp b/aconversions/src/re2fa/Brzozowski.cpp
index 6e255b1999446f3a9dd7ed870e6a52ac64c1a3f6..90f33ce024c039d84cf885b9f8c4363bd7bc41d0 100644
--- a/aconversions/src/re2fa/Brzozowski.cpp
+++ b/aconversions/src/re2fa/Brzozowski.cpp
@@ -28,6 +28,7 @@ FSM Brzozowski::convert( void )
{
RegExpOptimize opt;
+ // 1.
RegExp V = opt.optimize( m_re );
set<RegExpSymbol> alphabet = RegExpAlphabet::getSymbols( m_re );
@@ -38,6 +39,8 @@ FSM Brzozowski::convert( void )
Qi.at( 0 ).insert( V );
int i = 1;
+
+ // 2.
while( ! Qi.at( i - 1 ).empty( ) )
{
Qi.push_back( set<RegExp>( ) ); // initialize set Q_i
@@ -70,6 +73,7 @@ FSM Brzozowski::convert( void )
}
// ------------------------------------------------------------------------
+ // 3.
StateBuilder builder( Q );
diff --git a/aconversions/src/re2fa/Brzozowski.h b/aconversions/src/re2fa/Brzozowski.h
index dfb5828333ef7fdf235a79632a584f515f2fc61a..2263d402e0c979cfbdc39c65e3557a8d8436ea21 100644
--- a/aconversions/src/re2fa/Brzozowski.h
+++ b/aconversions/src/re2fa/Brzozowski.h
@@ -27,36 +27,80 @@ namespace conversions
/**
* Converts regular expression to finite automata using Brzozowski algorithm (derivations of regular expressions).
+ * Source: Melichar 2.110
*/
class Brzozowski : public AbstractREtoFAConverter
{
public:
+ /**
+ * @param re Source regular expression.
+ */
Brzozowski( const regexp::RegExp & re );
+
~Brzozowski( void );
+
+ /**
+ * Performs conversion.
+ * @return FSM equivalent to original regular expression.
+ */
automaton::FSM convert( void );
private:
+ /**
+ * Maps every regular expression to unique state of automata.
+ */
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;
};
+ /**
+ * Stores original regular epxression (m_from), and result of derivation (m_to) over m_symbol.
+ */
struct Transition
{
const regexp::RegExp m_from, m_to;
const alphabet::Symbol m_symbol;
+ /**
+ * @param from original regexp
+ * @param to resulting regexp
+ * @param symb
+ */
Transition( const regexp::RegExp & from, const alphabet::Symbol & symb, const regexp::RegExp & to );
+
bool operator<( const Transition & other ) const;
};
+ /**
+ * Set of transitions.
+ * @see Brzozowski::Transition
+ */
std::set<Transition> m_transitions;
};
diff --git a/aconversions/src/re2fa/Glushkov.h b/aconversions/src/re2fa/Glushkov.h
index e922bb7bf1fc4e14d5657f69477fb3f2c901a6ee..6fdc3d9f0aed6111626015910cc66b6f2531427e 100644
--- a/aconversions/src/re2fa/Glushkov.h
+++ b/aconversions/src/re2fa/Glushkov.h
@@ -25,39 +25,76 @@ namespace conversions
/**
* Converts regular expression to finite automata using Glushkov's NFA construction algorithm.
- * Sources:
- * - Melichar 2.107
- *
+ * Source: Melichar 2.107
*/
class Glushkov : public AbstractREtoFAConverter
{
public:
+ /**
+ * @param re Original regular expression.
+ */
Glushkov( const regexp::RegExp & re );
+
~Glushkov( void );
+
+ /**
+ * Performs conversion.
+ * @return FSM equivalent to original regular expression.
+ *
+ */
automaton::FSM convert( void );
private:
+ /**
+ * Maps each symbol to unique number. Also creates automaton state.
+ */
struct NumberedSymbol
{
+ /**
+ * Id of symbol (unique).
+ */
const int m_i;
+
+ /**
+ *
+ */
const alphabet::Symbol m_alphabetSymbol;
+
+ /**
+ * State which is created by this symbol in output automata.
+ */
const automaton::State m_state;
+ /**
+ * @param symb symbol
+ * @param i unique number
+ */
NumberedSymbol( const regexp::RegExpSymbol * symb, int i );
- bool operator<( const NumberedSymbol & x ) const;
- };
- struct Neighbours
- {
- const regexp::RegExpSymbol * m_first, * m_second;
-
- Neighbours( const regexp::RegExpSymbol * first, const regexp::RegExpSymbol * second );
- bool operator<( const Neighbours & x ) const;
+ bool operator<( const NumberedSymbol & x ) const;
};
+ /**
+ * Maps each symbol to unique number.
+ */
void initNumberSymbols( void );
+
+ /**
+ * Creates set of begin symbols
+ * @see m_beginSymbolSet
+ */
void constructBeginSymbolSet( void );
+
+ /**
+ * Creates set of end symbols.
+ * @see m_endSymbolSet
+ */
void constructEndSymbolSet( void );
+
+ /**
+ * Creates set of adjacent symbols.
+ * @see m_neighbourSymbolSet
+ */
void constructNeighbourSymbolSet( void );
std::map<const regexp::RegExpElement*, NumberedSymbol> m_numberedSymbols;
diff --git a/aconversions/src/re2fa/Thompson.h b/aconversions/src/re2fa/Thompson.h
index 89f0b2e79a4dcc868e90f8e632ea19c80124748a..76d5a5d15dd2e046e5473f91f6f62f1ab6a763de 100644
--- a/aconversions/src/re2fa/Thompson.h
+++ b/aconversions/src/re2fa/Thompson.h
@@ -28,12 +28,21 @@ namespace conversions
* Hopcroft, section 3.2.3
* http://www.eecis.udel.edu/~cavazos/cisc672/lectures/Lecture-04.pdf
* http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.21.7450&rep=rep1&type=ps
+ * Melichar 2.112
*/
class Thompson : public AbstractREtoFAConverter
{
public:
+ /**
+ * @param re Source regular expression.
+ */
Thompson( const regexp::RegExp & re );
~Thompson( void );
+
+ /**
+ * Performs conversion.
+ * @return FSM equivalent to original regular expression.
+ */
automaton::FSM convert( void );
private:
diff --git a/aconversions/src/re2rg/AbstractREtoRGConverter.h b/aconversions/src/re2rg/AbstractREtoRGConverter.h
index a97b41cce5df8031d37abab633981f9f933d1207..86f6f8e32cce4181b834710bb605b251721605dd 100644
--- a/aconversions/src/re2rg/AbstractREtoRGConverter.h
+++ b/aconversions/src/re2rg/AbstractREtoRGConverter.h
@@ -16,14 +16,23 @@
namespace conversions
{
+/**
+ * Abstract regular expression to grammar converter.
+ */
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;
};
diff --git a/aconversions/src/re2rg/re2rrg/AbstractREtoRRGConverter.h b/aconversions/src/re2rg/re2rrg/AbstractREtoRRGConverter.h
index 7e313f513502f32d98056a4306b5eb9ed1ddee83..4c2dd5e5d4dbe8ecef9db87c08857d112d769eac 100644
--- a/aconversions/src/re2rg/re2rrg/AbstractREtoRRGConverter.h
+++ b/aconversions/src/re2rg/re2rrg/AbstractREtoRRGConverter.h
@@ -17,14 +17,28 @@
namespace conversions
{
-class AbstractREtoRRGConverter: public conversions::AbstractREtoRGConverter
+/**
+ * Abstract regular epxression to right regular grammar converter.
+ */
+class AbstractREtoRRGConverter: public AbstractREtoRGConverter
{
public:
virtual ~AbstractREtoRRGConverter( void );
+
+ /**
+ * @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;
};
diff --git a/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.cpp b/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.cpp
index 327168748a44a4de2f672057bd481372b11fe4b5..4bb4d63f78847066b3920a51de5e375a72a091a0 100644
--- a/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.cpp
+++ b/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.cpp
@@ -29,6 +29,8 @@ BrzozowskiDerivationRRG::~BrzozowskiDerivationRRG( void )
RightRegularGrammar BrzozowskiDerivationRRG::convert( void )
{
RegExpOptimize opt;
+
+ // 1.
RegExp V = opt.optimize( m_re );
set<RegExpSymbol> alphabet = RegExpAlphabet::getSymbols( m_re );
@@ -40,6 +42,8 @@ RightRegularGrammar BrzozowskiDerivationRRG::convert( void )
Ni.at( 0 ).insert( V );
int i = 1;
+
+ // 2.
while( ! Ni.at( i - 1 ).empty( ) )
{
Ni.push_back( set<RegExp>( ) ); // initialize set Q_i
@@ -70,10 +74,11 @@ RightRegularGrammar BrzozowskiDerivationRRG::convert( void )
i += 1;
}
+ // 3.
+
for( const auto & s : alphabet )
m_grammar.addTerminalSymbol( s.getSymbol( ) );
-
NonTerminalBuilder builder( N, m_grammar );
for( const auto & t : m_transitions )
diff --git a/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.h b/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.h
index 506a169a5070664bbe44fe0ca3a2630ae7c63669..a656f8c79f63089b93cb83314307e9ff42f8c821 100644
--- a/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.h
+++ b/aconversions/src/re2rg/re2rrg/BrzozowskiDerivationRRG.h
@@ -25,11 +25,24 @@
namespace conversions
{
+/**
+ * Converts reg. expression to right regular grammar using brzozowski derivation algorithm.
+ * Source: Melichar 2.137
+ */
class BrzozowskiDerivationRRG : public AbstractREtoRRGConverter
{
public:
+ /**
+ * @param re Source regular expression.
+ */
BrzozowskiDerivationRRG( const regexp::RegExp & re );
+
~BrzozowskiDerivationRRG( void );
+
+ /**
+ * Performs conversion.
+ * @return right regular grammar equivalent to source regexp.
+ */
grammar::RightRegularGrammar convert( void );
protected:
diff --git a/aconversions/src/re2rg/re2rrg/GlushkovRRG.h b/aconversions/src/re2rg/re2rrg/GlushkovRRG.h
index 82c4ba6ed16fc6c0ac321373592221c9cc9b85c7..78d48eb00c8d56fb8712abac3183ed119bafb31d 100644
--- a/aconversions/src/re2rg/re2rrg/GlushkovRRG.h
+++ b/aconversions/src/re2rg/re2rrg/GlushkovRRG.h
@@ -21,11 +21,24 @@
namespace conversions
{
+/**
+ * Converts regular expression to right regular grammar using Glushkov algorithm.
+ * Source: None yet.
+ */
class GlushkovRRG : public AbstractREtoRRGConverter
{
public:
+ /**
+ * @param re Source regular expresison.
+ */
GlushkovRRG( const regexp::RegExp & re );
+
~GlushkovRRG( void );
+
+ /**
+ * Performs conversion.
+ * @return right regular grammar equivalent to source regexp.
+ */
grammar::RightRegularGrammar convert( void );
private:
@@ -47,7 +60,6 @@ private:
std::map<const regexp::RegExpElement*, NumberedSymbol> m_numberedSymbols;
std::set<NumberedSymbol> m_beginSymbolSet, m_endSymbolSet;
std::set<GlushkovTraversal::Neighbours> m_neighbourSymbolSet;
-
};
} /* namespace conversions */
diff --git a/aconversions/src/rg2fa/AbstractRGtoFAConverter.h b/aconversions/src/rg2fa/AbstractRGtoFAConverter.h
index 226fff1e31f242660d3493d7f4186ce77daf449f..f4ed104590ebf5e7e905aac2449a915cb3b39550 100644
--- a/aconversions/src/rg2fa/AbstractRGtoFAConverter.h
+++ b/aconversions/src/rg2fa/AbstractRGtoFAConverter.h
@@ -10,15 +10,24 @@
namespace conversions
{
+/**
+ * Abstract regular grammar to finite state machine conversion.
+ */
class AbstractRGtoFAConverter : public Conversion
{
public:
+ /**
+ * @return FSM equivalent to source grammar.
+ */
virtual automaton::FSM convert( void ) = 0;
virtual ~AbstractRGtoFAConverter( void );
protected:
AbstractRGtoFAConverter( void );
+ /**
+ * New automaton.
+ */
automaton::FSM m_automaton;
};
diff --git a/aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.h b/aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.h
index e88a28f5e1593aeb3ad003f0524dcc7d33b7b0bf..8e1448ff79267bc3b6bec87407ebd7da2b1ad4da 100644
--- a/aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.h
+++ b/aconversions/src/rg2fa/lrg2fa/AbstractLRGtoFAConverter.h
@@ -15,13 +15,23 @@
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;
};
diff --git a/aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.h b/aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.h
index f36e9df91808cff28a6038c587dcfa56102a2ad8..28ff087a46a9f8bea4fc41e6c0eb469a28d1db97 100644
--- a/aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.h
+++ b/aconversions/src/rg2fa/lrg2fa/LRGtoFAConverter.h
@@ -6,11 +6,24 @@
namespace conversions
{
+/**
+ * Converts left regular grammar to finite automata.
+ * Source: Melichar 2.102.
+ */
class LRGtoFAConverter : public AbstractLRGtoFAConverter
{
public:
+ /**
+ * @param grammar Source left regular grammar.
+ */
LRGtoFAConverter( const grammar::LeftRegularGrammar & grammar );
+
~LRGtoFAConverter( void );
+
+ /**
+ * Performs conversion.
+ * @return FSM equivalent to source grammar.
+ */
automaton::FSM convert( void );
};
diff --git a/aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.h b/aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.h
index 54347239fa655d8f02c10d88531dd9cded66e554..7704aa6f7267567d241c73681e18a3f02ed837d5 100644
--- a/aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.h
+++ b/aconversions/src/rg2fa/rrg2fa/AbstractRRGtoFAConverter.h
@@ -15,13 +15,23 @@
namespace conversions
{
-class AbstractRRGtoFAConverter: public conversions::AbstractRGtoFAConverter
+/**
+ * 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;
};
diff --git a/aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.h b/aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.h
index 32d5117e134ed8990c88d3d4a16982f63f0226da..0eae2d96580c290e60beea0b46ea61fd0538e8a8 100644
--- a/aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.h
+++ b/aconversions/src/rg2fa/rrg2fa/RRGtoFAConverter.h
@@ -6,11 +6,24 @@
namespace conversions
{
+/**
+ * Converts left regular grammar to finite automata.
+ * Source: Melichar 2.98
+ */
class RRGtoFAConverter : public AbstractRRGtoFAConverter
{
public:
+ /**
+ * @param grammar Source right regular grammar.
+ */
RRGtoFAConverter( const grammar::RightRegularGrammar & grammar );
+
~RRGtoFAConverter( void );
+
+ /**
+ * Performs conversion.
+ * @return FSM equivalent to source grammar.
+ */
automaton::FSM convert( void );
};
diff --git a/aconversions/src/rg2re/AbstractRGtoREConverter.h b/aconversions/src/rg2re/AbstractRGtoREConverter.h
index a333f37ae2e16844d6181c96485a9ddd366fd3ce..afc7790257d663cddeaeefc8c55895e62ba4c72d 100644
--- a/aconversions/src/rg2re/AbstractRGtoREConverter.h
+++ b/aconversions/src/rg2re/AbstractRGtoREConverter.h
@@ -15,15 +15,25 @@
namespace conversions
{
+/**
+ * Abstract regular grammar to regular expression conversion.
+ */
class AbstractRGtoREConverter : public Conversion
{
public:
+ /**
+ * @return regexp equivalent to source regular grammar.
+ */
virtual regexp::RegExp convert( void ) = 0;
+
virtual ~AbstractRGtoREConverter( void );
protected:
AbstractRGtoREConverter( void );
+ /**
+ * New regular expression.
+ */
regexp::RegExp m_re;
};
diff --git a/aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.h b/aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.h
index f6d406336b86eb6e5374e4b1da896b08dddb8add..f753cd70bdacefab245c3270582e3133a0ba4bdd 100644
--- a/aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.h
+++ b/aconversions/src/rg2re/lrg2re/AbstractLRGtoREConverter.h
@@ -21,7 +21,14 @@ 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;
};
diff --git a/aconversions/src/rg2re/lrg2re/LRGAlgebraic.h b/aconversions/src/rg2re/lrg2re/LRGAlgebraic.h
index e0abf34ada5a77b763fd7fd90aed6e1d0fa8ff57..ac9b41835fe0545d8113aa872deda8a4d422e73c 100644
--- a/aconversions/src/rg2re/lrg2re/LRGAlgebraic.h
+++ b/aconversions/src/rg2re/lrg2re/LRGAlgebraic.h
@@ -17,11 +17,22 @@ namespace conversions
class LRGAlgebraic: public AbstractLRGtoREConverter
{
public:
+ /**
+ * @param rg Source left regular grammar.
+ */
LRGAlgebraic( const grammar::LeftRegularGrammar & rg );
+
~LRGAlgebraic( void );
+
+ /**
+ * @return regexp equivalent to source left regular grammar.
+ */
regexp::RegExp convert( void );
protected:
+ /**
+ * Equation solver.
+ */
LeftRegularEquationSolver m_solver;
};
diff --git a/aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.h b/aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.h
index 83de063ecdaaea294493887c225807247a06148d..ce21d1c6fd93179cc4a894d9df1166a22c3661ee 100644
--- a/aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.h
+++ b/aconversions/src/rg2re/rrg2re/AbstractRRGtoREConverter.h
@@ -21,8 +21,14 @@ 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;
};
diff --git a/aconversions/src/rg2re/rrg2re/RRGAlgebraic.h b/aconversions/src/rg2re/rrg2re/RRGAlgebraic.h
index 85b907effbd71e9f2f4c0f52f1e1d75d1ff7f1b3..dd9d8ea1a260f1a794c0214d2dad5883f3803781 100644
--- a/aconversions/src/rg2re/rrg2re/RRGAlgebraic.h
+++ b/aconversions/src/rg2re/rrg2re/RRGAlgebraic.h
@@ -17,11 +17,22 @@ namespace conversions
class RRGAlgebraic: public AbstractRRGtoREConverter
{
public:
+ /**
+ * @param rg Source right regular grammar.
+ */
RRGAlgebraic( const grammar::RightRegularGrammar & rg );
+
~RRGAlgebraic( void );
+
+ /**
+ * @return regexp equivalent to source right regular grammar.
+ */
regexp::RegExp convert( void );
protected:
+ /**
+ * Equation solver.
+ */
RightRegularEquationSolver m_solver;
};
diff --git a/aconversions/src/rg2rg/lrg2rrg/AbstractLRGtoRRGConverter.h b/aconversions/src/rg2rg/lrg2rrg/AbstractLRGtoRRGConverter.h
index 637f25bedc1a3f8016becb872f015442be642782..9a5a3064b670c58c9ec049bb8a4c7f38d5248d20 100644
--- a/aconversions/src/rg2rg/lrg2rrg/AbstractLRGtoRRGConverter.h
+++ b/aconversions/src/rg2rg/lrg2rrg/AbstractLRGtoRRGConverter.h
@@ -16,16 +16,33 @@
namespace conversions
{
+/**
+ * Abstract left regular grammar to right regular grammar converter.
+ */
class AbstractLRGtoRRGConverter : public Conversion
{
public:
virtual ~AbstractLRGtoRRGConverter( void );
+
+ /**
+ * @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;
};
diff --git a/aconversions/src/rg2rg/lrg2rrg/LeftToRightRegularGrammar.h b/aconversions/src/rg2rg/lrg2rrg/LeftToRightRegularGrammar.h
index 0cb28c49e41b06c3366a12445bf01a5e6bc00702..6feae684b94d8ace168a19db2e5874a13647e0d6 100644
--- a/aconversions/src/rg2rg/lrg2rrg/LeftToRightRegularGrammar.h
+++ b/aconversions/src/rg2rg/lrg2rrg/LeftToRightRegularGrammar.h
@@ -16,8 +16,17 @@ namespace conversions
class LeftToRightRegularGrammar: public AbstractLRGtoRRGConverter
{
public:
+ /**
+ * @param lrg Original left regular grammar.
+ */
LeftToRightRegularGrammar( const grammar::LeftRegularGrammar & lrg );
+
virtual ~LeftToRightRegularGrammar( void );
+
+ /**
+ * Performs conversion.
+ * @return right regular grammar which is equivalent to source left regular grammar.
+ */
grammar::RightRegularGrammar convert( void );
};
diff --git a/aconversions/src/rg2rg/rrg2lrg/AbstractRRGtoLRGConverter.h b/aconversions/src/rg2rg/rrg2lrg/AbstractRRGtoLRGConverter.h
index 0c2cca11c2cf1c7ef3f5fcdfdcd3c182a98903a0..5cb8e7b38c46bd2557433a9e27ce8052fbee1444 100644
--- a/aconversions/src/rg2rg/rrg2lrg/AbstractRRGtoLRGConverter.h
+++ b/aconversions/src/rg2rg/rrg2lrg/AbstractRRGtoLRGConverter.h
@@ -16,15 +16,33 @@
namespace conversions
{
+/**
+ * Abstract right regular grammar to left regular grammar converter.
+ */
class AbstractRRGtoLRGConverter: public Conversion
{
public:
- AbstractRRGtoLRGConverter( const grammar::RightRegularGrammar & rrg );
virtual ~AbstractRRGtoLRGConverter( void );
+
+ /**
+ * @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;
};
diff --git a/aconversions/src/rg2rg/rrg2lrg/RightToLeftRegularGrammar.h b/aconversions/src/rg2rg/rrg2lrg/RightToLeftRegularGrammar.h
index 134a729f425c42a7d1a864d0ade7380c06b052e7..0a956c7c11cf91668074dd334644b719aaf5c73b 100644
--- a/aconversions/src/rg2rg/rrg2lrg/RightToLeftRegularGrammar.h
+++ b/aconversions/src/rg2rg/rrg2lrg/RightToLeftRegularGrammar.h
@@ -13,11 +13,23 @@
namespace conversions
{
+/**
+ * Converts right regular grammar to left regular grammar.
+ */
class RightToLeftRegularGrammar: public AbstractRRGtoLRGConverter
{
public:
+ /**
+ * @param rrg Original right regular grammar.
+ */
RightToLeftRegularGrammar( const grammar::RightRegularGrammar & rrg );
+
virtual ~RightToLeftRegularGrammar( void );
+
+ /**
+ * Performs conversion.
+ * @return left regular grammar which is equivalent to source right regular grammar.
+ */
grammar::LeftRegularGrammar convert( void );
};
diff --git a/aconversions/src/shared/GlushkovTraversal.h b/aconversions/src/shared/GlushkovTraversal.h
index cf2ff3d4a1cdaee0384fe8e17291f7ac0d68910f..09c7928214517283f1708a9e49fc98eb311edecc 100644
--- a/aconversions/src/shared/GlushkovTraversal.h
+++ b/aconversions/src/shared/GlushkovTraversal.h
@@ -24,9 +24,15 @@
namespace conversions
{
+/**
+ * RegExp tree traversal utils for Glushkov algorithm.
+ */
class GlushkovTraversal
{
public:
+ /**
+ * Actually, this is just std::pair
+ */
struct Neighbours
{
const regexp::RegExpSymbol * m_first, * m_second;
@@ -35,8 +41,19 @@ public:
bool operator<( const Neighbours & x ) const;
};
+ /**
+ * Returns all RegExpSymbols which can be initiating.
+ */
static std::set<const regexp::RegExpSymbol*> getLeftmostSymbolsInTree( const regexp::RegExp & re );
+
+ /**
+ * Returns all RegExpSymbols that can be terminating.
+ */
static std::set<const regexp::RegExpSymbol*> getRightmostSymbolsInTree( const regexp::RegExp & re );
+
+ /**
+ * Returns all pairs of RegExpSymbols that can be adjacent.
+ */
static std::set<Neighbours> getNeighbours( const regexp::RegExp & re );
private:
diff --git a/aconversions/src/shared/equations/LeftRegularEquationSolver.h b/aconversions/src/shared/equations/LeftRegularEquationSolver.h
index 855de953a9f011bd089cf6a8993fe7005f457fc5..73d6a89d2636e6abd5446f61db10d9d10a164105 100644
--- a/aconversions/src/shared/equations/LeftRegularEquationSolver.h
+++ b/aconversions/src/shared/equations/LeftRegularEquationSolver.h
@@ -20,6 +20,9 @@ public:
~LeftRegularEquationSolver( void );
private:
+ /**
+ * @copydoc RegularEquationSolver::eliminate(void)
+ */
regexp::RegExpElement* eliminate( void );
};
diff --git a/aconversions/src/shared/equations/RegularEquationSolver.h b/aconversions/src/shared/equations/RegularEquationSolver.h
index 5add4af8454b72f4cea4789d1e999648ad51101f..380b616a29b9e0db24c93da5d887faba119f2b4d 100644
--- a/aconversions/src/shared/equations/RegularEquationSolver.h
+++ b/aconversions/src/shared/equations/RegularEquationSolver.h
@@ -23,27 +23,65 @@
namespace conversions
{
+/**
+ * Base class for regular equations solvers.
+ */
class RegularEquationSolver
{
public:
RegularEquationSolver( void );
virtual ~RegularEquationSolver( void );
+ /**
+ * Adds nonterminal symbol into system.
+ *
+ * @param symb given symbol
+ */
void addSymbol( const alphabet::Symbol & symb );
+
+ /**
+ * Adds equation in form FROM = eq TO
+ *
+ * @param from symbol
+ * @param to symbol
+ * @param eq equation
+ */
void addEquation( const alphabet::Symbol & from, const alphabet::Symbol & to, const regexp::RegExpElement* eq );
+
+ /**
+ * Adds equation in form: FROM = eq
+ *
+ * @param from
+ * @param eq
+ */
void addEquation( const alphabet::Symbol & from, const regexp::RegExpElement* eq );
+
+ /**
+ * Solve expression system
+ *
+ * @param solveFor will solve equation system for given symbol
+ * @return regexp
+ */
regexp::RegExp solve( const alphabet::Symbol & solveFor );
protected:
+ /**
+ * actual equations elimination
+ * @return pointer to solutions RegExp tree root
+ */
virtual regexp::RegExpElement* eliminate( void ) = 0;
/**
- * Runs BFS to determine depth of symbols in equation system
+ * Runs BFS to determine depth of symbols in equation system and stores it in m_symbolsByDepth;
* @see m_symbolsByDepth
- * @return symbols sorted by depth starting with solveFor having depth 0
*/
void symbolsByDepth( const alphabet::Symbol & solveFor );
+ /**
+ * @see symbolsByDepth
+ */
+ std::deque<alphabet::Symbol> m_symbolsByDepth;
+
/**
* Stores transitions from nonterminal to nonterminal, eg A = 2A + 2B + 1C
*/
@@ -53,8 +91,11 @@ protected:
* Stores equation not going to particular nonterminal, eg A = 01*
*/
std::map<alphabet::Symbol, regexp::RegExpElement*> m_eqFinal;
+
+ /**
+ * Set of symbols
+ */
std::set<alphabet::Symbol> m_symbols;
- std::deque<alphabet::Symbol> m_symbolsByDepth;
};
} /* namespace conversions */