public override int CompareTo(RegEx <T> other)
{
var diff = TypeId - other.TypeId;
if (diff != 0)
{
return(diff);
}
var intersection = other as RegExIntersection <T>;
diff = Regexes.Length.CompareTo(intersection.Regexes.Length);
if (diff != 0)
{
return(diff);
}
for (var i = 0; i < Regexes.Length; i++)
{
diff = Regexes[i].CompareTo(intersection.Regexes[i]);
if (diff != 0)
{
return(diff);
}
}
return(0);
}
public override int CompareTo(RegEx <T> other)
{
var diff = TypeId - other.TypeId;
if (diff != 0)
{
return(diff);
}
var concat = other as RegExConcat <T>;
diff = Regexes.Length - concat.Regexes.Length;
if (diff != 0)
{
return(diff);
}
for (var i = 0; i < Regexes.Length; i++)
{
diff = Regexes[i].CompareTo(concat.Regexes[i]);
if (diff != 0)
{
return(diff);
}
}
return(0);
}
private static RegExDfa <char> MakeRegexDfa(RegEx <char> regex, uint category)
{
var result = new RegExDfa <char>(regex, category);
DfaUtils.DfaStatesConcpetCheck <char> .CheckDfaStates(result);
return(result);
}
// typeid diff if other is not star
// compareTo( Regex, other.Regex ) otherwise
public override int CompareTo(RegEx <T> other)
{
var diff = TypeId - other.TypeId;
if (diff != 0)
{
return(diff);
}
var star = other as RegExStar <T>;
return(Regex.CompareTo(star.Regex));
}
// typeid diff if other is not star
// c - other.c otherwise
public override int CompareTo(RegEx <T> other)
{
var diff = TypeId - other.TypeId;
if (diff != 0)
{
return(diff);
}
var range = other as RegExRange <T>;
return(Character.CompareTo(range.Character));
}
// typeid diff if other is not complement
// compareTo( Regex, other.Regex ) otherwise
public override int CompareTo(RegEx <T> other)
{
var diff = TypeId - other.TypeId;
if (diff != 0)
{
return(diff);
}
var complement = other as RegExComplement <T>;
return(Regex.CompareTo(complement.Regex));
}
private DFAState <T> CalculateDfaState(RegEx <T> regEx)
{
if (dictionaryOfDfaStates.ContainsKey(regEx))
{
return(dictionaryOfDfaStates[regEx]); //return this state
}
var new_state = new DFAState <T>();
dictionaryOfDfaStates.Add(regEx, new_state);
var listOfTransitions = new List <KeyValuePair <T, DFAState <T> > >();
foreach (var c in regEx.DerivChanges())
{
listOfTransitions.Add(new KeyValuePair <T, DFAState <T> >(c, CalculateDfaState(regEx.Derivative(c))));
}
if (regEx.HasEpsilon())
{
new_state._accepting = accepting;
}
else
{
new_state._accepting = 0;
}
if (listOfTransitions.Count == 0 || !listOfTransitions[0].Key.Equals(MinSymbol <T>()))
{
if (deadState == null)
{
deadState = new DFAState <T>();
deadState._accepting = 0;
deadState._transitions = new KeyValuePair <T, DFAState <T> >[] { new KeyValuePair <T, DFAState <T> >(MinSymbol <T>(), deadState) };
}
listOfTransitions.Insert(0, new KeyValuePair <T, DFAState <T> >(MinSymbol <T>(), deadState));
for (int i = 1; i < listOfTransitions.Count; i++)
{
if (listOfTransitions[i - 1].Key.CompareTo(listOfTransitions[i].Key) >= 0)
{
throw new Exception("Inpropper order");
}
}
}
new_state._transitions = listOfTransitions.ToArray();
return(new_state);
}
protected bool isRegExComplex(RegEx <T> r)
{
var intersection = r as RegExIntersection <T>;
var union = r as RegExUnion <T>;
if (intersection != null)
{
return(intersection.Regexes.Length > 1);
}
if (union != null)
{
return(union.Regexes.Length > 1);
}
return(false);
}
/// <summary>
/// RegEx representing Kleene star of RegExes.
/// Properties:
/// X** = X*
/// epsi* ~ empty* ~ epsi
/// all* ~ all
/// </summary>
/// <param name="regex">RegEx to be starred</param>
public static RegEx <T> Star <T>(RegEx <T> regex) where T : IComparable <T>, IEquatable <T>
{
// all* ~ all
if (0 == All <T> ().CompareTo(regex))
{
return(All <T> ());
}
// epsi* ~ empty* ~ epsi
if (0 == Epsilon <T>().CompareTo(regex) || 0 == Empty <T>().CompareTo(regex))
{
return(Epsilon <T>());
}
// X** ~ X*
return(regex is RegExStar <T>?regex : new RegExStar <T>(regex));
}
/// <summary>
/// Properties:
/// ~~X ~ X
/// ~all ~ empty
/// ~empty ~ all
/// </summary>
/// <param name="regex"></param>
public static RegEx <T> Complement <T>(RegEx <T> regex) where T : IComparable <T>, IEquatable <T>
{
// ~all ~ empty
if (All <T> ().Equals(regex))
{
return(Empty <T> ());
}
// ~empty ~ all
if (Empty <T> ().Equals(regex))
{
return(All <T> ());
}
// ~~X ~ X
var rcomp = regex as RegExComplement <T>;
return(rcomp != null ? rcomp.Regex : new RegExComplement <T>(regex));
}
// 0 if other is RegExEpsilon
// a < 0 otherwise
// => RegExEpsilon is the 'smallest' one
public override int CompareTo(RegEx <T> other)
{
return(TypeId - other.TypeId);
}
/// <summary>
/// Create RegExDfa from RegEx
/// </summary>
/// <param name="regEx">Regular Expression from which is made automata</param>
/// <param name="acceptingStateMarker">Number for accepting states</param>
public RegExDfa(RegEx <T> regEx, uint acceptingStateMarker)
{
accepting = acceptingStateMarker;
_start = CalculateDfaState(regEx);
}
internal RegExComplement(RegEx <T> regex)
{
TypeId = 3;
Regex = regex;
}
public virtual int CompareTo(RegEx <T> other)
{
//Derived classes should override this method
throw new NotImplementedException();
}
internal RegExStar(RegEx <T> regex)
{
this.TypeId = 2;
this.Regex = regex;
}
private static RegEx <char> Sanitize(RegEx <char> result)
{
return(RegExFactory.Intersection(result, RegExFactory.Star(CharactersClasses.print)));
}
public bool Equals(RegEx <T> other)
{
// should be correlated with compareTo
return(CompareTo(other) == 0);
}
public static RegEx <N> Convert <N>(RegEx <T> regex, Func <T, N> converter)
where N : IComparable <N>, IEquatable <N>
{
switch (regex.TypeId)
{
case 0:
return(RegExEpsilon <N> .RegexEpsilon);
case 1:
{
var r = regex as RegExRange <T>;
return(new RegExRange <N>(converter(r.Character)));
}
case 2:
{
var r = regex as RegExStar <T>;
return(new RegExStar <N>(Convert(r.Regex, converter)));
}
case 3:
{
var r = regex as RegExComplement <T>;
return(new RegExComplement <N>(Convert(r.Regex, converter)));
}
case 4:
{
var r = regex as RegExConcat <T>;
var l = new LinkedList <RegEx <N> >();
foreach (var recr in r.Regexes)
{
l.AddLast(Convert(recr, converter));
}
return(new RegExConcat <N>(l.ToArray()));
}
case 5:
{
var r = regex as RegExUnion <T>;
var l = new LinkedList <RegEx <N> >();
foreach (var recr in r.Regexes)
{
l.AddLast(Convert(recr, converter));
}
return(new RegExUnion <N>(l.ToArray()));
}
case 6:
{
var r = regex as RegExIntersection <T>;
var l = new LinkedList <RegEx <N> >();
foreach (var recr in r.Regexes)
{
l.AddLast(Convert(recr, converter));
}
return(new RegExIntersection <N>(l.ToArray()));
}
}
return(null);
}
private static RegEx <char> ParseAtom()
{
if (HasPrefix("["))
{
Eat(1);
bool complement = false;
if (HasPrefix("^"))
{
Eat(1);
complement = true;
}
RegEx <char> atom = null;
if (HasPrefix(":digit:"))
{
atom = CharactersClasses.digit;
}
if (HasPrefix(":print:"))
{
atom = CharactersClasses.print;
}
if (HasPrefix(":space:"))
{
atom = CharactersClasses.space;
}
if (atom == null)
{
List <RegEx <char> > chars = new List <RegEx <char> > ();
char ch;
while ((ch = Peek()) != ']')
{
if (ch.Equals('\\'))
{
Accept("]");
chars.Add(SingleChar(']'));
}
else
{
chars.Add(SingleChar(ch));
}
}
atom = RegExFactory.Union(chars.ToArray());
}
else
{
Eat(7);
Accept("]");
}
if (complement)
{
return(RegExFactory.Intersection(RegExFactory.Range((char)0), RegExFactory.Complement(atom)));
}
else
{
return(atom);
}
}
if (HasPrefix("."))
{
Eat(1);
return(RegExFactory.Range((char)0));
}
if (HasPrefix("("))
{
Eat(1);
var node = ParseBinaryOperators();
if (node == null)
{
throw new ParseError("Parentheses around the null expression.");
}
Accept(")");
return(node);
}
if (HasPrefix("^"))
{
Eat(1);
var node = ParseAtom();
if (node == null)
{
throw new ParseError("Unassigned ^.");
}
return(RegExFactory.Complement(node));
}
if (HasPrefix("\\"))
{
Eat(1);
char a = Peek();
if (!specialCharacters.Contains("" + a))
{
throw new ParseError("Special character required.");
}
return(SingleChar(a));
}
if (HasNext())
{
var a = Peek();
if (specialCharacters.Contains("" + a))
{
--head;
return(null);
}
return(SingleChar(a));
}
return(null);
}