/**************************************************************************************
* Copyright (C) 2008 EsperTech, Inc. All rights reserved. *
* http://esper.codehaus.org *
* http://www.espertech.com *
* ---------------------------------------------------------------------------------- *
* The software in this package is published under the terms of the GPL license *
* a copy of which has been included with this distribution in the license.txt file. *
**************************************************************************************/
package com.espertech.esper.epl.parse;
import com.espertech.esper.antlr.ASTUtil;
import com.espertech.esper.antlr.NoCaseSensitiveStream;
import com.espertech.esper.client.EPException;
import com.espertech.esper.collection.Pair;
import com.espertech.esper.epl.generated.EsperEPL2Ast;
import com.espertech.esper.epl.generated.EsperEPL2GrammarLexer;
import com.espertech.esper.epl.generated.EsperEPL2GrammarParser;
import org.antlr.runtime.*;
import org.antlr.runtime.tree.Tree;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.io.IOException;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Set;
/**
* Helper class for parsing an expression and walking a parse tree.
*/
public class ParseHelper {
/**
* Newline.
*/
public final static String newline = System.getProperty("line.separator");
/**
* Walk parse tree starting at the rule the walkRuleSelector supplies.
*
* @param ast - ast to walk
* @param walker - walker instance
* @param walkRuleSelector - walk rule
* @param expression - the expression we are walking in string form
* @param eplStatementForErrorMsg - statement text for error messages
*/
public static void walk(Tree ast, EPLTreeWalker walker, WalkRuleSelector walkRuleSelector, String expression, String eplStatementForErrorMsg) {
// Walk tree
try {
if (log.isDebugEnabled()) {
log.debug(".walk Walking AST using walker " + walker.getClass().getName());
}
walkRuleSelector.invokeWalkRule(walker);
if (log.isDebugEnabled()) {
log.debug(".walk AST tree after walking");
ASTUtil.dumpAST(ast);
}
} catch (RuntimeException e) {
log.info("Error walking statement [" + expression + "]", e);
if (e.getCause() instanceof RecognitionException) {
throw ExceptionConvertor.convert((RecognitionException) e.getCause(), eplStatementForErrorMsg, walker);
} else {
throw e;
}
} catch (RecognitionException e) {
log.info("Error walking statement [" + expression + "]", e);
throw ExceptionConvertor.convert(e, eplStatementForErrorMsg, walker);
}
}
/**
* Parse expression using the rule the ParseRuleSelector instance supplies.
*
* @param expression - text to parse
* @param parseRuleSelector - parse rule to select
* @param addPleaseCheck - true to include depth paraphrase
* @param eplStatementErrorMsg - text for error
* @return AST - syntax tree
* @throws EPException when the AST could not be parsed
*/
public static ParseResult parse(String expression, String eplStatementErrorMsg, boolean addPleaseCheck, ParseRuleSelector parseRuleSelector, boolean rewriteScript) throws EPException {
if (log.isDebugEnabled()) {
log.debug(".parse Parsing expr=" + expression);
}
CharStream input;
try {
input = new NoCaseSensitiveStream(new StringReader(expression));
} catch (IOException ex) {
throw new EPException("IOException parsing expression '" + expression + '\'', ex);
}
EsperEPL2GrammarLexer lex = new EsperEPL2GrammarLexer(input);
TokenRewriteStream tokens = new TokenRewriteStream(lex);
EsperEPL2GrammarParser parser = new EsperEPL2GrammarParser(tokens);
Tree tree;
try {
tree = parseRuleSelector.invokeParseRule(parser);
} catch (RuntimeException e) {
if (log.isDebugEnabled()) {
log.debug("Error parsing statement [" + eplStatementErrorMsg + "]", e);
}
if (e.getCause() instanceof RecognitionException) {
throw ExceptionConvertor.convertStatement((RecognitionException) e.getCause(), eplStatementErrorMsg, addPleaseCheck, parser);
} else {
throw e;
}
} catch (RecognitionException ex) {
if (rewriteScript && isContainsScriptExpression(tokens)) {
ScriptResult rewriteExpression = rewriteTokensScript(tokens);
ParseResult result = parse(rewriteExpression.getRewrittenEPL(), eplStatementErrorMsg, addPleaseCheck, parseRuleSelector, false);
return new ParseResult(result.getTree(), result.getExpressionWithoutAnnotations(), result.getTokenStream(), rewriteExpression.getScripts());
}
log.debug("Error parsing statement [" + expression + "]", ex);
throw ExceptionConvertor.convertStatement(ex, eplStatementErrorMsg, addPleaseCheck, parser);
}
// if we are re-writing scripts and contain a script, then rewrite
if (rewriteScript && isContainsScriptExpression(tokens)) {
ScriptResult rewriteExpression = rewriteTokensScript(tokens);
ParseResult result = parse(rewriteExpression.getRewrittenEPL(), rewriteExpression.getRewrittenEPL(), addPleaseCheck, parseRuleSelector, false);
return new ParseResult(result.getTree(), result.getExpressionWithoutAnnotations(), result.getTokenStream(), rewriteExpression.getScripts());
}
if (log.isDebugEnabled()) {
log.debug(".parse Dumping AST...");
ASTUtil.dumpAST(tree);
}
return new ParseResult(tree, getNoAnnotation(expression, tree, tokens), tokens, Collections.<String>emptyList());
}
private static ScriptResult rewriteTokensScript(TokenRewriteStream tokens) {
List<String> scripts = new ArrayList<String>();
for (int i = 0; i < tokens.size(); i++) {
if (tokens.get(i).getType() == EsperEPL2Ast.EXPRESSIONDECL) {
Pair<String, Integer> nameAndNameStart = findScriptName(i + 1, tokens);
int startIndex = findStartTokenScript(nameAndNameStart.getSecond(), tokens, EsperEPL2Ast.LBRACK);
if (startIndex != -1) {
int endIndex = findEndTokenScript(startIndex + 1, tokens, EsperEPL2Ast.RBRACK, EsperEPL2GrammarParser.getAfterScriptTokens());
if (endIndex != -1) {
StringWriter writer = new StringWriter();
for (int j = startIndex + 1; j < endIndex; j++) {
writer.append(tokens.get(j).getText());
}
scripts.add(writer.toString());
rewriteScript(startIndex, endIndex, tokens);
}
}
}
}
String rewrittenEPL = tokens.toString();
return new ScriptResult(rewrittenEPL, scripts);
}
private static Pair<String, Integer> findScriptName(int start, TokenRewriteStream tokens) {
String lastIdent = null;
int lastIdentIndex = 0;
for (int i = start; i < tokens.size(); i++) {
if (tokens.get(i).getType() == EsperEPL2Ast.IDENT) {
lastIdent = tokens.get(i).getText();
lastIdentIndex = i;
}
if (tokens.get(i).getType() == EsperEPL2Ast.LPAREN) {
break;
}
// find beginning of script, ignore brackets
if (tokens.get(i).getType() == EsperEPL2Ast.LBRACK && tokens.get(i+1).getType() != EsperEPL2Ast.RBRACK) {
break;
}
}
if (lastIdent == null) {
throw new IllegalStateException("Failed to parse expression name");
}
return new Pair<String, Integer>(lastIdent, lastIdentIndex);
}
private static void rewriteScript(int startIndex, int endIndex, TokenRewriteStream tokens) {
if (startIndex >= endIndex - 1) {
return;
}
Token[] tokensCapture = new Token[endIndex - startIndex - 1];
int count = 0;
for (int i = startIndex + 1; i < endIndex; i++) {
tokensCapture[count] = tokens.get(i);
count++;
}
tokens.delete(startIndex + 1, endIndex - 1);
int start = endIndex -1;
tokens.insertAfter(start, "'");
for (int i = 0; i < tokensCapture.length; i++) {
if (tokensCapture[i].getType() == EsperEPL2Ast.QUOTED_STRING_LITERAL) {
tokens.insertAfter(start, "\\'");
tokens.insertAfter(start, tokensCapture[i].getText().substring(1, tokensCapture[i].getText().length() - 1));
tokens.insertAfter(start, "\\'");
}
else {
tokens.insertAfter(start, tokensCapture[i].getText());
}
}
tokens.insertAfter(start, "'");
}
private static int findStartTokenScript(int startIndex, TokenRewriteStream tokens, int tokenTypeSearch) {
int found = -1;
for (int i = startIndex; i < tokens.size(); i++) {
if (tokens.get(i).getType() == tokenTypeSearch) {
return i;
}
}
return found;
}
private static int findEndTokenScript(int startIndex, TokenRewriteStream tokens, int tokenTypeSearch, Set<Integer> afterScriptTokens) {
int found = -1;
for (int i = startIndex; i < tokens.size(); i++) {
if (tokens.get(i).getType() == tokenTypeSearch) {
// The next non-comment token must be among the afterScriptTokens, i.e. SELECT/INSERT/ON/DELETE/UPDATE
// Find next non-comment token.
for (int j = i + 1; j < tokens.size(); j++) {
Token next = tokens.get(j);
if (next.getChannel() == 0) {
if (afterScriptTokens.contains(next.getType())) {
found = i;
}
break;
}
}
}
if (found != -1) {
break;
}
}
return found;
}
private static boolean isContainsScriptExpression(TokenRewriteStream tokens) {
for (int i = 0; i < tokens.size(); i++) {
if (tokens.get(i).getType() == EsperEPL2Ast.EXPRESSIONDECL) {
int startIndex = findStartTokenScript(i + 1, tokens, EsperEPL2Ast.LBRACK);
if (startIndex != -1) {
return true;
}
}
}
return false;
}
private static String getNoAnnotation(String expression, Tree tree, CommonTokenStream tokens) {
Token lastAnnotationToken = null;
for (int i = 0; i < tree.getChildCount(); i++) {
if (tree.getChild(i).getType() == EsperEPL2Ast.ANNOTATION) {
lastAnnotationToken = tokens.get(tree.getChild(i).getTokenStopIndex());
} else {
break;
}
}
if (lastAnnotationToken == null) {
return null;
}
try {
int line = lastAnnotationToken.getLine();
int charpos = lastAnnotationToken.getCharPositionInLine();
int fromChar = charpos + lastAnnotationToken.getText().length();
if (line == 1) {
return expression.substring(fromChar).trim();
}
String[] lines = expression.split("\r\n|\r|\n");
StringBuilder buf = new StringBuilder();
buf.append(lines[line - 1].substring(fromChar));
for (int i = line; i < lines.length; i++) {
buf.append(lines[i]);
if (i < lines.length - 1) {
buf.append(newline);
}
}
return buf.toString().trim();
} catch (RuntimeException ex) {
log.error("Error determining non-annotated expression sting: " + ex.getMessage(), ex);
}
return null;
}
private static class ScriptResult {
private final String rewrittenEPL;
private final List<String> scripts;
private ScriptResult(String rewrittenEPL, List<String> scripts) {
this.rewrittenEPL = rewrittenEPL;
this.scripts = scripts;
}
public String getRewrittenEPL() {
return rewrittenEPL;
}
public List<String> getScripts() {
return scripts;
}
}
private static Log log = LogFactory.getLog(ParseHelper.class);
}