public Choise(
IRegExExpressionTree <TLetter> firstChoise,
IRegExExpressionTree <TLetter> secondChoise)
{
this.firstChoise = firstChoise;
this.secondChoise = secondChoise;
}
public Concatenation(
IRegExExpressionTree <TLetter> first,
IRegExExpressionTree <TLetter> second)
{
this.first = first;
this.second = second;
}
public static bool IsInfinite <TLetter>(IRegExExpressionTree <TLetter> exp)
{
switch (exp.Type)
{
case RegExNodeTypes.Letter:
return(false);
case RegExNodeTypes.EmptyWord:
return(false);
case RegExNodeTypes.Empty:
return(false);
case RegExNodeTypes.KleeneClosure:
return(!(IsEmpty(exp) || IsEmptyWord(exp)));
case RegExNodeTypes.Choise:
return(exp.GetChildren().Any(IsEmpty));
case RegExNodeTypes.Concatenation:
return(exp.GetChildren().All(x => !IsEmpty(x)) && exp.GetChildren().Any(IsEmpty));
default:
throw new ArgumentException();
}
}
private static EpsilonDFA <TState, TLetter> GetNFA <TState, TLetter>(
IRegExExpressionTree <TLetter> exp, Func <TState> getNewState)
{
switch (exp.Type)
{
case RegExNodeTypes.Letter:
return(EpsilonDFA <TState, TLetter> .Letter(
((Letter <TLetter>)exp).LetterToMatch,
getNewState));
case RegExNodeTypes.EmptyWord:
return(EpsilonDFA <TState, TLetter> .EmptyWord(getNewState));
case RegExNodeTypes.Empty:
return(EpsilonDFA <TState, TLetter> .Empty(getNewState));
case RegExNodeTypes.KleeneClosure:
return(EpsilonDFA <TState, TLetter> .KleeneClosure(
GetNFA(exp.GetChildren().First(), getNewState),
getNewState));
case RegExNodeTypes.Choise:
return(EpsilonDFA <TState, TLetter> .Choise(
GetNFA(exp.GetChildren().First(), getNewState),
GetNFA(exp.GetChildren().Last(), getNewState),
getNewState));
case RegExNodeTypes.Concatenation:
return(EpsilonDFA <TState, TLetter> .Concatenation(
GetNFA(exp.GetChildren().First(), getNewState),
GetNFA(exp.GetChildren().Last(), getNewState),
getNewState));
default:
throw new ArgumentException();
}
}
public static bool IsEmptyWord <TLetter>(IRegExExpressionTree <TLetter> exp)
{
switch (exp.Type)
{
case RegExNodeTypes.Letter:
case RegExNodeTypes.Empty:
return(false);
case RegExNodeTypes.EmptyWord:
return(true);
case RegExNodeTypes.KleeneClosure:
return(exp.GetChildren().All(IsEmptyWord));
case RegExNodeTypes.Choise:
return(exp.GetChildren().All(IsEmptyWord));
case RegExNodeTypes.Concatenation:
return(exp.GetChildren().All(IsEmptyWord));
default:
throw new ArgumentException();
}
}
public static IRegExExpressionTree <TLetter> Simplify <TLetter>(IRegExExpressionTree <TLetter> exp)
{
switch (exp.Type)
{
case RegExNodeTypes.Letter:
case RegExNodeTypes.EmptyWord:
case RegExNodeTypes.Empty:
return(exp); //No change
case RegExNodeTypes.KleeneClosure:
var child = exp.GetChildren().First();
if (IsEmptyWord(child))
{
return(child); //(epsilon)* = epsilon
}
else if (child.Type == RegExNodeTypes.Choise)
{
var first = child.GetChildren().First();
var second = child.GetChildren().Last();
if (IsEmptyWord(first))
{
return(new KleeneClosure <TLetter>(second)); //(epsilon + r)* = r*
}
else if (IsEmptyWord(second))
{
return(new KleeneClosure <TLetter>(first)); //(r + epsilon)* = r*
}
}
return(exp); //No change
case RegExNodeTypes.Choise:
{
var first = exp.GetChildren().First();
var second = exp.GetChildren().Last();
if (IsEmpty(first))
{
return(second); //empty + r = r
}
else if (IsEmpty(second))
{
return(first); //r + empty = r
}
}
return(exp); //No change
case RegExNodeTypes.Concatenation:
{
var first = exp.GetChildren().First();
var second = exp.GetChildren().Last();
if (IsEmpty(first))
{
return(first); //empty r = empty
}
else if (IsEmpty(second))
{
return(second); //r empty = empty
}
if (IsEmptyWord(first))
{
return(second); //epsilon r = r
}
else if (IsEmptyWord(second))
{
return(first); //r epsilon = r
}
if (first.Type == RegExNodeTypes.Choise)
{
var first2 = first.GetChildren().First();
var second2 = first.GetChildren().Last();
return(new Choise <TLetter>(
new Concatenation <TLetter>(first2, second),
new Concatenation <TLetter>(second2, second)
));//(s + t) r = s r + t r
}
else if (second.Type == RegExNodeTypes.Choise)
{
var first2 = second.GetChildren().First();
var second2 = second.GetChildren().Last();
return(new Choise <TLetter>(
new Concatenation <TLetter>(first, first2),
new Concatenation <TLetter>(first, second2)
));//r (s + t) r = r s + r t
}
}
return(exp); //No change
default:
throw new ArgumentException();
}
}
public static DeterministicFiniteAutomaton <bool[], TLetter> GetDFA <TLetter>(IRegExExpressionTree <TLetter> exp, IEnumerable <TLetter> alphabet)
{
int n = 0;
var epsNFA = GetNFA(exp, () => n++);
bool[] startState = new bool[n];
startState[epsNFA.startState] = true;
var finalState = epsNFA.finalState;
Predicate <bool[]> isFinal = x => x[finalState];
List <Tuple <bool[], TLetter, bool[]> > transitions = new List <Tuple <bool[], TLetter, bool[]> >();
foreach (var letter in alphabet)
{
transitions.AddRange(GetPWSTransitionsWithLetter(n, epsNFA, letter));
}
return(new DeterministicFiniteAutomaton <bool[], TLetter>(transitions, isFinal, startState));
}
public KleeneClosure(IRegExExpressionTree <TLetter> toRepeat)
{
this.toRepeat = toRepeat;
}
