From e4075c6859bfae242b296ffd2019c034ec4303e4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tom=C3=A1=C5=A1=20Pecka?= <peckato1@fit.cvut.cz>
Date: Tue, 25 Mar 2014 15:43:13 +0100
Subject: [PATCH] Doxygen to almost every foo in aconversions
---
aconversions/src/abstract/Conversion.h | 4 ++
.../src/aconversion/ConversionHandler.h | 4 ++
.../src/fa2re/AbstractFAtoREConverter.h | 17 ++++++
aconversions/src/fa2re/BrzozowskiAlgebraic.h | 16 ++++-
aconversions/src/fa2re/StateElimination.h | 46 ++++++++++++++-
.../src/fa2rg/AbstractFAtoRGConverter.h | 10 ++++
.../src/fa2rg/StateNonterminalMap.cpp | 11 ----
aconversions/src/fa2rg/StateNonterminalMap.h | 19 +++++-
.../fa2rg/fa2lrg/AbstractFAtoLRGConverter.h | 12 ++++
.../src/fa2rg/fa2lrg/FAtoLRGConverter.h | 16 +++++
.../fa2rg/fa2rrg/AbstractFAtoRRGConverter.h | 12 ++++
.../src/fa2rg/fa2rrg/FAtoRRGConverter.h | 16 +++++
.../src/re2fa/AbstractREtoFAConverter.h | 17 ++++++
aconversions/src/re2fa/Brzozowski.cpp | 4 ++
aconversions/src/re2fa/Brzozowski.h | 44 ++++++++++++++
aconversions/src/re2fa/Glushkov.h | 59 +++++++++++++++----
aconversions/src/re2fa/Thompson.h | 9 +++
.../src/re2rg/AbstractREtoRGConverter.h | 9 +++
.../re2rg/re2rrg/AbstractREtoRRGConverter.h | 16 ++++-
.../re2rg/re2rrg/BrzozowskiDerivationRRG.cpp | 7 ++-
.../re2rg/re2rrg/BrzozowskiDerivationRRG.h | 13 ++++
aconversions/src/re2rg/re2rrg/GlushkovRRG.h | 14 ++++-
.../src/rg2fa/AbstractRGtoFAConverter.h | 9 +++
.../rg2fa/lrg2fa/AbstractLRGtoFAConverter.h | 10 ++++
.../src/rg2fa/lrg2fa/LRGtoFAConverter.h | 13 ++++
.../rg2fa/rrg2fa/AbstractRRGtoFAConverter.h | 12 +++-
.../src/rg2fa/rrg2fa/RRGtoFAConverter.h | 13 ++++
.../src/rg2re/AbstractRGtoREConverter.h | 10 ++++
.../rg2re/lrg2re/AbstractLRGtoREConverter.h | 7 +++
aconversions/src/rg2re/lrg2re/LRGAlgebraic.h | 11 ++++
.../rg2re/rrg2re/AbstractRRGtoREConverter.h | 6 ++
aconversions/src/rg2re/rrg2re/RRGAlgebraic.h | 11 ++++
.../rg2rg/lrg2rrg/AbstractLRGtoRRGConverter.h | 17 ++++++
.../rg2rg/lrg2rrg/LeftToRightRegularGrammar.h | 9 +++
.../rg2rg/rrg2lrg/AbstractRRGtoLRGConverter.h | 20 ++++++-
.../rg2rg/rrg2lrg/RightToLeftRegularGrammar.h | 12 ++++
aconversions/src/shared/GlushkovTraversal.h | 17 ++++++
.../equations/LeftRegularEquationSolver.h | 3 +
.../shared/equations/RegularEquationSolver.h | 47 ++++++++++++++-
39 files changed, 568 insertions(+), 34 deletions(-)
diff --git a/aconversions/src/abstract/Conversion.h b/aconversions/src/abstract/Conversion.h
index 9fa3530720..3d80365961 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 0b273043a3..76f059eeb4 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 e541a9c4b6..4ea9b2e98c 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 4298c474f5..6623b169d0 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 240ce7547d..f5d27e6bba 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 0c0dd826da..b05163aa80 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 0926708092..cb6f03c1d0 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 799491e757..eb8053b72c 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 86a43b10fd..360f2515a7 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 69848392c1..348384ecf5 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 28d5e30d0e..44e7edea9e 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 575e500945..074d36ddd5 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 7d348a0981..69af927a2d 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 6e255b1999..90f33ce024 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 dfb5828333..2263d402e0 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 e922bb7bf1..6fdc3d9f0a 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 89f0b2e79a..76d5a5d15d 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 a97b41cce5..86f6f8e32c 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 7e313f5135..4c2dd5e5d4 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 327168748a..4bb4d63f78 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 506a169a50..a656f8c79f 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 82c4ba6ed1..78d48eb00c 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 226fff1e31..f4ed104590 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 e88a28f5e1..8e1448ff79 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 f36e9df918..28ff087a46 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 54347239fa..7704aa6f72 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 32d5117e13..0eae2d9658 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 a333f37ae2..afc7790257 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 f6d406336b..f753cd70bd 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 e0abf34ada..ac9b41835f 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 83de063ecd..ce21d1c6fd 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 85b907effb..dd9d8ea1a2 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 637f25bedc..9a5a3064b6 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 0cb28c49e4..6feae684b9 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 0c2cca11c2..5cb8e7b38c 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 134a729f42..0a956c7c11 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 cf2ff3d4a1..09c7928214 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 855de953a9..73d6a89d26 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 5add4af845..380b616a29 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 */
--
GitLab