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 ToAutomatonAllowMutate(
IDictionary <string, Automaton> automata,
IAutomatonProvider automatonProvider,
bool minimize)
{
bool @bool = false;
if (allowMutation)
{
@bool = RegExp.SetAllowMutate(true); // This is not thead safe.
}
Automaton a = this.ToAutomaton(automata, automatonProvider, minimize);
if (allowMutation)
{
RegExp.SetAllowMutate(@bool);
}
return(a);
}
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));
}
}
/// <summary>
/// Constructs new <code>Automaton</code> from this <code>RegExp</code>.
/// The constructed automaton has no transitions to dead states.
/// </summary>
/// <param name = "automatonProvider">The provider of automata for named identifiers.</param>
/// <param name = "minimize">if set to <c>true</c> the automaton is minimized and determinized.</param>
/// <returns></returns>
public Automaton ToAutomaton(IAutomatonProvider automatonProvider, bool minimize)
{
return this.ToAutomatonAllowMutate(null, automatonProvider, minimize);
}
/// <summary>
/// Constructs new <code>Automaton</code> from this <code>RegExp</code>.
/// The constructed automaton is minimal and deterministic and has no
/// transitions to dead states.
/// </summary>
/// <param name = "automatonProvider">The provider of automata for named identifiers.</param>
/// <returns></returns>
public Automaton ToAutomaton(IAutomatonProvider automatonProvider)
{
return this.ToAutomatonAllowMutate(null, automatonProvider, true);
}
private Automaton ToAutomaton(
IDictionary <string, Automaton> automata,
IAutomatonProvider automatonProvider,
bool minimize)
{
IList <Automaton> list;
Automaton a = null;
switch (this.kind)
{
case Kind.RegexpUnion:
list = new List <Automaton>();
this.FindLeaves(this.exp1, Kind.RegexpUnion, list, automata, automatonProvider, minimize);
this.FindLeaves(this.exp2, Kind.RegexpUnion, list, automata, automatonProvider, minimize);
a = BasicOperations.Union(list);
a.Minimize();
break;
case Kind.RegexpConcatenation:
list = new List <Automaton>();
this.FindLeaves(this.exp1, Kind.RegexpConcatenation, list, automata, automatonProvider, minimize);
this.FindLeaves(this.exp2, Kind.RegexpConcatenation, list, automata, automatonProvider, minimize);
a = BasicOperations.Concatenate(list);
a.Minimize();
break;
case Kind.RegexpIntersection:
a = this.exp1.ToAutomaton(automata, automatonProvider, minimize)
.Intersection(this.exp2.ToAutomaton(automata, automatonProvider, minimize));
a.Minimize();
break;
case Kind.RegexpOptional:
a = this.exp1.ToAutomaton(automata, automatonProvider, minimize).Optional();
a.Minimize();
break;
case Kind.RegexpRepeat:
a = this.exp1.ToAutomaton(automata, automatonProvider, minimize).Repeat();
a.Minimize();
break;
case Kind.RegexpRepeatMin:
a = this.exp1.ToAutomaton(automata, automatonProvider, minimize).Repeat(this.min);
a.Minimize();
break;
case Kind.RegexpRepeatMinMax:
a = this.exp1.ToAutomaton(automata, automatonProvider, minimize).Repeat(this.min, this.max);
a.Minimize();
break;
case Kind.RegexpComplement:
a = this.exp1.ToAutomaton(automata, automatonProvider, minimize).Complement();
a.Minimize();
break;
case Kind.RegexpChar:
a = BasicAutomata.MakeChar(this.c);
break;
case Kind.RegexpCharRange:
a = BasicAutomata.MakeCharRange(this.@from, this.to);
break;
case Kind.RegexpAnyChar:
a = BasicAutomata.MakeAnyChar();
break;
case Kind.RegexpEmpty:
a = BasicAutomata.MakeEmpty();
break;
case Kind.RegexpString:
a = BasicAutomata.MakeString(this.s);
break;
case Kind.RegexpAnyString:
a = BasicAutomata.MakeAnyString();
break;
case Kind.RegexpAutomaton:
Automaton aa = null;
if (automata != null)
{
automata.TryGetValue(this.s, out aa);
}
if (aa == null && automatonProvider != null)
{
try
{
aa = automatonProvider.GetAutomaton(this.s);
}
catch (IOException e)
{
throw new ArgumentException(string.Empty, e);
}
}
if (aa == null)
{
throw new ArgumentException("'" + this.s + "' not found");
}
a = aa.Clone(); // Always clone here (ignore allowMutate).
break;
case Kind.RegexpInterval:
a = BasicAutomata.MakeInterval(this.min, this.max, this.digits);
break;
}
return(a);
}
internal Automaton ToAutomaton(IAutomatonProvider automatonProvider)
{
return(this.ToAutomatonAllowMutate(null, automatonProvider, true));
}
public Automaton ToAutomaton(IAutomatonProvider automatonProvider, bool minimize) => ToAutomatonAllowMutate(null, automatonProvider, minimize);
private void FindLeaves(RegExp exp, Kind kind, IList <Automaton> list, IDictionary <string, Automaton> automata, IAutomatonProvider automaton_provider)
{
if (exp.kind == kind)
{
FindLeaves(exp.exp1, kind, list, automata, automaton_provider);
FindLeaves(exp.exp2, kind, list, automata, automaton_provider);
}
else
{
list.Add(exp.ToAutomaton(automata, automaton_provider));
}
}
/// <summary>
/// Constructs a query for terms matching <paramref name="term"/>.
/// </summary>
/// <param name="term"> Regular expression. </param>
/// <param name="flags"> Optional <see cref="RegExp"/> features from <see cref="RegExpSyntax"/> </param>
/// <param name="provider"> Custom <see cref="IAutomatonProvider"/> for named automata </param>
public RegexpQuery(Term term, RegExpSyntax flags, IAutomatonProvider provider)
: base(term, (new RegExp(term.Text(), flags)).ToAutomaton(provider))
{
}
private Automaton ToAutomaton(IDictionary <string, Automaton> automata, IAutomatonProvider automaton_provider)
{
IList <Automaton> list;
Automaton a = null;
switch (kind)
{
case Kind.REGEXP_UNION:
list = new List <Automaton>();
FindLeaves(exp1, Kind.REGEXP_UNION, list, automata, automaton_provider);
FindLeaves(exp2, Kind.REGEXP_UNION, list, automata, automaton_provider);
a = BasicOperations.Union(list);
MinimizationOperations.Minimize(a);
break;
case Kind.REGEXP_CONCATENATION:
list = new List <Automaton>();
FindLeaves(exp1, Kind.REGEXP_CONCATENATION, list, automata, automaton_provider);
FindLeaves(exp2, Kind.REGEXP_CONCATENATION, list, automata, automaton_provider);
a = BasicOperations.Concatenate(list);
MinimizationOperations.Minimize(a);
break;
case Kind.REGEXP_INTERSECTION:
a = exp1.ToAutomaton(automata, automaton_provider).Intersection(exp2.ToAutomaton(automata, automaton_provider));
MinimizationOperations.Minimize(a);
break;
case Kind.REGEXP_OPTIONAL:
a = exp1.ToAutomaton(automata, automaton_provider).Optional();
MinimizationOperations.Minimize(a);
break;
case Kind.REGEXP_REPEAT:
a = exp1.ToAutomaton(automata, automaton_provider).Repeat();
MinimizationOperations.Minimize(a);
break;
case Kind.REGEXP_REPEAT_MIN:
a = exp1.ToAutomaton(automata, automaton_provider).Repeat(min);
MinimizationOperations.Minimize(a);
break;
case Kind.REGEXP_REPEAT_MINMAX:
a = exp1.ToAutomaton(automata, automaton_provider).Repeat(min, max);
MinimizationOperations.Minimize(a);
break;
case Kind.REGEXP_COMPLEMENT:
a = exp1.ToAutomaton(automata, automaton_provider).Complement();
MinimizationOperations.Minimize(a);
break;
case Kind.REGEXP_CHAR:
a = BasicAutomata.MakeChar(c);
break;
case Kind.REGEXP_CHAR_RANGE:
a = BasicAutomata.MakeCharRange(from, to);
break;
case Kind.REGEXP_ANYCHAR:
a = BasicAutomata.MakeAnyChar();
break;
case Kind.REGEXP_EMPTY:
a = BasicAutomata.MakeEmpty();
break;
case Kind.REGEXP_STRING:
a = BasicAutomata.MakeString(s);
break;
case Kind.REGEXP_ANYSTRING:
a = BasicAutomata.MakeAnyString();
break;
case Kind.REGEXP_AUTOMATON:
Automaton aa = null;
if (automata != null)
{
aa = automata[s];
}
if (aa == null && automaton_provider != null)
{
try
{
aa = automaton_provider.GetAutomaton(s);
}
catch (Exception e) when(e.IsIOException())
{
throw new ArgumentException(e.ToString(), e);
}
}
if (aa == null)
{
throw new ArgumentException("'" + s + "' not found");
}
a = (Automaton)aa.Clone(); // always clone here (ignore allow_mutate)
break;
case Kind.REGEXP_INTERVAL:
a = BasicAutomata.MakeInterval(min, max, digits);
break;
}
return(a);
}
private Automaton ToAutomatonAllowMutate(IDictionary <string, Automaton> automata, IAutomatonProvider automaton_provider)
{
bool b = false;
if (allow_mutation) // thread unsafe
{
b = Automaton.SetAllowMutate(true);
}
Automaton a = ToAutomaton(automata, automaton_provider);
if (allow_mutation)
{
Automaton.SetAllowMutate(b);
}
return(a);
}
public virtual Automaton ToAutomaton(IAutomatonProvider automaton_provider)
{
return(ToAutomatonAllowMutate(null, automaton_provider));
}
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 Automaton ToAutomaton(IAutomatonProvider automatonProvider, bool minimize)
{
return(this.ToAutomatonAllowMutate(null, automatonProvider, minimize));
}
private Automaton ToAutomatonAllowMutate(
IDictionary<string, Automaton> automata,
IAutomatonProvider automatonProvider,
bool minimize)
{
bool @bool = false;
if (allowMutation)
{
@bool = this.SetAllowMutate(true); // This is not thead safe.
}
Automaton a = this.ToAutomaton(automata, automatonProvider, minimize);
if (allowMutation)
{
this.SetAllowMutate(@bool);
}
return a;
}
public Automaton ToAutomaton(IAutomatonProvider automatonProvider) => ToAutomatonAllowMutate(null, automatonProvider, true);