private string GetQuantifierComment(QuantifierKind kind)
{
switch (kind)
{
case QuantifierKind.Maybe:
return("zero or one time");
case QuantifierKind.MaybeMany:
return("zero or more times");
case QuantifierKind.OneMany:
return("one or more times");
case QuantifierKind.Count:
return($"exactly {CurrentLine.Count1} times");
case QuantifierKind.CountRange:
return($"from {CurrentLine.Count1} to {CurrentLine.Count2} times");
case QuantifierKind.CountFrom:
return($"at least {CurrentLine.Count1} times");
case QuantifierKind.MaybeCount:
return($"from zero to {CurrentLine.Count2} times");
}
return(null);
}
public TokenInterQuantifier(TokenInterPrimitiveEntry primitiveEntry, QuantifierKind kind, QuantifierMode mode = QuantifierMode.Greedy)
{
PrimitiveEntry = primitiveEntry;
Range = QuantifierHelper.GetRange(kind);
Kind = kind;
Mode = mode;
}
public QuantifierEntry(TokenPrimitiveEntry primitiveEntry, QuantifierKind kind, QuantifierMode mode)
{
PrimitiveEntry = primitiveEntry;
Kind = kind;
Mode = mode;
Range = QuantifierHelper.GetRange(kind);
}
public ParserQuantifierEntry(ParserPrimitiveEntry primitiveEntry, QuantifierKind kind, QuantifierMode mode)
{
PrimitiveEntry = primitiveEntry;
Kind = kind;
Range = QuantifierHelper.GetRange(kind);
Mode = mode;
}
private QuantifierEntry(PrimitiveEntry primitiveEntry, QuantifierKind kind, QuantifierMode mode, int maximum, int minimum)
{
Kind = kind;
Mode = mode;
PrimitiveEntry = primitiveEntry;
Maximum = maximum;
Minimum = minimum;
}
public QuantifierEntry(PrimitiveEntry primitiveEntry, Interval <int> range, QuantifierMode mode)
{
PrimitiveEntry = primitiveEntry;
Kind = QuantifierHelper.GetKind(range);
Mode = mode;
Minimum = range.Minimum;
Maximum = range.Maximum;
}
public QuantifierEntry(PrimitiveEntry primitiveEntry, QuantifierKind kind, QuantifierMode mode)
{
PrimitiveEntry = primitiveEntry;
Kind = kind;
Mode = mode;
var range = QuantifierHelper.GetRange(kind);
Minimum = range.Minimum;
Maximum = range.Maximum;
}
private ParserProductionBuilder CreateQuantifier(QuantifierKind kind, QuantifierMode mode)
{
var parserRule = new ParserRule
{
IsInline = true
};
parserRule.Productions.Add(new ParserProduction(CreateArray()));
return(new ParserProductionBuilder(new ParserQuantifierEntry(new ParserRuleEntry(parserRule), kind, mode)));
}
//if boundVarTypes is null, then this represents not providing explicit types
public TermQuantifier(QuantifierKind quantifier, IList <Identifier> boundVars, IList <TypeIsa> boundVarTypes,
Term term)
{
if (boundVars == null || boundVarTypes != null && boundVars.Count != boundVarTypes.Count)
{
throw new ArgumentException();
}
Quantifier = quantifier;
BoundVars = boundVars;
BoundVarTypes = boundVarTypes;
Term = term;
}
public static QuantifierKind Collapse(QuantifierKind inner, QuantifierKind outer)
{
return((inner, outer) switch
{
(QuantifierKind.ZeroOrOne, QuantifierKind.ZeroOrOne) => QuantifierKind.ZeroOrOne,
(QuantifierKind.ZeroOrOne, QuantifierKind.OneOrMore) => QuantifierKind.ZeroOrMore,
(QuantifierKind.ZeroOrOne, QuantifierKind.ZeroOrMore) => QuantifierKind.ZeroOrMore,
(QuantifierKind.OneOrMore, QuantifierKind.ZeroOrOne) => QuantifierKind.ZeroOrMore,
(QuantifierKind.OneOrMore, QuantifierKind.OneOrMore) => QuantifierKind.OneOrMore,
(QuantifierKind.OneOrMore, QuantifierKind.ZeroOrMore) => QuantifierKind.ZeroOrMore,
(QuantifierKind.ZeroOrMore, QuantifierKind.ZeroOrOne) => QuantifierKind.ZeroOrMore,
(QuantifierKind.ZeroOrMore, QuantifierKind.OneOrMore) => QuantifierKind.ZeroOrMore,
(QuantifierKind.ZeroOrMore, QuantifierKind.ZeroOrMore) => QuantifierKind.ZeroOrMore,
_ => throw new InvalidOperationException()
});
private string GetQuantifierComment(QuantifierKind kind)
{
switch (kind)
{
case QuantifierKind.Maybe:
return "zero or one time";
case QuantifierKind.MaybeMany:
return "zero or more times";
case QuantifierKind.OneMany:
return "one or more times";
case QuantifierKind.Count:
return $"exactly {Current.Count1} times";
case QuantifierKind.CountRange:
return $"from {Current.Count1} to {Current.Count2} times";
case QuantifierKind.CountFrom:
return $"at least {Current.Count1} times";
case QuantifierKind.MaybeCount:
return $"from zero to {Current.Count1} times";
}
return null;
}
public Quantifier(string expression)
{
if (expression.Length == 0)
{
Kind = QuantifierKind.None;
MaximumMatches = 1;
MinimumMatches = 1;
}
else if (expression.Length > 1)
{
Kind = QuantifierKind.Expression;
Match m = Matcher.Match(expression);
if (!m.Success)
{
throw new ArgumentException(string.Format("Cannot extract a Quantifier from the expression {1}", expression));
}
int minimum;
// shouldn't ever happen
if (!int.TryParse(m.Groups["min"].Value, out minimum))
{
throw new ArgumentException("Cannot Parse Quantifier Expression into Range");
}
MinimumMatches = minimum;
string maximumString = m.Groups["max"].Value; // drop the comma
if (maximumString.Length > 1)
{
int maximum;
// shouldn't ever happen
if (!int.TryParse(maximumString.Substring(1), out maximum))
{
throw new ArgumentException("Cannot Parse Quantifier Expression into Range");
}
MaximumMatches = maximum;
}
else if (maximumString.Length == 1) // got a comma, so we're unbounded
{
MaximumMatches = int.MaxValue;
}
else // exact match, because no comma
{
MaximumMatches = minimum;
}
}
else
{
switch (expression.ToCharArray()[0])
{
case '*':
MinimumMatches = 0;
MaximumMatches = int.MaxValue;
Kind = QuantifierKind.Wildcard;
break;
case '+':
MinimumMatches = 1;
MaximumMatches = int.MaxValue;
Kind = QuantifierKind.Wildcard;
break;
case '?':
MinimumMatches = 0;
MaximumMatches = 1;
Kind = QuantifierKind.Wildcard;
break;
default:
throw new ArgumentException("Passed Quantifier String was not an allowed Quantifier");
}
}
}
public TermQuantifier(QuantifierKind quantifier, IList <Identifier> boundVars, Term term) : this(quantifier,
boundVars, null, term)
{
}
public static bool CanCollapse(QuantifierKind inner, QuantifierKind outer)
{
return(inner != QuantifierKind.Generic && outer != QuantifierKind.Generic);
}
public InvocationQuantifier(QuantifierKind kind)
{
this.kind = kind;
}
