// --- ComparisonPredicate --- public override void ExitComparisonPredicateNone(NSPredicateParser.ComparisonPredicateNoneContext context) { ComparisonPredicate pred = Stack.Pop(); var subpred = ComparisonPredicate.Comparison(pred.LeftExpression, pred.PredicateOperatorType, pred.RightExpression, ComparisonPredicateModifier.Any, pred.Options); var not = CompoundPredicate.Not(subpred); Stack.Push(not); }
// | CONTAINS # OpContains public override void ExitOpContains(NSPredicateParser.OpContainsContext context) { Operators.Push(PredicateOperatorType.Contains); }
public override void ExitComparisonPredicateSome(NSPredicateParser.ComparisonPredicateSomeContext context) { ComparisonPredicate pred = Stack.Pop(); var any = ComparisonPredicate.Comparison(pred.LeftExpression, pred.PredicateOperatorType, pred.RightExpression, ComparisonPredicateModifier.Any, pred.Options); Stack.Push(any); }
// | IDENTIFIER '(' expression_list ')' # ExprArgFunction public override void EnterExprArgFunction(NSPredicateParser.ExprArgFunctionContext context) { Stack.Push(new FunctionArgSentinel()); }
public override void ExitValueTrue(NSPredicateParser.ValueTrueContext context) { Stack.Push(Expr.MakeConstant(true)); }
public override void ExitValueSelf(NSPredicateParser.ValueSelfContext context) { Stack.Push(Expr.MakeEvaluatedObject()); }
public override void ExitValueNull(NSPredicateParser.ValueNullContext context) { Stack.Push(Expr.MakeConstant(null)); }
// --- ConstantExprs --- public override void ExitValueEmptyAggregate(NSPredicateParser.ValueEmptyAggregateContext context) { Stack.Push(Expr.MakeAggregate(new Expr[] { })); }
// < public override void ExitOpLessThan(NSPredicateParser.OpLessThanContext context) { Operators.Push(PredicateOperatorType.LessThan); }
// | IN # OpIn public override void ExitOpIn(NSPredicateParser.OpInContext context) { Operators.Push(PredicateOperatorType.In); }
// >= public override void ExitOpGreaterThanOrEqualTo(NSPredicateParser.OpGreaterThanOrEqualToContext context) { Operators.Push(PredicateOperatorType.GreaterThanOrEqualTo); }
public override void ExitOperatorOptionsSpecified(NSPredicateParser.OperatorOptionsSpecifiedContext context) { string optStr = context.IDENTIFIER().GetText().ToLower(); ComparisonPredicateOptions opts = 0; if (optStr.Contains("c")) { opts |= ComparisonPredicateOptions.CaseInsensitive; } if (optStr.Contains("d")) { opts |= ComparisonPredicateOptions.DiacriticInsensitive; } ComparisonOptions.Push(opts); }
public override void ExitOperatorOptionsBare(NSPredicateParser.OperatorOptionsBareContext context) { ComparisonOptions.Push(0); }
public override void ExitOperatorBetween(NSPredicateParser.OperatorBetweenContext context) { ComparisonOptions.Push(0); Operators.Push(PredicateOperatorType.Between); }
// | ENDS_WITH # OpEndsWith public override void ExitOpEndsWith(NSPredicateParser.OpEndsWithContext context) { Operators.Push(PredicateOperatorType.EndsWith); }
public override void ExitUnqualifiedComparisonPredicate(NSPredicateParser.UnqualifiedComparisonPredicateContext context) { var rhs = Stack.Pop(); var lhs = Stack.Pop(); var pred = ComparisonPredicate.Comparison(lhs, Operators.Pop(), rhs, ComparisonPredicateModifier.Direct, ComparisonOptions.Pop()); Stack.Push(pred); }
public override void ExitValueAggregate(NSPredicateParser.ValueAggregateContext context) { var exprs = new List<Expr>(); do { var expr = Stack.Pop(); if (expr is Expr) { exprs.Insert(0, expr); } else { Debug.Assert(expr is AggregateSentinel); break; } } while (true); Stack.Push(Expr.MakeAggregate(exprs)); }
// | LIKE # OpLike public override void ExitOpLike(NSPredicateParser.OpLikeContext context) { Operators.Push(PredicateOperatorType.Like); }
public override void ExitValueFormat(NSPredicateParser.ValueFormatContext context) { // Figure out the index of the positional argument that we have here int start = context.Start.StartIndex; int position = PositionalArgumentLocations[start]; var format = context.FORMAT().GetText(); if (format == "%K") { Stack.Push(Expr.MakeKeyPath(FormatArguments[position])); } else { Stack.Push(Expr.MakeConstant(FormatArguments[position])); } }
// | MATCHES # OpMatches public override void ExitOpMatches(NSPredicateParser.OpMatchesContext context) { Operators.Push(PredicateOperatorType.Matches); }
public override void ExitValueNumber(NSPredicateParser.ValueNumberContext context) { var numStr = context.NUMBER().GetText(); if (numStr.Contains(".")) { double val = double.Parse(numStr); Stack.Push(Expr.MakeConstant(val)); } else { int val = int.Parse(numStr); Stack.Push(Expr.MakeConstant(val)); } }
// != public override void ExitOpNotEqualTo(NSPredicateParser.OpNotEqualToContext context) { Operators.Push(PredicateOperatorType.NotEqualTo); }
public override void ExitValueString(NSPredicateParser.ValueStringContext context) { var str = context.STRING().GetText(); str = str.Substring(1, str.Length - 2); // Strip quotes str = Unescape(str); Stack.Push(Expr.MakeConstant(str)); }
public override void ExitPredicateFalse(NSPredicateParser.PredicateFalseContext context) { Stack.Push(Predicate.Constant(false)); }
private dynamic _Parse(Func<NSPredicateParser, IParseTree> startRule) { // Figure out where all the positional arguments live in the input PositionalArgumentLocations.Clear(); int positional = 0; bool state = false; for (int i = 0; i < PredicateFormat.Length; i++) { var c = PredicateFormat[i]; if (c == '%') { state = !state; } else if (state && (c == '@' || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) { state = false; PositionalArgumentLocations[i - 1] = positional; positional++; } } // Run the input through antlr to generate the predicate tree AntlrInputStream input = new AntlrInputStream(PredicateFormat); NSPredicateLexer lexer = Lexer = new NSPredicateLexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); NSPredicateParser parser = Parser = new NSPredicateParser(tokens); IParseTree tree = startRule(parser); ParseTreeWalker.Default.Walk(this, tree); return Stack.Pop(); }
public override void ExitPredicateNot(NSPredicateParser.PredicateNotContext context) { Predicate subpred = Stack.Pop(); Stack.Push(CompoundPredicate.Not(subpred)); }
public override void ExitPredicateOr(NSPredicateParser.PredicateOrContext context) { Predicate rhs = Stack.Pop(); Predicate lhs = Stack.Pop(); Stack.Push(CompoundPredicate.Or(new Predicate[] { lhs, rhs })); }
// --- PredicateTrue/False --- public override void ExitPredicateTrue(NSPredicateParser.PredicateTrueContext context) { Stack.Push(Predicate.Constant(true)); }
// | expression '+' expression # ExprAdd public override void ExitExprAdd(NSPredicateParser.ExprAddContext context) { var rhs = Stack.Pop(); var lhs = Stack.Pop(); Stack.Push(Expr.MakeFunction("add:to:", rhs, lhs)); }
public override void ExitIndexSize(NSPredicateParser.IndexSizeContext context) { Stack.Push(Expr.MakeSymbolic(SymbolicValueType.SIZE)); }