/// <summary>
/// Returns a new (deterministic) automaton that accepts a single character of the given value.
/// </summary>
/// <param name="c">The c.</param>
/// <returns>A new (deterministic) automaton that accepts a single character of the given value.</returns>
internal static Automaton MakeChar(char c)
{
var a = new Automaton();
a.Singleton = c.ToString();
a.IsDeterministic = true;
return a;
}
/// <summary>
/// Returns a new (deterministic) automaton that accepts all strings.
/// </summary>
/// <returns>
/// A new (deterministic) automaton that accepts all strings.
/// </returns>
internal static Automaton MakeAnyString()
{
var state = new State();
state.Accept = true;
state.Transitions.Add(new Transition(char.MinValue, char.MaxValue, state));
var a = new Automaton();
a.Initial = state;
a.IsDeterministic = true;
return a;
}
/// <summary>
/// Initializes a new instance of the <see cref="Xeger"/> class.
/// </summary>
/// <param name="regex">The regex.</param>
/// <param name="random">The random.</param>
internal Xeger(string regex, Random random)
{
if (string.IsNullOrEmpty(regex))
{
throw new ArgumentNullException("regex");
}
if (random == null)
{
throw new ArgumentNullException("random");
}
this.automaton = new RegExp(regex, AllExceptAnyString).ToAutomaton();
this.random = random;
}
/// <summary>
/// Reverses the language of the given (non-singleton) automaton while returning the set of
/// new initial states.
/// </summary>
/// <param name="a">The automaton.</param>
/// <returns></returns>
internal static HashSet<State> Reverse(Automaton a)
{
// Reverse all edges.
var m = new Dictionary<State, HashSet<Transition>>();
HashSet<State> states = a.GetStates();
HashSet<State> accept = a.GetAcceptStates();
foreach (State r in states)
{
m.Add(r, new HashSet<Transition>());
r.Accept = false;
}
foreach (State r in states)
{
foreach (Transition t in r.Transitions)
{
m[t.To].Add(new Transition(t.Min, t.Max, r));
}
}
foreach (State r in states)
{
r.Transitions = m[r].ToList();
}
// Make new initial+final states.
a.Initial.Accept = true;
a.Initial = new State();
foreach (State r in accept)
{
a.Initial.AddEpsilon(r); // Ensures that all initial states are reachable.
}
a.IsDeterministic = false;
return accept;
}
internal static Automaton MakeStringMatcher(String s)
{
var a = new Automaton();
var states = new State[s.Length + 1];
states[0] = a.Initial;
for (int i = 0; i < s.Length; i++)
{
states[i + 1] = new State();
}
State f = states[s.Length];
f.Accept = true;
f.Transitions.Add(new Transition(Char.MinValue, Char.MaxValue, f));
for (int i = 0; i < s.Length; i++)
{
var done = new HashSet <char?>();
char c = s[i];
states[i].Transitions.Add(new Transition(c, states[i + 1]));
done.Add(c);
for (int j = i; j >= 1; j--)
{
char d = s[j - 1];
if (!done.Contains(d) && s.Substring(0, j - 1).Equals(s.Substring(i - j + 1, i - (i - j + 1))))
{
states[i].Transitions.Add(new Transition(d, states[j]));
done.Add(d);
}
}
var da = new char[done.Count];
int h = 0;
foreach (char w in done)
{
da[h++] = w;
}
Array.Sort(da);
int from = Char.MinValue;
int k = 0;
while (from <= Char.MaxValue)
{
while (k < da.Length && da[k] == from)
{
k++;
from++;
}
if (from <= Char.MaxValue)
{
int to = Char.MaxValue;
if (k < da.Length)
{
to = da[k] - 1;
k++;
}
states[i].Transitions.Add(new Transition((char)from, (char)to, states[0]));
from = to + 2;
}
}
}
a.IsDeterministic = true;
return(a);
}
/// <summary>
/// Returns true if the given string is accepted by the automaton.
/// </summary>
/// <param name="a">The automaton.</param>
/// <param name="s">The string.</param>
/// <returns></returns>
/// <remarks>
/// Complexity: linear in the length of the string.
/// </remarks>
internal static bool Run(Automaton a, string s)
{
if (a.IsSingleton)
{
return(s.Equals(a.IsSingleton));
}
if (a.IsDeterministic)
{
State p = a.Initial;
foreach (char t in s)
{
State q = p.Step(t);
if (q == null)
{
return(false);
}
p = q;
}
return(p.Accept);
}
HashSet <State> states = a.GetStates();
Automaton.SetStateNumbers(states);
var pp = new LinkedList <State>();
var ppOther = new LinkedList <State>();
var bb = new BitArray(states.Count);
var bbOther = new BitArray(states.Count);
pp.AddLast(a.Initial);
var dest = new List <State>();
bool accept = a.Initial.Accept;
foreach (char c in s)
{
accept = false;
ppOther.Clear();
bbOther.SetAll(false);
foreach (State p in pp)
{
dest.Clear();
p.Step(c, dest);
foreach (State q in dest)
{
if (q.Accept)
{
accept = true;
}
if (!bbOther.Get(q.Number))
{
bbOther.Set(q.Number, true);
ppOther.AddLast(q);
}
}
}
LinkedList <State> tp = pp;
pp = ppOther;
ppOther = tp;
BitArray tb = bb;
bb = bbOther;
bbOther = tb;
}
return(accept);
}
internal Automaton Concatenate(Automaton a)
{
return(BasicOperations.Concatenate(this, a));
}
internal static bool IsEmpty(Automaton a)
{
if (a.IsSingleton)
{
return false;
}
return !a.Initial.Accept && a.Initial.Transitions.Count == 0;
}
/// <summary>
/// Returns an automaton that accepts the intersection of the languages of the given automata.
/// Never modifies the input automata languages.
/// </summary>
/// <param name="a1">The a1.</param>
/// <param name="a2">The a2.</param>
/// <returns></returns>
internal static Automaton Intersection(Automaton a1, Automaton a2)
{
if (a1.IsSingleton)
{
if (a2.Run(a1.Singleton))
{
return(a1.CloneIfRequired());
}
return(BasicAutomata.MakeEmpty());
}
if (a2.IsSingleton)
{
if (a1.Run(a2.Singleton))
{
return(a2.CloneIfRequired());
}
return(BasicAutomata.MakeEmpty());
}
if (a1 == a2)
{
return(a1.CloneIfRequired());
}
Transition[][] transitions1 = Automaton.GetSortedTransitions(a1.GetStates());
Transition[][] transitions2 = Automaton.GetSortedTransitions(a2.GetStates());
var c = new Automaton();
var worklist = new LinkedList <StatePair>();
var newstates = new Dictionary <StatePair, StatePair>();
var p = new StatePair(c.Initial, a1.Initial, a2.Initial);
worklist.AddLast(p);
newstates.Add(p, p);
while (worklist.Count > 0)
{
p = worklist.RemoveAndReturnFirst();
p.S.Accept = p.FirstState.Accept && p.SecondState.Accept;
Transition[] t1 = transitions1[p.FirstState.Number];
Transition[] t2 = transitions2[p.SecondState.Number];
for (int n1 = 0, b2 = 0; n1 < t1.Length; n1++)
{
while (b2 < t2.Length && t2[b2].Max < t1[n1].Min)
{
b2++;
}
for (int n2 = b2; n2 < t2.Length && t1[n1].Max >= t2[n2].Min; n2++)
{
if (t2[n2].Max >= t1[n1].Min)
{
var q = new StatePair(t1[n1].To, t2[n2].To);
StatePair r;
newstates.TryGetValue(q, out r);
if (r == null)
{
q.S = new State();
worklist.AddLast(q);
newstates.Add(q, q);
r = q;
}
char min = t1[n1].Min > t2[n2].Min ? t1[n1].Min : t2[n2].Min;
char max = t1[n1].Max < t2[n2].Max ? t1[n1].Max : t2[n2].Max;
p.S.Transitions.Add(new Transition(min, max, r.S));
}
}
}
}
c.IsDeterministic = a1.IsDeterministic && a2.IsDeterministic;
c.RemoveDeadTransitions();
c.CheckMinimizeAlways();
return(c);
}
/// <summary>
/// Determinizes the specified automaton.
/// </summary>
/// <remarks>
/// Complexity: exponential in number of states.
/// </remarks>
/// <param name="a">The automaton.</param>
internal static void Determinize(Automaton a)
{
if (a.IsDeterministic || a.IsSingleton)
{
return;
}
var initialset = new HashSet<State>();
initialset.Add(a.Initial);
BasicOperations.Determinize(a, initialset.ToList());
}
/// <summary>
/// Returns a new (deterministic) automaton that accepts a single char whose value is in the
/// given interval (including both end points).
/// </summary>
/// <param name="min">The min.</param>
/// <param name="max">The max.</param>
/// <returns>
/// A new (deterministic) automaton that accepts a single char whose value is in the
/// given interval (including both end points).
/// </returns>
internal static Automaton MakeCharRange(char min, char max)
{
if (min == max)
{
return BasicAutomata.MakeChar(min);
}
var a = new Automaton();
var s1 = new State();
var s2 = new State();
a.Initial = s1;
s2.Accept = true;
if (min <= max)
{
s1.Transitions.Add(new Transition(min, max, s2));
}
a.IsDeterministic = true;
return a;
}
/// <summary>
/// Accepts <code>min</code> or more concatenated repetitions of the language of the given
/// automaton.
/// </summary>
/// <param name="a">The automaton.</param>
/// <param name="min">The minimum concatenated repetitions of the language of the given
/// automaton.</param>
/// <returns>Returns an automaton that accepts <code>min</code> or more concatenated
/// repetitions of the language of the given automaton.
/// </returns>
/// <remarks>
/// Complexity: linear in number of states and in <code>min</code>.
/// </remarks>
internal static Automaton Repeat(Automaton a, int min)
{
if (min == 0)
{
return BasicOperations.Repeat(a);
}
var @as = new List<Automaton>();
while (min-- > 0)
{
@as.Add(a);
}
@as.Add(BasicOperations.Repeat(a));
return BasicOperations.Concatenate(@as);
}
/// <summary>
/// Accepts between <code>min</code> and <code>max</code> (including both) concatenated
/// repetitions of the language of the given automaton.
/// </summary>
/// <param name="a">The automaton.</param>
/// <param name="min">The minimum concatenated repetitions of the language of the given
/// automaton.</param>
/// <param name="max">The maximum concatenated repetitions of the language of the given
/// automaton.</param>
/// <returns>
/// Returns an automaton that accepts between <code>min</code> and <code>max</code>
/// (including both) concatenated repetitions of the language of the given automaton.
/// </returns>
/// <remarks>
/// Complexity: linear in number of states and in <code>min</code> and <code>max</code>.
/// </remarks>
internal static Automaton Repeat(Automaton a, int min, int max)
{
if (min > max)
{
return BasicAutomata.MakeEmpty();
}
max -= min;
a.ExpandSingleton();
Automaton b;
if (min == 0)
{
b = BasicAutomata.MakeEmptyString();
}
else if (min == 1)
{
b = a.Clone();
}
else
{
var @as = new List<Automaton>();
while (min-- > 0)
{
@as.Add(a);
}
b = BasicOperations.Concatenate(@as);
}
if (max > 0)
{
Automaton d = a.Clone();
while (--max > 0)
{
Automaton c = a.Clone();
foreach (State p in c.GetAcceptStates())
{
p.AddEpsilon(d.Initial);
}
d = c;
}
foreach (State p in b.GetAcceptStates())
{
p.AddEpsilon(d.Initial);
}
b.IsDeterministic = false;
b.ClearHashCode();
b.CheckMinimizeAlways();
}
return b;
}
/// <summary>
/// Returns an automaton that accepts the union of the empty string and the language of the
/// given automaton.
/// </summary>
/// <param name="a">The automaton.</param>
/// <remarks>
/// Complexity: linear in number of states.
/// </remarks>
/// <returns>An automaton that accepts the union of the empty string and the language of the
/// given automaton.</returns>
internal static Automaton Optional(Automaton a)
{
a = a.CloneExpandedIfRequired();
var s = new State();
s.AddEpsilon(a.Initial);
s.Accept = true;
a.Initial = s;
a.IsDeterministic = false;
a.ClearHashCode();
a.CheckMinimizeAlways();
return a;
}
/// <summary>
/// Accepts the Kleene star (zero or more concatenated repetitions) of the language of the
/// given automaton. Never modifies the input automaton language.
/// </summary>
/// <param name="a">The automaton.</param>
/// <returns>
/// An automaton that accepts the Kleene star (zero or more concatenated repetitions)
/// of the language of the given automaton. Never modifies the input automaton language.
/// </returns>
/// <remarks>
/// Complexity: linear in number of states.
/// </remarks>
internal static Automaton Repeat(Automaton a)
{
a = a.CloneExpanded();
var s = new State();
s.Accept = true;
s.AddEpsilon(a.Initial);
foreach (State p in a.GetAcceptStates())
{
p.AddEpsilon(s);
}
a.Initial = s;
a.IsDeterministic = false;
a.ClearHashCode();
a.CheckMinimizeAlways();
return a;
}
/// <summary>
/// Adds epsilon transitions to the given automaton. This method adds extra character interval
/// transitions that are equivalent to the given set of epsilon transitions.
/// </summary>
/// <param name="a">The automaton.</param>
/// <param name="pairs">A collection of <see cref="StatePair"/> objects representing pairs of
/// source/destination states where epsilon transitions should be added.</param>
internal static void AddEpsilons(Automaton a, ICollection<StatePair> pairs)
{
a.ExpandSingleton();
var forward = new Dictionary<State, HashSet<State>>();
var back = new Dictionary<State, HashSet<State>>();
foreach (StatePair p in pairs)
{
HashSet<State> to = forward[p.FirstState];
if (to == null)
{
to = new HashSet<State>();
forward.Add(p.FirstState, to);
}
to.Add(p.SecondState);
HashSet<State> from = back[p.SecondState];
if (from == null)
{
from = new HashSet<State>();
back.Add(p.SecondState, from);
}
from.Add(p.FirstState);
}
var worklist = new LinkedList<StatePair>(pairs);
var workset = new HashSet<StatePair>(pairs);
while (worklist.Count != 0)
{
StatePair p = worklist.RemoveAndReturnFirst();
workset.Remove(p);
HashSet<State> to = forward[p.SecondState];
HashSet<State> from = back[p.FirstState];
if (to != null)
{
foreach (State s in to)
{
var pp = new StatePair(p.FirstState, s);
if (!pairs.Contains(pp))
{
pairs.Add(pp);
forward[p.FirstState].Add(s);
back[s].Add(p.FirstState);
worklist.AddLast(pp);
workset.Add(pp);
if (from != null)
{
foreach (State q in from)
{
var qq = new StatePair(q, p.FirstState);
if (!workset.Contains(qq))
{
worklist.AddLast(qq);
workset.Add(qq);
}
}
}
}
}
}
}
// Add transitions.
foreach (StatePair p in pairs)
{
p.FirstState.AddEpsilon(p.SecondState);
}
a.IsDeterministic = false;
a.ClearHashCode();
a.CheckMinimizeAlways();
}
/// <summary>
/// Returns an automaton that accepts the intersection of the languages of the given automata.
/// Never modifies the input automata languages.
/// </summary>
/// <param name="a1">The a1.</param>
/// <param name="a2">The a2.</param>
/// <returns></returns>
internal static Automaton Intersection(Automaton a1, Automaton a2)
{
if (a1.IsSingleton)
{
if (a2.Run(a1.Singleton))
{
return a1.CloneIfRequired();
}
return BasicAutomata.MakeEmpty();
}
if (a2.IsSingleton)
{
if (a1.Run(a2.Singleton))
{
return a2.CloneIfRequired();
}
return BasicAutomata.MakeEmpty();
}
if (a1 == a2)
{
return a1.CloneIfRequired();
}
Transition[][] transitions1 = Automaton.GetSortedTransitions(a1.GetStates());
Transition[][] transitions2 = Automaton.GetSortedTransitions(a2.GetStates());
var c = new Automaton();
var worklist = new LinkedList<StatePair>();
var newstates = new Dictionary<StatePair, StatePair>();
var p = new StatePair(c.Initial, a1.Initial, a2.Initial);
worklist.AddLast(p);
newstates.Add(p, p);
while (worklist.Count > 0)
{
p = worklist.RemoveAndReturnFirst();
p.S.Accept = p.FirstState.Accept && p.SecondState.Accept;
Transition[] t1 = transitions1[p.FirstState.Number];
Transition[] t2 = transitions2[p.SecondState.Number];
for (int n1 = 0, b2 = 0; n1 < t1.Length; n1++)
{
while (b2 < t2.Length && t2[b2].Max < t1[n1].Min)
{
b2++;
}
for (int n2 = b2; n2 < t2.Length && t1[n1].Max >= t2[n2].Min; n2++)
{
if (t2[n2].Max >= t1[n1].Min)
{
var q = new StatePair(t1[n1].To, t2[n2].To);
StatePair r;
newstates.TryGetValue(q, out r);
if (r == null)
{
q.S = new State();
worklist.AddLast(q);
newstates.Add(q, q);
r = q;
}
char min = t1[n1].Min > t2[n2].Min ? t1[n1].Min : t2[n2].Min;
char max = t1[n1].Max < t2[n2].Max ? t1[n1].Max : t2[n2].Max;
p.S.Transitions.Add(new Transition(min, max, r.S));
}
}
}
}
c.IsDeterministic = a1.IsDeterministic && a2.IsDeterministic;
c.RemoveDeadTransitions();
c.CheckMinimizeAlways();
return c;
}
/// <summary>
/// Determines whether the given automaton accepts the empty string and nothing else.
/// </summary>
/// <param name="a">The automaton.</param>
/// <returns>
/// <c>true</c> if the given automaton accepts the empty string and nothing else; otherwise,
/// <c>false</c>.
/// </returns>
internal static bool IsEmptyString(Automaton a)
{
if (a.IsSingleton)
{
return a.Singleton.Length == 0;
}
return a.Initial.Accept && a.Initial.Transitions.Count == 0;
}
/// <summary>
/// Returns a (deterministic) automaton that accepts the complement of the language of the
/// given automaton.
/// </summary>
/// <param name="a">The automaton.</param>
/// <returns>A (deterministic) automaton that accepts the complement of the language of the
/// given automaton.</returns>
/// <remarks>
/// Complexity: linear in number of states (if already deterministic).
/// </remarks>
internal static Automaton Complement(Automaton a)
{
a = a.CloneExpandedIfRequired();
a.Determinize();
a.Totalize();
foreach (State p in a.GetStates())
{
p.Accept = !p.Accept;
}
a.RemoveDeadTransitions();
return a;
}
internal static Automaton Minimize(Automaton a)
{
a.Minimize();
return a;
}
internal static Automaton MakeStringMatcher(String s)
{
var a = new Automaton();
var states = new State[s.Length + 1];
states[0] = a.Initial;
for (int i = 0; i < s.Length; i++)
{
states[i + 1] = new State();
}
State f = states[s.Length];
f.Accept = true;
f.Transitions.Add(new Transition(Char.MinValue, Char.MaxValue, f));
for (int i = 0; i < s.Length; i++)
{
var done = new HashSet<char?>();
char c = s[i];
states[i].Transitions.Add(new Transition(c, states[i + 1]));
done.Add(c);
for (int j = i; j >= 1; j--)
{
char d = s[j - 1];
if (!done.Contains(d) && s.Substring(0, j - 1).Equals(s.Substring(i - j + 1, i - (i - j + 1))))
{
states[i].Transitions.Add(new Transition(d, states[j]));
done.Add(d);
}
}
var da = new char[done.Count];
int h = 0;
foreach (char w in done)
{
da[h++] = w;
}
Array.Sort(da);
int from = Char.MinValue;
int k = 0;
while (from <= Char.MaxValue)
{
while (k < da.Length && da[k] == from)
{
k++;
from++;
}
if (from <= Char.MaxValue)
{
int to = Char.MaxValue;
if (k < da.Length)
{
to = da[k] - 1;
k++;
}
states[i].Transitions.Add(new Transition((char)from, (char)to, states[0]));
from = to + 2;
}
}
}
a.IsDeterministic = true;
return a;
}
internal Automaton Intersection(Automaton a)
{
return BasicOperations.Intersection(this, a);
}
internal static Automaton Concatenate(Automaton a1, Automaton a2)
{
if (a1.IsSingleton && a2.IsSingleton)
{
return BasicAutomata.MakeString(a1.Singleton + a2.Singleton);
}
if (BasicOperations.IsEmpty(a1) || BasicOperations.IsEmpty(a2))
{
return BasicAutomata.MakeEmpty();
}
bool deterministic = a1.IsSingleton && a2.IsDeterministic;
if (a1 == a2)
{
a1 = a1.CloneExpanded();
a2 = a2.CloneExpanded();
}
else
{
a1 = a1.CloneExpandedIfRequired();
a2 = a2.CloneExpandedIfRequired();
}
foreach (State s in a1.GetAcceptStates())
{
s.Accept = false;
s.AddEpsilon(a2.Initial);
}
a1.IsDeterministic = deterministic;
a1.ClearHashCode();
a1.CheckMinimizeAlways();
return a1;
}
internal static Automaton Concatenate(IList <Automaton> l)
{
if (l.Count == 0)
{
return(BasicAutomata.MakeEmptyString());
}
bool allSingleton = l.All(a => a.IsSingleton);
if (allSingleton)
{
var b = new StringBuilder();
foreach (Automaton a in l)
{
b.Append(a.Singleton);
}
return(BasicAutomata.MakeString(b.ToString()));
}
else
{
if (l.Any(a => a.IsEmpty))
{
return(BasicAutomata.MakeEmpty());
}
var ids = new HashSet <int>();
foreach (Automaton a in l)
{
ids.Add(RuntimeHelpers.GetHashCode(a));
}
bool hasAliases = ids.Count != l.Count;
Automaton b = l[0];
b = hasAliases ? b.CloneExpanded() : b.CloneExpandedIfRequired();
var ac = b.GetAcceptStates();
bool first = true;
foreach (Automaton a in l)
{
if (first)
{
first = false;
}
else
{
if (a.IsEmptyString())
{
continue;
}
Automaton aa = a;
aa = hasAliases ? aa.CloneExpanded() : aa.CloneExpandedIfRequired();
HashSet <State> ns = aa.GetAcceptStates();
foreach (State s in ac)
{
s.Accept = false;
s.AddEpsilon(aa.Initial);
if (s.Accept)
{
ns.Add(s);
}
}
ac = ns;
}
}
b.IsDeterministic = false;
b.ClearHashCode();
b.CheckMinimizeAlways();
return(b);
}
}
/// <summary>
/// Returns true if the given string is accepted by the automaton.
/// </summary>
/// <param name="a">The automaton.</param>
/// <param name="s">The string.</param>
/// <returns></returns>
/// <remarks>
/// Complexity: linear in the length of the string.
/// </remarks>
internal static bool Run(Automaton a, string s)
{
if (a.IsSingleton)
{
return s.Equals(a.IsSingleton);
}
if (a.IsDeterministic)
{
State p = a.Initial;
foreach (char t in s)
{
State q = p.Step(t);
if (q == null)
{
return false;
}
p = q;
}
return p.Accept;
}
HashSet<State> states = a.GetStates();
Automaton.SetStateNumbers(states);
var pp = new LinkedList<State>();
var ppOther = new LinkedList<State>();
var bb = new BitArray(states.Count);
var bbOther = new BitArray(states.Count);
pp.AddLast(a.Initial);
var dest = new List<State>();
bool accept = a.Initial.Accept;
foreach (char c in s)
{
accept = false;
ppOther.Clear();
bbOther.SetAll(false);
foreach (State p in pp)
{
dest.Clear();
p.Step(c, dest);
foreach (State q in dest)
{
if (q.Accept)
{
accept = true;
}
if (!bbOther.Get(q.Number))
{
bbOther.Set(q.Number, true);
ppOther.AddLast(q);
}
}
}
LinkedList<State> tp = pp;
pp = ppOther;
ppOther = tp;
BitArray tb = bb;
bb = bbOther;
bbOther = tb;
}
return accept;
}
/// <summary>
/// Determinizes the given automaton using the given set of initial states.
/// </summary>
/// <param name="a">The automaton.</param>
/// <param name="initialset">The initial states.</param>
internal static void Determinize(Automaton a, List<State> initialset)
{
char[] points = a.GetStartPoints();
var comparer = new ListEqualityComparer<State>();
// Subset construction.
var sets = new Dictionary<List<State>, List<State>>(comparer);
var worklist = new LinkedList<List<State>>();
var newstate = new Dictionary<List<State>, State>();
sets.Add(initialset, initialset);
worklist.AddLast(initialset);
a.Initial = new State();
newstate.Add(initialset, a.Initial);
while (worklist.Count > 0)
{
List<State> s = worklist.RemoveAndReturnFirst();
State r;
newstate.TryGetValue(s, out r);
foreach (State q in s)
{
if (q.Accept)
{
r.Accept = true;
break;
}
}
for (int n = 0; n < points.Length; n++)
{
var p = (from qq in s from t in qq.Transitions where t.Min <= points[n] && points[n] <= t.Max select t.To).ToList();
if (!sets.ContainsKey(p))
{
sets.Add(p, p);
worklist.AddLast(p);
newstate.Add(p, new State());
}
State q;
newstate.TryGetValue(p, out q);
char min = points[n];
char max;
if (n + 1 < points.Length)
{
max = (char)(points[n + 1] - 1);
}
else
{
max = char.MaxValue;
}
r.Transitions.Add(new Transition(min, max, q));
}
}
a.IsDeterministic = true;
a.RemoveDeadTransitions();
}
internal Automaton Concatenate(Automaton a)
{
return BasicOperations.Concatenate(this, a);
}
/// <summary>
/// Minimizes the given automaton using Huffman's algorithm.
/// </summary>
/// <param name="a">The automaton.</param>
internal static void MinimizeHuffman(Automaton a)
{
a.Determinize();
a.Totalize();
HashSet <State> ss = a.GetStates();
var transitions = new Transition[ss.Count][];
State[] states = ss.ToArray();
var mark = new List <List <bool> >();
var triggers = new List <List <HashSet <IntPair> > >();
foreach (State t in states)
{
var v = new List <HashSet <IntPair> >();
Initialize(ref v, states.Length);
triggers.Add(v);
}
// Initialize marks based on acceptance status and find transition arrays.
for (int n1 = 0; n1 < states.Length; n1++)
{
states[n1].Number = n1;
transitions[n1] = states[n1].GetSortedTransitions(false).ToArray();
for (int n2 = n1 + 1; n2 < states.Length; n2++)
{
if (states[n1].Accept != states[n2].Accept)
{
mark[n1][n2] = true;
}
}
}
// For all pairs, see if states agree.
for (int n1 = 0; n1 < states.Length; n1++)
{
for (int n2 = n1 + 1; n2 < states.Length; n2++)
{
if (!mark[n1][n2])
{
if (MinimizationOperations.StatesAgree(transitions, mark, n1, n2))
{
MinimizationOperations.AddTriggers(transitions, triggers, n1, n2);
}
else
{
MinimizationOperations.MarkPair(mark, triggers, n1, n2);
}
}
}
}
// Assign equivalence class numbers to states.
int numclasses = 0;
foreach (State t in states)
{
t.Number = -1;
}
for (int n1 = 0; n1 < states.Length; n1++)
{
if (states[n1].Number == -1)
{
states[n1].Number = numclasses;
for (int n2 = n1 + 1; n2 < states.Length; n2++)
{
if (!mark[n1][n2])
{
states[n2].Number = numclasses;
}
}
numclasses++;
}
}
// Make a new state for each equivalence class.
var newstates = new State[numclasses];
for (int n = 0; n < numclasses; n++)
{
newstates[n] = new State();
}
// Select a class representative for each class and find the new initial state.
for (int n = 0; n < states.Length; n++)
{
newstates[states[n].Number].Number = n;
if (states[n] == a.Initial)
{
a.Initial = newstates[states[n].Number];
}
}
// Build transitions and set acceptance.
for (int n = 0; n < numclasses; n++)
{
State s = newstates[n];
s.Accept = states[s.Number].Accept;
foreach (Transition t in states[s.Number].Transitions)
{
s.Transitions.Add(new Transition(t.Min, t.Max, newstates[t.To.Number]));
}
}
a.RemoveDeadTransitions();
}
private Automaton ToAutomaton(
IDictionary <string, Automaton> automata,
IAutomatonProvider automatonProvider,
bool minimize)
{
IList <Automaton> list;
Automaton a = null;
switch (kind)
{
case Kind.RegexpUnion:
list = new List <Automaton>();
this.FindLeaves(exp1, Kind.RegexpUnion, list, automata, automatonProvider, minimize);
this.FindLeaves(exp2, Kind.RegexpUnion, list, automata, automatonProvider, minimize);
a = BasicOperations.Union(list);
a.Minimize();
break;
case Kind.RegexpConcatenation:
list = new List <Automaton>();
this.FindLeaves(exp1, Kind.RegexpConcatenation, list, automata, automatonProvider, minimize);
this.FindLeaves(exp2, Kind.RegexpConcatenation, list, automata, automatonProvider, minimize);
a = BasicOperations.Concatenate(list);
a.Minimize();
break;
case Kind.RegexpIntersection:
a = exp1.ToAutomaton(automata, automatonProvider, minimize)
.Intersection(exp2.ToAutomaton(automata, automatonProvider, minimize));
a.Minimize();
break;
case Kind.RegexpOptional:
a = exp1.ToAutomaton(automata, automatonProvider, minimize).Optional();
a.Minimize();
break;
case Kind.RegexpRepeat:
a = exp1.ToAutomaton(automata, automatonProvider, minimize).Repeat();
a.Minimize();
break;
case Kind.RegexpRepeatMin:
a = exp1.ToAutomaton(automata, automatonProvider, minimize).Repeat(min);
a.Minimize();
break;
case Kind.RegexpRepeatMinMax:
a = exp1.ToAutomaton(automata, automatonProvider, minimize).Repeat(min, max);
a.Minimize();
break;
case Kind.RegexpComplement:
a = exp1.ToAutomaton(automata, automatonProvider, minimize).Complement();
a.Minimize();
break;
case Kind.RegexpChar:
a = BasicAutomata.MakeChar(c);
break;
case Kind.RegexpCharRange:
a = BasicAutomata.MakeCharRange(from, to);
break;
case Kind.RegexpAnyChar:
a = BasicAutomata.MakeAnyChar();
break;
case Kind.RegexpEmpty:
a = BasicAutomata.MakeEmpty();
break;
case Kind.RegexpString:
a = BasicAutomata.MakeString(s);
break;
case Kind.RegexpAnyString:
a = BasicAutomata.MakeAnyString();
break;
case Kind.RegexpAutomaton:
Automaton aa = null;
if (automata != null)
{
automata.TryGetValue(s, out aa);
}
if (aa == null && automatonProvider != null)
{
try
{
aa = automatonProvider.GetAutomaton(s);
}
catch (IOException e)
{
throw new ArgumentException(string.Empty, e);
}
}
if (aa == null)
{
throw new ArgumentException("'" + s + "' not found");
}
a = aa.Clone(); // Always clone here (ignore allowMutate).
break;
case Kind.RegexpInterval:
a = BasicAutomata.MakeInterval(min, max, digits);
break;
}
return(a);
}
internal static void MinimizeHopcroft(Automaton a)
{
a.Determinize();
IList <Transition> tr = a.Initial.Transitions;
if (tr.Count == 1)
{
Transition t = tr[0];
if (t.To == a.Initial && t.Min == char.MinValue && t.Max == char.MaxValue)
{
return;
}
}
a.Totalize();
// Make arrays for numbered states and effective alphabet.
HashSet <State> ss = a.GetStates();
var states = new State[ss.Count];
int number = 0;
foreach (State q in ss)
{
states[number] = q;
q.Number = number++;
}
char[] sigma = a.GetStartPoints();
// Initialize data structures.
var reverse = new List <List <LinkedList <State> > >();
foreach (State s in states)
{
var v = new List <LinkedList <State> >();
Initialize(ref v, sigma.Length);
reverse.Add(v);
}
var reverseNonempty = new bool[states.Length, sigma.Length];
var partition = new List <LinkedList <State> >();
Initialize(ref partition, states.Length);
var block = new int[states.Length];
var active = new StateList[states.Length, sigma.Length];
var active2 = new StateListNode[states.Length, sigma.Length];
var pending = new LinkedList <IntPair>();
var pending2 = new bool[sigma.Length, states.Length];
var split = new List <State>();
var split2 = new bool[states.Length];
var refine = new List <int>();
var refine2 = new bool[states.Length];
var splitblock = new List <List <State> >();
Initialize(ref splitblock, states.Length);
for (int q = 0; q < states.Length; q++)
{
splitblock[q] = new List <State>();
partition[q] = new LinkedList <State>();
for (int x = 0; x < sigma.Length; x++)
{
reverse[q][x] = new LinkedList <State>();
active[q, x] = new StateList();
}
}
// Find initial partition and reverse edges.
foreach (State qq in states)
{
int j = qq.Accept ? 0 : 1;
partition[j].AddLast(qq);
block[qq.Number] = j;
for (int x = 0; x < sigma.Length; x++)
{
char y = sigma[x];
State p = qq.Step(y);
reverse[p.Number][x].AddLast(qq);
reverseNonempty[p.Number, x] = true;
}
}
// Initialize active sets.
for (int j = 0; j <= 1; j++)
{
for (int x = 0; x < sigma.Length; x++)
{
foreach (State qq in partition[j])
{
if (reverseNonempty[qq.Number, x])
{
active2[qq.Number, x] = active[j, x].Add(qq);
}
}
}
}
// Initialize pending.
for (int x = 0; x < sigma.Length; x++)
{
int a0 = active[0, x].Size;
int a1 = active[1, x].Size;
int j = a0 <= a1 ? 0 : 1;
pending.AddLast(new IntPair(j, x));
pending2[x, j] = true;
}
// Process pending until fixed point.
int k = 2;
while (pending.Count > 0)
{
IntPair ip = pending.RemoveAndReturnFirst();
int p = ip.N1;
int x = ip.N2;
pending2[x, p] = false;
// Find states that need to be split off their blocks.
for (StateListNode m = active[p, x].First; m != null; m = m.Next)
{
foreach (State s in reverse[m.State.Number][x])
{
if (!split2[s.Number])
{
split2[s.Number] = true;
split.Add(s);
int j = block[s.Number];
splitblock[j].Add(s);
if (!refine2[j])
{
refine2[j] = true;
refine.Add(j);
}
}
}
}
// Refine blocks.
foreach (int j in refine)
{
if (splitblock[j].Count < partition[j].Count)
{
LinkedList <State> b1 = partition[j];
LinkedList <State> b2 = partition[k];
foreach (State s in splitblock[j])
{
b1.Remove(s);
b2.AddLast(s);
block[s.Number] = k;
for (int c = 0; c < sigma.Length; c++)
{
StateListNode sn = active2[s.Number, c];
if (sn != null && sn.StateList == active[j, c])
{
sn.Remove();
active2[s.Number, c] = active[k, c].Add(s);
}
}
}
// Update pending.
for (int c = 0; c < sigma.Length; c++)
{
int aj = active[j, c].Size;
int ak = active[k, c].Size;
if (!pending2[c, j] && 0 < aj && aj <= ak)
{
pending2[c, j] = true;
pending.AddLast(new IntPair(j, c));
}
else
{
pending2[c, k] = true;
pending.AddLast(new IntPair(k, c));
}
}
k++;
}
foreach (State s in splitblock[j])
{
split2[s.Number] = false;
}
refine2[j] = false;
splitblock[j].Clear();
}
split.Clear();
refine.Clear();
}
// Make a new state for each equivalence class, set initial state.
var newstates = new State[k];
for (int n = 0; n < newstates.Length; n++)
{
var s = new State();
newstates[n] = s;
foreach (State q in partition[n])
{
if (q == a.Initial)
{
a.Initial = s;
}
s.Accept = q.Accept;
s.Number = q.Number; // Select representative.
q.Number = n;
}
}
// Build transitions and set acceptance.
foreach (State s in newstates)
{
s.Accept = states[s.Number].Accept;
foreach (Transition t in states[s.Number].Transitions)
{
s.Transitions.Add(new Transition(t.Min, t.Max, newstates[t.To.Number]));
}
}
a.RemoveDeadTransitions();
}
/// <summary>
/// Determinizes the given automaton using the given set of initial states.
/// </summary>
/// <param name="a">The automaton.</param>
/// <param name="initialset">The initial states.</param>
internal static void Determinize(Automaton a, List <State> initialset)
{
char[] points = a.GetStartPoints();
var comparer = new ListEqualityComparer <State>();
// Subset construction.
var sets = new Dictionary <List <State>, List <State> >(comparer);
var worklist = new LinkedList <List <State> >();
var newstate = new Dictionary <List <State>, State>();
sets.Add(initialset, initialset);
worklist.AddLast(initialset);
a.Initial = new State();
newstate.Add(initialset, a.Initial);
while (worklist.Count > 0)
{
List <State> s = worklist.RemoveAndReturnFirst();
State r;
newstate.TryGetValue(s, out r);
foreach (State q in s)
{
if (q.Accept)
{
r.Accept = true;
break;
}
}
for (int n = 0; n < points.Length; n++)
{
var p = (from qq in s from t in qq.Transitions where t.Min <= points[n] && points[n] <= t.Max select t.To).ToList();
if (!sets.ContainsKey(p))
{
sets.Add(p, p);
worklist.AddLast(p);
newstate.Add(p, new State());
}
State q;
newstate.TryGetValue(p, out q);
char min = points[n];
char max;
if (n + 1 < points.Length)
{
max = (char)(points[n + 1] - 1);
}
else
{
max = char.MaxValue;
}
r.Transitions.Add(new Transition(min, max, q));
}
}
a.IsDeterministic = true;
a.RemoveDeadTransitions();
}
/// <summary>
/// Returns a new (deterministic) automaton with the empty language.
/// </summary>
/// <returns>
/// A new (deterministic) automaton with the empty language.
/// </returns>
internal static Automaton MakeEmpty()
{
var a = new Automaton();
var s = new State();
a.Initial = s;
a.IsDeterministic = true;
return a;
}
/// <summary>
/// Adds epsilon transitions to the given automaton. This method adds extra character interval
/// transitions that are equivalent to the given set of epsilon transitions.
/// </summary>
/// <param name="a">The automaton.</param>
/// <param name="pairs">A collection of <see cref="StatePair"/> objects representing pairs of
/// source/destination states where epsilon transitions should be added.</param>
internal static void AddEpsilons(Automaton a, ICollection <StatePair> pairs)
{
a.ExpandSingleton();
var forward = new Dictionary <State, HashSet <State> >();
var back = new Dictionary <State, HashSet <State> >();
foreach (StatePair p in pairs)
{
HashSet <State> to = forward[p.FirstState];
if (to == null)
{
to = new HashSet <State>();
forward.Add(p.FirstState, to);
}
to.Add(p.SecondState);
HashSet <State> from = back[p.SecondState];
if (from == null)
{
from = new HashSet <State>();
back.Add(p.SecondState, from);
}
from.Add(p.FirstState);
}
var worklist = new LinkedList <StatePair>(pairs);
var workset = new HashSet <StatePair>(pairs);
while (worklist.Count != 0)
{
StatePair p = worklist.RemoveAndReturnFirst();
workset.Remove(p);
HashSet <State> to = forward[p.SecondState];
HashSet <State> from = back[p.FirstState];
if (to != null)
{
foreach (State s in to)
{
var pp = new StatePair(p.FirstState, s);
if (!pairs.Contains(pp))
{
pairs.Add(pp);
forward[p.FirstState].Add(s);
back[s].Add(p.FirstState);
worklist.AddLast(pp);
workset.Add(pp);
if (from != null)
{
foreach (State q in from)
{
var qq = new StatePair(q, p.FirstState);
if (!workset.Contains(qq))
{
worklist.AddLast(qq);
workset.Add(qq);
}
}
}
}
}
}
}
// Add transitions.
foreach (StatePair p in pairs)
{
p.FirstState.AddEpsilon(p.SecondState);
}
a.IsDeterministic = false;
a.ClearHashCode();
a.CheckMinimizeAlways();
}
/// <summary>
/// Returns a new (deterministic) automaton that accepts only the empty string.
/// </summary>
/// <returns>
/// A new (deterministic) automaton that accepts only the empty string.
/// </returns>
internal static Automaton MakeEmptyString()
{
var a = new Automaton();
a.Singleton = string.Empty;
a.IsDeterministic = true;
return a;
}
internal static Automaton Minimize(Automaton a)
{
a.Minimize();
return(a);
}
internal static Automaton MakeInterval(int min, int max, int digits)
{
var a = new Automaton();
string x = Convert.ToString(min, CultureInfo.CurrentCulture);
string y = Convert.ToString(max, CultureInfo.CurrentCulture);
if (min > max || (digits > 0 && y.Length > digits))
{
throw new ArgumentException();
}
int d = digits > 0 ? digits : y.Length;
var bx = new StringBuilder();
for (int i = x.Length; i < d; i++)
{
bx.Append('0');
}
bx.Append(x);
x = bx.ToString();
var by = new StringBuilder();
for (int i = y.Length; i < d; i++)
{
by.Append('0');
}
by.Append(y);
y = by.ToString();
ICollection<State> initials = new List<State>();
a.Initial = BasicAutomata.Between(x, y, 0, initials, digits <= 0);
if (digits <= 0)
{
List<StatePair> pairs = (from p in initials
where a.Initial != p
select new StatePair(a.Initial, p)).ToList();
a.AddEpsilons(pairs);
a.Initial.AddTransition(new Transition('0', a.Initial));
a.IsDeterministic = false;
}
else
{
a.IsDeterministic = true;
}
a.CheckMinimizeAlways();
return a;
}
internal Automaton Intersection(Automaton a)
{
return(BasicOperations.Intersection(this, a));
}
/// <summary>
/// Returns a new (deterministic) automaton that accepts the single given string.
/// </summary>
/// <param name="s">The string.</param>
/// <returns>A new (deterministic) automaton that accepts the single given string.</returns>
internal static Automaton MakeString(string s)
{
var a = new Automaton();
a.Singleton = s;
a.IsDeterministic = true;
return a;
}
internal static Automaton MakeCharSet(string set)
{
if (set.Length == 1)
{
return MakeChar(set[0]);
}
var a = new Automaton();
var s1 = new State();
var s2 = new State();
a.Initial = s1;
s2.Accept = true;
foreach (char t in set)
{
s1.Transitions.Add(new Transition(t, s2));
}
a.IsDeterministic = true;
a.Reduce();
return a;
}
/// <summary>
/// Returns an automaton that accepts the union of the languages of the given automata.
/// </summary>
/// <param name="automatons">The l.</param>
/// <returns>
/// An automaton that accepts the union of the languages of the given automata.
/// </returns>
/// <remarks>
/// Complexity: linear in number of states.
/// </remarks>
internal static Automaton Union(IList<Automaton> automatons)
{
var ids = new HashSet<int>();
foreach (Automaton a in automatons)
{
ids.Add(RuntimeHelpers.GetHashCode(a));
}
bool hasAliases = ids.Count != automatons.Count;
var s = new State();
foreach (Automaton b in automatons)
{
if (b.IsEmpty)
{
continue;
}
Automaton bb = b;
bb = hasAliases ? bb.CloneExpanded() : bb.CloneExpandedIfRequired();
s.AddEpsilon(bb.Initial);
}
var automaton = new Automaton();
automaton.Initial = s;
automaton.IsDeterministic = false;
automaton.ClearHashCode();
automaton.CheckMinimizeAlways();
return automaton;
}