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