/// <summary>
/// Returns indicator if optional matches.
/// </summary>
/// <returns>
/// indicator
/// </returns>
public static bool IsOptional(this RegexNFATypeEnum value)
{
switch (value)
{
case RegexNFATypeEnum.ONE_OPTIONAL:
return(true);
case RegexNFATypeEnum.ONE_OPTIONAL_RELUCTANT:
return(true);
case RegexNFATypeEnum.ONE_TO_MANY:
return(false);
case RegexNFATypeEnum.ONE_TO_MANY_RELUCTANT:
return(false);
case RegexNFATypeEnum.SINGLE:
return(false);
case RegexNFATypeEnum.ZERO_TO_MANY:
return(true);
case RegexNFATypeEnum.ZERO_TO_MANY_RELUCTANT:
return(true);
}
throw new ArgumentException();
}
/// <summary>
/// Return postfix.
/// </summary>
/// <returns>
/// postfix
/// </returns>
public static string OptionalPostfix(this RegexNFATypeEnum value)
{
switch (value)
{
case RegexNFATypeEnum.ONE_OPTIONAL:
return("?");
case RegexNFATypeEnum.ONE_OPTIONAL_RELUCTANT:
return("??");
case RegexNFATypeEnum.ONE_TO_MANY:
return("+");
case RegexNFATypeEnum.ONE_TO_MANY_RELUCTANT:
return("+?");
case RegexNFATypeEnum.SINGLE:
return("");
case RegexNFATypeEnum.ZERO_TO_MANY:
return("*");
case RegexNFATypeEnum.ZERO_TO_MANY_RELUCTANT:
return("*?");
}
throw new ArgumentException("Invalid pattern type: " + value);
}
public RowRegexExprNode Copy(
RowRegexExprNode nodeToCopy,
RegexNFATypeEnum newType)
{
var atom = (RowRegexExprNodeAtom)nodeToCopy;
return(new RowRegexExprNodeAtom(atom.Tag, newType, null));
}
public RowRegexExprNode Copy(RowRegexExprNode nodeToCopy, RegexNFATypeEnum newType)
{
var nested = (RowRegexExprNodeNested)nodeToCopy;
var nestedCopy = new RowRegexExprNodeNested(newType, null);
foreach (var inner in nested.ChildNodes)
{
var innerCopy = CheckedCopy(inner);
nestedCopy.AddChildNode(innerCopy);
}
return(nestedCopy);
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="type">multiplicity and greedy</param>
public RowRegexExprNodeNested(RegexNFATypeEnum type, RowRegexExprRepeatDesc optionalRepeat)
{
NFAType = type;
OptionalRepeat = optionalRepeat;
}
private static IList <RowRegexExprNode> ExpandRepeat(RowRegexExprNode node,
RowRegexExprRepeatDesc repeat,
RegexNFATypeEnum type,
RowRegexExprNodeCopier copier)
{
var evaluateParams = new EvaluateParams(null, true, null);
// handle single-bounds (no ranges)
IList <RowRegexExprNode> repeated = new List <RowRegexExprNode>();
if (repeat.Single != null)
{
ValidateExpression(repeat.Single);
int numRepeated = repeat.Single.ExprEvaluator.Evaluate(evaluateParams).AsInt();
ValidateRange(numRepeated, 1, int.MaxValue);
for (var i = 0; i < numRepeated; i++)
{
var copy = copier.Copy(node, type);
repeated.Add(copy);
}
return(repeated);
}
// evaluate bounds
int?lower = null;
int?upper = null;
if (repeat.Lower != null)
{
ValidateExpression(repeat.Lower);
lower = (int?)repeat.Lower.ExprEvaluator.Evaluate(evaluateParams);
}
if (repeat.Upper != null)
{
ValidateExpression(repeat.Upper);
upper = (int?)repeat.Upper.ExprEvaluator.Evaluate(evaluateParams);
}
// handle range
if (lower != null && upper != null)
{
ValidateRange(lower.Value, 1, int.MaxValue);
ValidateRange(upper.Value, 1, int.MaxValue);
ValidateRange(lower.Value, 1, upper.Value);
for (var i = 0; i < lower; i++)
{
var copy = copier.Copy(node, type);
repeated.Add(copy);
}
for (int i = lower.Value; i < upper; i++)
{
// make type optional
var newType = type;
if (type == RegexNFATypeEnum.SINGLE)
{
newType = RegexNFATypeEnum.ONE_OPTIONAL;
}
else if (type == RegexNFATypeEnum.ONE_TO_MANY)
{
newType = RegexNFATypeEnum.ZERO_TO_MANY;
}
else if (type == RegexNFATypeEnum.ONE_TO_MANY_RELUCTANT)
{
newType = RegexNFATypeEnum.ZERO_TO_MANY_RELUCTANT;
}
var copy = copier.Copy(node, newType);
repeated.Add(copy);
}
return(repeated);
}
// handle lower-bounds only
if (upper == null)
{
ValidateRange(lower.Value, 1, int.MaxValue);
for (var i = 0; i < lower; i++)
{
var copyInner = copier.Copy(node, type);
repeated.Add(copyInner);
}
// make type optional
var newType = type;
if (type == RegexNFATypeEnum.SINGLE)
{
newType = RegexNFATypeEnum.ZERO_TO_MANY;
}
else if (type == RegexNFATypeEnum.ONE_OPTIONAL)
{
newType = RegexNFATypeEnum.ZERO_TO_MANY;
}
else if (type == RegexNFATypeEnum.ONE_OPTIONAL_RELUCTANT)
{
newType = RegexNFATypeEnum.ZERO_TO_MANY_RELUCTANT;
}
else if (type == RegexNFATypeEnum.ONE_TO_MANY)
{
newType = RegexNFATypeEnum.ZERO_TO_MANY;
}
else if (type == RegexNFATypeEnum.ONE_TO_MANY_RELUCTANT)
{
newType = RegexNFATypeEnum.ZERO_TO_MANY_RELUCTANT;
}
var copy = copier.Copy(node, newType);
repeated.Add(copy);
return(repeated);
}
// handle upper-bounds only
ValidateRange(upper.Value, 1, int.MaxValue);
for (var i = 0; i < upper; i++)
{
// make type optional
var newType = type;
if (type == RegexNFATypeEnum.SINGLE)
{
newType = RegexNFATypeEnum.ONE_OPTIONAL;
}
else if (type == RegexNFATypeEnum.ONE_TO_MANY)
{
newType = RegexNFATypeEnum.ZERO_TO_MANY;
}
else if (type == RegexNFATypeEnum.ONE_TO_MANY_RELUCTANT)
{
newType = RegexNFATypeEnum.ZERO_TO_MANY_RELUCTANT;
}
var copy = copier.Copy(node, newType);
repeated.Add(copy);
}
return(repeated);
}
/// <summary>
/// Ctor.
/// </summary>
/// <param name="tag">variable name</param>
/// <param name="type">multiplicity and greedy indicator</param>
/// <param name="optionalRepeat">optional repeating information</param>
public RowRegexExprNodeAtom(String tag, RegexNFATypeEnum type, RowRegexExprRepeatDesc optionalRepeat)
{
Tag = tag;
NFAType = type;
OptionalRepeat = optionalRepeat;
}
