ParseHelper.java

/**************************************************************************************
 * 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) {
                Token tokenBefore = getTokenBefore(i, tokens);
                boolean isCreateExpressionClause = tokenBefore != null && tokenBefore.getType() == EsperEPL2Ast.CREATE;
                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(), !isCreateExpressionClause);
                    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 Token getTokenBefore(int i, TokenRewriteStream tokens) {
        int position = i-1;
        while (position >= 0) {
            Token t = tokens.get(position);
            if (t.getChannel() != 99) {
                return t;
            }
            position--;
        }
        return null;
    }

    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, boolean requireAfterScriptToken) {
        int found = -1;
        for (int i = startIndex; i < tokens.size(); i++) {
            if (tokens.get(i).getType() == tokenTypeSearch) {
                if (!requireAfterScriptToken) {
                    return i;
                }
                // 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);
}