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; }