public String GetParseTreeAsString(String rule) { AntlrInputStream input = new AntlrInputStream(rule); RuleSetLexer lexer = new RuleSetLexer(input); var tokens = new CommonTokenStream(lexer); RuleSetParser parser = new RuleSetParser(tokens); return parser.rule_set().ToStringTree(parser); }
public IRuleSet GetCompiledRule(string rule) { AntlrInputStream input = new AntlrInputStream(rule); RuleSetLexer lexer = new RuleSetLexer(input); var tokens = new CommonTokenStream(lexer); RuleSetParser parser = new RuleSetParser(tokens); RuleSetTreeBuilder ruleSetTreeBuilder = new RuleSetTreeBuilder(jsonParser); parser.AddParseListener(ruleSetTreeBuilder); parser.ErrorHandler = new ExceptionThrowingErrorHandler(); parser.rule_set(); return ruleSetTreeBuilder.ruleSet; }
public override void ExitArrayIncludesOneComparisonSpecificationExpression(RuleSetParser.ArrayIncludesOneComparisonSpecificationExpressionContext ctx) { specifications.Push(new ArrayIncludeOne(jsonPathParser, getValueExpression(ctx.value_expr()), getArray(ctx.string_array()))); }
public override void ExitArithmeticExpressionMult(RuleSetParser.ArithmeticExpressionMultContext ctx) { exitRealArithmeticExpression(ArithmeticOperatorType.multiply); }
public override void ExitArithmeticExpressionDiv(RuleSetParser.ArithmeticExpressionDivContext ctx) { exitRealArithmeticExpression(ArithmeticOperatorType.divide); }
public override void EnterRight_arithmetic_expr(RuleSetParser.Right_arithmetic_exprContext ctx) { rightArithmeticExpressions.Clear(); arithmeticExpressions = rightArithmeticExpressions; }
protected String getValueExpression(RuleSetParser.Value_exprContext value_expr) { if (value_expr.jsonpath_expr() != null) { return getJsonPathExpression(value_expr.jsonpath_expr()); } return value_expr.GetText(); }
protected List<String> getArray(RuleSetParser.String_arrayContext string_array) { String arrayString = string_array.GetText() .Replace("(", "") .Replace(")", ""); return Regex.Split(arrayString, "\\s*,\\s*").ToList(); }
public override void ExitNumericEqualComparisonSpecificationExpression(RuleSetParser.NumericEqualComparisonSpecificationExpressionContext ctx) { ArithmeticExpression right = getArithmeticExpression(ctx.numeric_expr(0)); ArithmeticExpression left = getArithmeticExpression(ctx.numeric_expr()[(ctx.numeric_expr().Count - 1)]); specifications.Push(new Equals(jsonPathParser, left, right)); }
public override void ExitNumericConstant(RuleSetParser.NumericConstantContext ctx) { this.arithmeticExpressions.Push(new NumericConstant(float.Parse(ctx.GetText()))); }
public override void ExitLogicalExpressionOr(RuleSetParser.LogicalExpressionOrContext context) { var right = specifications.Pop(); var left = specifications.Pop(); this.specifications.Push(new OrSpecification(jsonPathParser, left, right)); }
public override void ExitLogicalExpressionNot(RuleSetParser.LogicalExpressionNotContext context) { var notspecification = specifications.Pop(); this.specifications.Push(new NotSpecification(jsonPathParser, notspecification)); }
public override void ExitJsonPathExpression(RuleSetParser.JsonPathExpressionContext ctx) { this.arithmeticExpressions.Push(new NumericField(jsonPathParser, ctx.GetText())); }
protected ArithmeticExpression getArithmeticExpression(RuleSetParser.Right_arithmetic_exprContext right_arithmetic_exprContext) { if (rightArithmeticExpressions.Count == 1) { return rightArithmeticExpressions.Pop(); } throw new ArgumentException("Could not determine ArithmeticExpression from arithmetic_exprContext: " + right_arithmetic_exprContext.GetText()); }
public override void ExitNumericLessThanComparisonSpecificationExpression(RuleSetParser.NumericLessThanComparisonSpecificationExpressionContext ctx) { ArithmeticExpression right = (ctx.left_arithmetic_expr() != null) ? getArithmeticExpression(ctx.left_arithmetic_expr()) : getArithmeticExpression(ctx.numeric_expr(0)); ArithmeticExpression left = (ctx.right_arithmetic_expr() != null) ? getArithmeticExpression(ctx.right_arithmetic_expr()) : getArithmeticExpression(ctx.numeric_expr()[(ctx.numeric_expr().Count - 1)]); specifications.Push(new LessThan(jsonPathParser, left, right)); }
protected ArithmeticExpression getArithmeticExpression(RuleSetParser.Numeric_exprContext numeric_exprContext) { if (looseArithmeticExpressions.Count > 0) { return looseArithmeticExpressions.Pop(); } throw new ArgumentException("Could not determine ArithmeticExpression from numeric_exprContext: " + numeric_exprContext.GetText()); }
public override void ExitRight_arithmetic_expr(RuleSetParser.Right_arithmetic_exprContext ctx) { arithmeticExpressions = looseArithmeticExpressions; }
protected String getJsonPathExpression(RuleSetParser.Jsonpath_exprContext jsonpath_expr) { return jsonpath_expr.GetText(); }
public override void ExitRule_set(RuleSetParser.Rule_setContext context) { while (specifications.Count > 0) { ruleSet.AddRule(specifications.Pop()); } }
public override void EnterLeft_arithmetic_expr(RuleSetParser.Left_arithmetic_exprContext ctx) { leftArithmeticExpressions.Clear(); arithmeticExpressions = leftArithmeticExpressions; }
public override void ExitStringEqualsComparisonSpecificationExpression(RuleSetParser.StringEqualsComparisonSpecificationExpressionContext ctx) { specifications.Push(new StringEquals(jsonPathParser, getValueExpression(ctx.value_expr()), ctx.string_comparison_value().GetText())); }
public override void EnterRule_set(RuleSetParser.Rule_setContext context) { this.ruleSet = new RuleSet(); }
public override void ExitTotalledJsonPathExpression(RuleSetParser.TotalledJsonPathExpressionContext ctx) { this.arithmeticExpressions.Push(new TotalFromJsonPathExpression(jsonPathParser, ctx.total_expr().jsonpath_expr().GetText())); }
public override void ExitArithmeticExpressionMinus(RuleSetParser.ArithmeticExpressionMinusContext ctx) { exitRealArithmeticExpression(ArithmeticOperatorType.subtract); }
public override void ExitTotalledNumericGreaterThanComparisonSpecificationExpression(RuleSetParser.TotalledNumericGreaterThanComparisonSpecificationExpressionContext context) { var left = new TotalFromJsonPathExpression(jsonPathParser, context.jsonpath_expr().GetText()); ArithmeticExpression right = (context.right_arithmetic_expr() != null) ? getArithmeticExpression(context.right_arithmetic_expr()) : getArithmeticExpression(context.numeric_expr()); }
public override void ExitArithmeticExpressionPlus(RuleSetParser.ArithmeticExpressionPlusContext ctx) { exitRealArithmeticExpression(ArithmeticOperatorType.add); }
public override void ExitTotalledNumericLessThanComparisonSpecificationExpression(RuleSetParser.TotalledNumericLessThanComparisonSpecificationExpressionContext ctx) { ArithmeticExpression left = new TotalFromJsonPathExpression(jsonPathParser, ctx.jsonpath_expr().GetText()); ArithmeticExpression right = (ctx.right_arithmetic_expr() != null) ? getArithmeticExpression(ctx.right_arithmetic_expr()) : getArithmeticExpression(ctx.numeric_expr()); specifications.Push(new LessThan(jsonPathParser, left, right)); }
public override void ExitBooleanIsTrueComparisonSpecificationExpression(RuleSetParser.BooleanIsTrueComparisonSpecificationExpressionContext ctx) { specifications.Push(new IsTrue(jsonPathParser, getValueExpression(ctx.value_expr()))); }
public RuleSet(string raw) { Rules = RuleSetParser.ParseRules(raw); }