public void DumpDot()
{
string rawRegEx = @"\d{3}-\d{2}-(a|q)J";
rawRegEx = @"0x[0-9A-Fa-f]{4}";
Fare.RegExp e = new Fare.RegExp(rawRegEx);
var a = e.ToAutomaton();
_testOutput.WriteLine($"/* {rawRegEx} */");
_testOutput.WriteLine(Fare.DotFormatter.ToDot(a));
// fail test to get output
Assert.True(false);
}
private void FindLeaves(
RegExp exp,
Kind regExpKind,
IList <Automaton> list,
IDictionary <String, Automaton> automata,
IAutomatonProvider automatonProvider,
bool minimize)
{
if (exp.kind == regExpKind)
{
this.FindLeaves(exp.exp1, regExpKind, list, automata, automatonProvider, minimize);
this.FindLeaves(exp.exp2, regExpKind, list, automata, automatonProvider, minimize);
}
else
{
list.Add(exp.ToAutomaton(automata, automatonProvider, minimize));
}
}
public void DumpAST()
{
string rawRegEx = @"\d{3}\d3}";
Fare.RegExp e = new Fare.RegExp(rawRegEx);
var a = e.ToAutomaton();
_testOutput.WriteLine($"expr: {rawRegEx} has {a.NumberOfStates} states and {a.NumberOfTransitions} transistions");
foreach (var state in a.GetStates())
{
_testOutput.WriteLine($"\tState (Id:{state.Id}, Number:{state.Number}, Accept: {state.Accept}) has {state.Transitions.Count} transitions");
foreach (var trans in state.GetSortedTransitions(false))
{
_testOutput.WriteLine($"\t\tTransition to: {trans.To.Id} [{trans.Min} - {trans.Max}]");
}
}
// fail test to get output
Assert.True(false);
}
/// <summary>
/// Initializes a new instance of the <see cref="Xeger"/> class.
/// </summary>
/// <param name="regex">The regex.</param>
/// <param name="random">The random.</param>
/// <param name="anyCharAlphabet">The list of characters used for computing the possible values for classes "." "\s", "\d", "\w" (and "\S", "\D", "\W"). It does not check explicitly defined chars in regexp.</param>
public Xeger(string regex, Random random, string anyCharAlphabet = null)
{
if (string.IsNullOrEmpty(regex))
{
throw new ArgumentNullException("regex");
}
if (random == null)
{
throw new ArgumentNullException("random");
}
if (anyCharAlphabet != null)
{
this.anyCharAlphabet = anyCharAlphabet;
}
regex = RemoveStartEndMarkers(regex);
var rx = new RegExp(regex, anyCharAlphabet, AllExceptAnyString);
this.UsedAlphabet = rx.UsedAlphabet();
this.automaton = rx.ToAutomaton();
this.random = random;
}
private void FindLeaves(
RegExp exp,
Kind regExpKind,
IList<Automaton> list,
IDictionary<String, Automaton> automata,
IAutomatonProvider automatonProvider,
bool minimize)
{
if (exp.kind == regExpKind)
{
this.FindLeaves(exp.exp1, regExpKind, list, automata, automatonProvider, minimize);
this.FindLeaves(exp.exp2, regExpKind, list, automata, automatonProvider, minimize);
}
else
{
list.Add(exp.ToAutomaton(automata, automatonProvider, minimize));
}
}
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 = this.anyCharAlphabet != null?BasicAutomata.MakeCharSet(this.anyCharAlphabet) : 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);
}
