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