public static Pair <ITree, CommonTokenStream> ParseEventProperty(String text) { ParseRuleSelector startRuleSelector = parser => (ITree)parser.startEventPropertyRule(); return(Parse(startRuleSelector, text)); }
public static Pair <ITree, CommonTokenStream> ParseJson(String text) { ParseRuleSelector startRuleSelector = parser => parser.startJsonValueRule(); return(Parse(startRuleSelector, text)); }
public static Pair <ITree, CommonTokenStream> ParseEPL(String text) { ParseRuleSelector startRuleSelector = parser => (ITree)parser.startEPLExpressionRule(); return(Parse(startRuleSelector, text)); }
public static Pair <ITree, CommonTokenStream> Parse( ParseRuleSelector parseRuleSelector, string text) { var lex = ParseHelper.NewLexer(new CaseInsensitiveInputStream(text)); var tokens = new CommonTokenStream(lex); var g = ParseHelper.NewParser(tokens); var ctx = parseRuleSelector.InvokeParseRule(g); return(new Pair <ITree, CommonTokenStream>(ctx, tokens)); }
private static ParseResult HandleScriptAndClassRewrite( CommonTokenStream tokens, string eplStatementErrorMsg, bool addPleaseCheck, ParseRuleSelector parseRuleSelector) { var rewriteExpression = RewriteTokensScript(tokens); var result = Parse(rewriteExpression.RewrittenEPL, eplStatementErrorMsg, addPleaseCheck, parseRuleSelector, false); return new ParseResult( result.Tree, result.ExpressionWithoutAnnotations, result.TokenStream, rewriteExpression.Scripts, rewriteExpression.Classes); }
public static Object ParsePopulate(String json, Type topClass, EngineImportService engineImportService) { var startRuleSelector = new ParseRuleSelector(parser => parser.startJsonValueRule()); var parseResult = ParseHelper.Parse(json, json, true, startRuleSelector, false); var tree = (EsperEPL2GrammarParser.StartJsonValueRuleContext)parseResult.Tree; var parsed = ASTJsonHelper.Walk(parseResult.TokenStream, tree.jsonvalue()); if (!(parsed is IDictionary <String, Object>)) { throw new ExprValidationException( "Failed to map value to object of type " + topClass.FullName + ", expected Json Map/Object format, received " + (parsed != null ? parsed.GetType().Name : "null")); } var objectProperties = (IDictionary <String, Object>)parsed; return(PopulateUtil.InstantiatePopulateObject(objectProperties, topClass, engineImportService)); }
public static Pair <ITree, CommonTokenStream> Parse(ParseRuleSelector parseRuleSelector, String text) { NoCaseSensitiveStream input; try { input = new NoCaseSensitiveStream(text); } catch (IOException ex) { throw new IOException("IOException parsing text '" + text + '\'', ex); } var lex = ParseHelper.NewLexer(input); var tokens = new CommonTokenStream(lex); var g = ParseHelper.NewParser(tokens); var ctx = parseRuleSelector.Invoke(g); return(new Pair <ITree, CommonTokenStream>(ctx, tokens)); }
static EPAdministratorHelper() { PatternParseRule = DoPatternParseRule; EPLParseRule = DoEPLParseRule; }
/// <summary> /// Parse expression using the rule the ParseRuleSelector instance supplies. /// </summary> /// <param name="expression">text to parse</param> /// <param name="eplStatementErrorMsg">text for error</param> /// <param name="addPleaseCheck">true to include depth paraphrase</param> /// <param name="parseRuleSelector">parse rule to select</param> /// <param name="rewriteScript">if set to <c>true</c> [rewrite script].</param> /// <returns> /// AST - syntax tree /// </returns> /// <exception cref="EPException">IOException parsing expression ' + expression + '\''</exception> /// <throws>EPException when the AST could not be parsed</throws> public static ParseResult Parse(String expression, String eplStatementErrorMsg, bool addPleaseCheck, ParseRuleSelector parseRuleSelector, bool rewriteScript) { if (Log.IsDebugEnabled) { Log.Debug(".parse Parsing expr=" + expression); } ICharStream input; try { input = new NoCaseSensitiveStream(expression); } catch (IOException ex) { throw new EPException("IOException parsing expression '" + expression + '\'', ex); } var lex = NewLexer(input); var tokens = new CommonTokenStream(lex); var parser = ParseHelper.NewParser(tokens); ITree tree; try { tree = parseRuleSelector.Invoke(parser); } catch (RecognitionException ex) { tokens.Fill(); if (rewriteScript && IsContainsScriptExpression(tokens)) { return(HandleScriptRewrite(tokens, eplStatementErrorMsg, addPleaseCheck, parseRuleSelector)); } Log.Debug("Error parsing statement [" + expression + "]", ex); throw ExceptionConvertor.ConvertStatement(ex, eplStatementErrorMsg, addPleaseCheck, parser); } catch (Exception e) { try { tokens.Fill(); } catch (Exception ex) { Log.Debug("Token-fill produced exception: " + ex.Message, ex); } if (Log.IsDebugEnabled) { Log.Debug("Error parsing statement [" + eplStatementErrorMsg + "]", e); } if (e.InnerException is RecognitionException) { if (rewriteScript && IsContainsScriptExpression(tokens)) { return(HandleScriptRewrite(tokens, eplStatementErrorMsg, addPleaseCheck, parseRuleSelector)); } throw ExceptionConvertor.ConvertStatement((RecognitionException)e.InnerException, eplStatementErrorMsg, addPleaseCheck, parser); } else { throw; } } // if we are re-writing scripts and contain a script, then rewrite if (rewriteScript && IsContainsScriptExpression(tokens)) { return(HandleScriptRewrite(tokens, eplStatementErrorMsg, addPleaseCheck, parseRuleSelector)); } if (Log.IsDebugEnabled) { Log.Debug(".parse Dumping AST..."); ASTUtil.DumpAST(tree); } var expressionWithoutAnnotation = expression; if (tree is EsperEPL2GrammarParser.StartEPLExpressionRuleContext) { var epl = (EsperEPL2GrammarParser.StartEPLExpressionRuleContext)tree; expressionWithoutAnnotation = GetNoAnnotation(expression, epl.annotationEnum(), tokens); } else if (tree is EsperEPL2GrammarParser.StartPatternExpressionRuleContext) { var pattern = (EsperEPL2GrammarParser.StartPatternExpressionRuleContext)tree; expressionWithoutAnnotation = GetNoAnnotation(expression, pattern.annotationEnum(), tokens); } return(new ParseResult(tree, expressionWithoutAnnotation, tokens, Collections.GetEmptyList <String>())); }
/// <summary> /// Parse expression using the rule the ParseRuleSelector instance supplies. /// </summary> /// <param name="expression">text to parse</param> /// <param name="parseRuleSelector">parse rule to select</param> /// <param name="addPleaseCheck">true to include depth paraphrase</param> /// <param name="eplStatementErrorMsg">text for error</param> /// <param name="rewriteScript">whether to rewrite script expressions</param> /// <returns>AST - syntax tree</returns> /// <throws>EPException when the AST could not be parsed</throws> /// <throws>StatementSpecCompileSyntaxException syntax exceptions</throws> public static ParseResult Parse( string expression, string eplStatementErrorMsg, bool addPleaseCheck, ParseRuleSelector parseRuleSelector, bool rewriteScript) { if (Log.IsDebugEnabled) { Log.Debug(".parse Parsing expr=" + expression); } var input = new CaseInsensitiveInputStream(expression); var lex = NewLexer(input); var tokens = new CommonTokenStream(lex); var parser = ParseHelper.NewParser(tokens); ITree tree; try { tree = parseRuleSelector.InvokeParseRule(parser); } catch (RecognitionException ex) { tokens.Fill(); if (rewriteScript) { if (IsContainsScriptOrClassExpression(tokens)) { return HandleScriptAndClassRewrite(tokens, eplStatementErrorMsg, addPleaseCheck, parseRuleSelector); } } Log.Debug("Error parsing statement [" + expression + "]", ex); throw ExceptionConvertor.ConvertStatement(ex, eplStatementErrorMsg, addPleaseCheck, parser); } catch (Exception e) { try { tokens.Fill(); } catch (Exception) { Log.Debug("Token-fill produced exception: " + e.Message, e); } if (Log.IsDebugEnabled) { Log.Debug("Error parsing statement [" + eplStatementErrorMsg + "]", e); } if (e.InnerException is RecognitionException recognitionException) { if (rewriteScript) { if (IsContainsScriptOrClassExpression(tokens)) { return HandleScriptAndClassRewrite(tokens, eplStatementErrorMsg, addPleaseCheck, parseRuleSelector); } } throw ExceptionConvertor.ConvertStatement(recognitionException, eplStatementErrorMsg, addPleaseCheck, parser); } throw; } // if we are re-writing scripts and contain a script, then rewrite if (rewriteScript && IsContainsScriptOrClassExpression(tokens)) { return HandleScriptAndClassRewrite(tokens, eplStatementErrorMsg, addPleaseCheck, parseRuleSelector); } if (Log.IsDebugEnabled) { Log.Debug(".parse Dumping AST..."); ASTUtil.DumpAST(tree); } var expressionWithoutAnnotation = expression; if (tree is EsperEPL2GrammarParser.StartEPLExpressionRuleContext) { var epl = (EsperEPL2GrammarParser.StartEPLExpressionRuleContext) tree; expressionWithoutAnnotation = GetNoAnnotation(expression, epl.annotationEnum(), tokens); } return new ParseResult( tree, expressionWithoutAnnotation, tokens, EmptyList<string>.Instance, EmptyList<string>.Instance); }