Example usage for org.antlr.v4.runtime CommonTokenStream CommonTokenStream

List of usage examples for org.antlr.v4.runtime CommonTokenStream CommonTokenStream

  1. HOME
  2. Java
  3. org.antlr
  4. org.antlr.v4.runtime.*
  5. CommonTokenStream
  6. CommonTokenStream

Introduction

In this page you can find the example usage for org.antlr.v4.runtime CommonTokenStream CommonTokenStream.

Prototype

public CommonTokenStream(TokenSource tokenSource)

Source Link

Document

Constructs a new CommonTokenStream using the specified token source and the default token channel ( Token#DEFAULT_CHANNEL ).

Usage

From source file:com.eprosima.fastrtps.fastrtpsgen.java

License:Apache License

private Project parseIDL(String idlFilename) {
    boolean returnedValue = false;
    String idlParseFileName = idlFilename;
    Project project = null;//from  w w w  . java2  s  .  c  om

    String onlyFileName = Util.getIDLFileNameOnly(idlFilename);

    if (!m_ppDisable) {
        idlParseFileName = callPreprocessor(idlFilename);
    }

    if (idlParseFileName != null) {
        Context ctx = new Context(onlyFileName, idlFilename, m_includePaths, m_subscribercode, m_publishercode,
                m_localAppProduct);

        if (fusion_)
            ctx.setActivateFusion(true);

        // Create default @Key annotation.
        AnnotationDeclaration keyann = ctx.createAnnotationDeclaration("Key", null);
        keyann.addMember(new AnnotationMember("value", new PrimitiveTypeCode(TypeCode.KIND_BOOLEAN), "true"));

        // Create default @Topic annotation.
        AnnotationDeclaration topicann = ctx.createAnnotationDeclaration("Topic", null);
        topicann.addMember(new AnnotationMember("value", new PrimitiveTypeCode(TypeCode.KIND_BOOLEAN), "true"));

        // Create template manager
        TemplateManager tmanager = new TemplateManager("FastCdrCommon:eprosima:Common");

        List<TemplateExtension> extensions = new ArrayList<TemplateExtension>();

        // Load common types template
        extensions.add(new TemplateExtension("struct_type", "keyFunctionHeadersStruct"));
        extensions.add(new TemplateExtension("union_type", "keyFunctionHeadersUnion"));
        tmanager.addGroup("TypesHeader", extensions);
        extensions.clear();
        extensions.add(new TemplateExtension("struct_type", "keyFunctionSourcesStruct"));
        tmanager.addGroup("TypesSource", extensions);

        // TODO: Uncomment following lines and create templates

        // Load Types common templates
        tmanager.addGroup("RTPSPubSubTypeHeader");
        tmanager.addGroup("RTPSPubSubTypeSource");

        // Load Publisher templates
        tmanager.addGroup("RTPSPublisherHeader");
        tmanager.addGroup("RTPSPublisherSource");

        // Load Subscriber templates
        tmanager.addGroup("RTPSSubscriberHeader");
        tmanager.addGroup("RTPSSubscriberSource");

        // Load PubSubMain template
        tmanager.addGroup("RTPSPubSubMain");

        // Add JNI sources.
        if (m_languageOption == LANGUAGE.JAVA) {
            tmanager.addGroup("JNIHeader");
            tmanager.addGroup("JNISource");
            tmanager.addGroup("JavaSource");

            // Set package in context.
            ctx.setPackage(m_package);
        }

        // Create main template
        TemplateGroup maintemplates = tmanager.createTemplateGroup("main");
        maintemplates.setAttribute("ctx", ctx);

        try {
            ANTLRFileStream input = new ANTLRFileStream(idlParseFileName);
            IDLLexer lexer = new IDLLexer(input);
            lexer.setContext(ctx);
            CommonTokenStream tokens = new CommonTokenStream(lexer);
            IDLParser parser = new IDLParser(tokens);
            // Pass the finelame without the extension

            Specification specification = parser.specification(ctx, tmanager, maintemplates).spec;
            returnedValue = specification != null;

        } catch (FileNotFoundException ex) {
            System.out.println(ColorMessage.error("FileNotFounException") + "The File " + idlParseFileName
                    + " was not found.");
        } /* catch (ParseException ex) {
            System.out.println(ColorMessage.error("ParseException") + ex.getMessage());
          }*/ catch (Exception ex) {
            System.out.println(ColorMessage.error("Exception") + ex.getMessage());
        }

        if (returnedValue) {
            // Create information of project for solution
            project = new Project(onlyFileName, idlFilename, ctx.getDependencies());

            System.out.println("Generating Type definition files...");
            if (returnedValue = Utils.writeFile(m_outputDir + onlyFileName + ".h",
                    maintemplates.getTemplate("TypesHeader"), m_replace)) {
                if (returnedValue = Utils.writeFile(m_outputDir + onlyFileName + ".cxx",
                        maintemplates.getTemplate("TypesSource"), m_replace)) {
                    project.addCommonIncludeFile(onlyFileName + ".h");
                    project.addCommonSrcFile(onlyFileName + ".cxx");
                }
            }

            // TODO: Uncomment following lines and create templates
            if (ctx.existsLastStructure()) {
                m_atLeastOneStructure = true;
                project.setHasStruct(true);

                System.out.println("Generating TopicDataTypes files...");
                if (returnedValue = Utils.writeFile(m_outputDir + onlyFileName + "PubSubTypes.h",
                        maintemplates.getTemplate("RTPSPubSubTypeHeader"), m_replace)) {
                    if (returnedValue = Utils.writeFile(m_outputDir + onlyFileName + "PubSubTypes.cxx",
                            maintemplates.getTemplate("RTPSPubSubTypeSource"), m_replace)) {
                        project.addProjectIncludeFile(onlyFileName + "PubSubTypes.h");
                        project.addProjectSrcFile(onlyFileName + "PubSubTypes.cxx");
                    }
                }

                if (m_exampleOption != null) {
                    System.out.println("Generating Publisher files...");
                    if (returnedValue = Utils.writeFile(m_outputDir + onlyFileName + "Publisher.h",
                            maintemplates.getTemplate("RTPSPublisherHeader"), m_replace)) {
                        if (returnedValue = Utils.writeFile(m_outputDir + onlyFileName + "Publisher.cxx",
                                maintemplates.getTemplate("RTPSPublisherSource"), m_replace)) {
                            project.addProjectIncludeFile(onlyFileName + "Publisher.h");
                            project.addProjectSrcFile(onlyFileName + "Publisher.cxx");
                        }
                    }

                    System.out.println("Generating Subscriber files...");
                    if (returnedValue = Utils.writeFile(m_outputDir + onlyFileName + "Subscriber.h",
                            maintemplates.getTemplate("RTPSSubscriberHeader"), m_replace)) {
                        if (returnedValue = Utils.writeFile(m_outputDir + onlyFileName + "Subscriber.cxx",
                                maintemplates.getTemplate("RTPSSubscriberSource"), m_replace)) {
                            project.addProjectIncludeFile(onlyFileName + "Subscriber.h");
                            project.addProjectSrcFile(onlyFileName + "Subscriber.cxx");
                        }
                    }

                    System.out.println("Generating main file...");
                    if (returnedValue = Utils.writeFile(m_outputDir + onlyFileName + "PubSubMain.cxx",
                            maintemplates.getTemplate("RTPSPubSubMain"), m_replace)) {
                        project.addProjectSrcFile(onlyFileName + "PubSubMain.cxx");
                    }
                }
            }
        }

        // Java support (Java classes and JNI code)
        if (returnedValue && m_languageOption == LANGUAGE.JAVA) {
            String outputDir = m_outputDir;

            // Make directories from package.
            if (!m_package.isEmpty()) {
                outputDir = m_outputDir + File.separator + m_package.replace('.', File.separatorChar);
                File dirs = new File(outputDir);

                if (!dirs.exists()) {
                    if (!dirs.mkdirs()) {
                        System.out
                                .println(ColorMessage.error() + "Cannot create directories for Java packages.");
                        return null;
                    }
                }
            }

            // Java classes.
            TypesGenerator typeGen = new TypesGenerator(tmanager, m_outputDir, m_replace);
            TypeCode.javapackage = m_package + (m_package.isEmpty() ? "" : ".");
            if (!typeGen.generate(ctx, outputDir + File.separator, m_package, onlyFileName, null)) {
                System.out.println(ColorMessage.error() + "generating Java types");
                return null;
            }

            if (ctx.existsLastStructure()) {
                System.out.println("Generando fichero " + m_outputDir + onlyFileName + "PubSub.java");
                if (!Utils.writeFile(outputDir + File.separator + onlyFileName + "PubSub.java",
                        maintemplates.getTemplate("JavaSource"), m_replace))
                    return null;

                // Call javah application for each structure.
                if (!callJavah(idlFilename))
                    return null;
            }

            if (Utils.writeFile(m_outputDir + onlyFileName + "PubSubJNII.h",
                    maintemplates.getTemplate("JNIHeader"), m_replace))
                project.addJniIncludeFile(onlyFileName + "PubSubJNII.h");
            else
                return null;

            StringTemplate jnisourceTemplate = maintemplates.getTemplate("JNISource");
            if (Utils.writeFile(m_outputDir + onlyFileName + "PubSubJNI.cxx", jnisourceTemplate, m_replace))
                project.addJniSrcFile(onlyFileName + "PubSubJNI.cxx");
            else
                return null;
        }
    }

    return returnedValue ? project : null;
}

From source file:com.espertech.esper.core.deploy.EPLModuleUtil.java

License:Open Source License

public static ParseNode getModule(EPLModuleParseItem item, String resourceName)
        throws ParseException, IOException {
    CharStream input = new NoCaseSensitiveStream(new StringReader(item.getExpression()));

    EsperEPL2GrammarLexer lex = ParseHelper.newLexer(input);
    CommonTokenStream tokenStream = new CommonTokenStream(lex);
    tokenStream.fill();//from   ww  w  .  j  a v  a 2s . c  o m

    List tokens = tokenStream.getTokens();
    int beginIndex = 0;
    boolean isMeta = false;
    boolean isModule = false;
    boolean isUses = false;
    boolean isExpression = false;

    while (beginIndex < tokens.size()) {
        Token t = (Token) tokens.get(beginIndex);
        if (t.getType() == EsperEPL2GrammarParser.EOF) {
            break;
        }
        if ((t.getType() == EsperEPL2GrammarParser.WS) || (t.getType() == EsperEPL2GrammarParser.SL_COMMENT)
                || (t.getType() == EsperEPL2GrammarParser.ML_COMMENT)) {
            beginIndex++;
            continue;
        }
        String tokenText = t.getText().trim().toLowerCase();
        if (tokenText.equals("module")) {
            isModule = true;
            isMeta = true;
        } else if (tokenText.equals("uses")) {
            isUses = true;
            isMeta = true;
        } else if (tokenText.equals("import")) {
            isMeta = true;
        } else {
            isExpression = true;
            break;
        }
        beginIndex++;
        beginIndex++; // skip space
        break;
    }

    if (isExpression) {
        return new ParseNodeExpression(item);
    }
    if (!isMeta) {
        return new ParseNodeComment(item);
    }

    // check meta tag (module, uses, import)
    StringWriter buffer = new StringWriter();
    for (int i = beginIndex; i < tokens.size(); i++) {
        Token t = (Token) tokens.get(i);
        if (t.getType() == EsperEPL2GrammarParser.EOF) {
            break;
        }
        if ((t.getType() != EsperEPL2GrammarParser.IDENT) && (t.getType() != EsperEPL2GrammarParser.DOT)
                && (t.getType() != EsperEPL2GrammarParser.STAR) && (!t.getText().matches("[a-zA-Z]*"))) {
            throw getMessage(isModule, isUses, resourceName, t.getType());
        }
        buffer.append(t.getText().trim());
    }

    String result = buffer.toString().trim();
    if (result.length() == 0) {
        throw getMessage(isModule, isUses, resourceName, -1);
    }

    if (isModule) {
        return new ParseNodeModule(item, result);
    } else if (isUses) {
        return new ParseNodeUses(item, result);
    }
    return new ParseNodeImport(item, result);
}

From source file:com.espertech.esper.core.deploy.EPLModuleUtil.java

License:Open Source License

public static List<EPLModuleParseItem> parse(String module) throws ParseException {

    CharStream input;//w  ww.j  a  va2 s.  co m
    try {
        input = new NoCaseSensitiveStream(new StringReader(module));
    } catch (IOException ex) {
        log.error("Exception reading module expression: " + ex.getMessage(), ex);
        return null;
    }

    EsperEPL2GrammarLexer lex = ParseHelper.newLexer(input);
    CommonTokenStream tokens = new CommonTokenStream(lex);
    try {
        tokens.fill();
    } catch (RuntimeException ex) {
        String message = "Unexpected exception recognizing module text";
        if (ex instanceof LexerNoViableAltException) {
            if (ParseHelper.hasControlCharacters(module)) {
                message = "Unrecognized control characters found in text, failed to parse text";
            } else {
                message += ", recognition failed for " + ex.toString();
            }
        } else if (ex instanceof RecognitionException) {
            RecognitionException recog = (RecognitionException) ex;
            message += ", recognition failed for " + recog.toString();
        } else if (ex.getMessage() != null) {
            message += ": " + ex.getMessage();
        }
        message += " [" + module + "]";
        log.error(message, ex);
        throw new ParseException(message);
    }

    List<EPLModuleParseItem> statements = new ArrayList<EPLModuleParseItem>();
    StringWriter current = new StringWriter();
    Integer lineNum = null;
    int charPosStart = 0;
    int charPos = 0;
    List<Token> tokenList = tokens.getTokens();
    Set<Integer> skippedSemicolonIndexes = getSkippedSemicolons(tokenList);
    int index = -1;
    for (Object token : tokenList) // Call getTokens first before invoking tokens.size! ANTLR problem
    {
        index++;
        Token t = (Token) token;
        boolean semi = t.getType() == EsperEPL2GrammarLexer.SEMI && !skippedSemicolonIndexes.contains(index);
        if (semi) {
            if (current.toString().trim().length() > 0) {
                statements.add(new EPLModuleParseItem(current.toString().trim(), lineNum == null ? 0 : lineNum,
                        charPosStart, charPos));
                lineNum = null;
            }
            current = new StringWriter();
        } else {
            if ((lineNum == null) && (t.getType() != EsperEPL2GrammarParser.WS)) {
                lineNum = t.getLine();
                charPosStart = charPos;
            }
            if (t.getType() != EsperEPL2GrammarLexer.EOF) {
                current.append(t.getText());
                charPos += t.getText().length();
            }
        }
    }

    if (current.toString().trim().length() > 0) {
        statements.add(new EPLModuleParseItem(current.toString().trim(), lineNum == null ? 0 : lineNum, 0, 0));
    }
    return statements;
}

From source file:com.espertech.esper.epl.db.DatabasePollingViewableFactory.java

License:Open Source License

/**
 * Lexes the sample SQL and inserts a "where 1=0" where-clause.
 * @param querySQL to inspect using lexer
 * @return sample SQL with where-clause inserted
 * @throws ExprValidationException to indicate a lexer problem
 *///from w  w w .  j a va2 s .c  om
protected static String lexSampleSQL(String querySQL) throws ExprValidationException {
    querySQL = querySQL.replaceAll("\\s\\s+|\\n|\\r", " ");
    StringReader reader = new StringReader(querySQL);
    CharStream input;
    try {
        input = new NoCaseSensitiveStream(reader);
    } catch (IOException ex) {
        throw new ExprValidationException("IOException lexing query SQL '" + querySQL + '\'', ex);
    }

    int whereIndex = -1;
    int groupbyIndex = -1;
    int havingIndex = -1;
    int orderByIndex = -1;
    List<Integer> unionIndexes = new ArrayList<Integer>();

    EsperEPL2GrammarLexer lex = ParseHelper.newLexer(input);
    CommonTokenStream tokens = new CommonTokenStream(lex);
    tokens.fill();
    List tokenList = tokens.getTokens();

    for (int i = 0; i < tokenList.size(); i++) {
        Token token = (Token) tokenList.get(i);
        if ((token == null) || token.getText() == null) {
            break;
        }
        String text = token.getText().toLowerCase().trim();
        if (text.equals("where")) {
            whereIndex = token.getCharPositionInLine() + 1;
        }
        if (text.equals("group")) {
            groupbyIndex = token.getCharPositionInLine() + 1;
        }
        if (text.equals("having")) {
            havingIndex = token.getCharPositionInLine() + 1;
        }
        if (text.equals("order")) {
            orderByIndex = token.getCharPositionInLine() + 1;
        }
        if (text.equals("union")) {
            unionIndexes.add(token.getCharPositionInLine() + 1);
        }
    }

    // If we have a union, break string into subselects and process each
    if (unionIndexes.size() != 0) {
        StringWriter changedSQL = new StringWriter();
        int lastIndex = 0;
        for (int i = 0; i < unionIndexes.size(); i++) {
            int index = unionIndexes.get(i);
            String fragment;
            if (i > 0) {
                fragment = querySQL.substring(lastIndex + 5, index - 1);
            } else {
                fragment = querySQL.substring(lastIndex, index - 1);
            }
            String lexedFragment = lexSampleSQL(fragment);

            if (i > 0) {
                changedSQL.append("union ");
            }
            changedSQL.append(lexedFragment);
            lastIndex = index - 1;
        }

        // last part after last union
        String fragment = querySQL.substring(lastIndex + 5, querySQL.length());
        String lexedFragment = lexSampleSQL(fragment);
        changedSQL.append("union ");
        changedSQL.append(lexedFragment);

        return changedSQL.toString();
    }

    // Found a where clause, simplest cases
    if (whereIndex != -1) {
        StringWriter changedSQL = new StringWriter();
        String prefix = querySQL.substring(0, whereIndex + 5);
        String suffix = querySQL.substring(whereIndex + 5, querySQL.length());
        changedSQL.write(prefix);
        changedSQL.write("1=0 and ");
        changedSQL.write(suffix);
        return changedSQL.toString();
    }

    // No where clause, find group-by
    int insertIndex;
    if (groupbyIndex != -1) {
        insertIndex = groupbyIndex;
    } else if (havingIndex != -1) {
        insertIndex = havingIndex;
    } else if (orderByIndex != -1) {
        insertIndex = orderByIndex;
    } else {
        StringWriter changedSQL = new StringWriter();
        changedSQL.write(querySQL);
        changedSQL.write(" where 1=0 ");
        return changedSQL.toString();
    }

    try {
        StringWriter changedSQL = new StringWriter();
        String prefix = querySQL.substring(0, insertIndex - 1);
        changedSQL.write(prefix);
        changedSQL.write("where 1=0 ");
        String suffix = querySQL.substring(insertIndex - 1, querySQL.length());
        changedSQL.write(suffix);
        return changedSQL.toString();
    } catch (Exception ex) {
        String text = "Error constructing sample SQL to retrieve metadata for JDBC-drivers that don't support metadata, consider using the "
                + SAMPLE_WHERECLAUSE_PLACEHOLDER + " placeholder or providing a sample SQL";
        log.error(text, ex);
        throw new ExprValidationException(text, ex);
    }
}

From source file:com.espertech.esper.epl.parse.ParseHelper.java

License:Open Source License

/**
 * 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/*w  w  w .j av a 2 s.co m*/
 * @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 = newLexer(input);

    CommonTokenStream tokens = new CommonTokenStream(lex);
    EsperEPL2GrammarParser parser = ParseHelper.newParser(tokens);

    Tree tree;
    try {
        tree = parseRuleSelector.invokeParseRule(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 (RuntimeException e) {
        try {
            tokens.fill();
        } catch (RuntimeException ex) {
            log.debug("Token-fill produced exception: " + e.getMessage(), e);
        }
        if (log.isDebugEnabled()) {
            log.debug("Error parsing statement [" + eplStatementErrorMsg + "]", e);
        }
        if (e.getCause() instanceof RecognitionException) {
            if (rewriteScript && isContainsScriptExpression(tokens)) {
                return handleScriptRewrite(tokens, eplStatementErrorMsg, addPleaseCheck, parseRuleSelector);
            }
            throw ExceptionConvertor.convertStatement((RecognitionException) e.getCause(), eplStatementErrorMsg,
                    addPleaseCheck, parser);
        } else {
            throw e;
        }
    }

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

    String expressionWithoutAnnotation = expression;
    if (tree instanceof EsperEPL2GrammarParser.StartEPLExpressionRuleContext) {
        EsperEPL2GrammarParser.StartEPLExpressionRuleContext epl = (EsperEPL2GrammarParser.StartEPLExpressionRuleContext) tree;
        expressionWithoutAnnotation = getNoAnnotation(expression, epl.annotationEnum(), tokens);
    } else if (tree instanceof EsperEPL2GrammarParser.StartPatternExpressionRuleContext) {
        EsperEPL2GrammarParser.StartPatternExpressionRuleContext pattern = (EsperEPL2GrammarParser.StartPatternExpressionRuleContext) tree;
        expressionWithoutAnnotation = getNoAnnotation(expression, pattern.annotationEnum(), tokens);
    }

    return new ParseResult(tree, expressionWithoutAnnotation, tokens, Collections.<String>emptyList());
}

From source file:com.espertech.esper.event.property.PropertyParser.java

License:Open Source License

/**
 * Parses a given property name returning an AST.
 * @param propertyName to parse//from w  ww.j  a v a 2 s . c om
 * @return AST syntax tree
 */
public static EsperEPL2GrammarParser.StartEventPropertyRuleContext parse(String propertyName) {
    CharStream input;
    try {
        input = new NoCaseSensitiveStream(new StringReader(propertyName));
    } catch (IOException ex) {
        throw new PropertyAccessException("IOException parsing property name '" + propertyName + '\'', ex);
    }

    EsperEPL2GrammarLexer lex = ParseHelper.newLexer(input);
    CommonTokenStream tokens = new CommonTokenStream(lex);
    try {
        tokens.fill();
    } catch (RuntimeException e) {
        if (ParseHelper.hasControlCharacters(propertyName)) {
            throw new PropertyAccessException("Unrecognized control characters found in text");
        }
        throw new PropertyAccessException("Failed to parse text: " + e.getMessage());
    }

    EsperEPL2GrammarParser g = ParseHelper.newParser(tokens);
    EsperEPL2GrammarParser.StartEventPropertyRuleContext r;

    try {
        r = g.startEventPropertyRule();
    } catch (RecognitionException e) {
        return handleRecognitionEx(e, tokens, propertyName, g);
    } catch (RuntimeException e) {
        if (log.isDebugEnabled()) {
            log.debug("Error parsing property expression [" + propertyName + "]", e);
        }
        if (e.getCause() instanceof RecognitionException) {
            return handleRecognitionEx((RecognitionException) e.getCause(), tokens, propertyName, g);
        } else {
            throw e;
        }
    }

    return r;
}

From source file:com.espertech.esper.event.property.PropertyParser.java

License:Open Source License

private static EsperEPL2GrammarParser.StartEventPropertyRuleContext handleRecognitionEx(RecognitionException e,
        CommonTokenStream tokens, String propertyName, EsperEPL2GrammarParser g) {
    // Check for keywords and escape each, parse again
    String escapedPropertyName = escapeKeywords(tokens);

    CharStream inputEscaped;//www.ja  va 2s .  c om
    try {
        inputEscaped = new NoCaseSensitiveStream(new StringReader(escapedPropertyName));
    } catch (IOException ex) {
        throw new PropertyAccessException("IOException parsing property name '" + propertyName + '\'', ex);
    }

    EsperEPL2GrammarLexer lexEscaped = ParseHelper.newLexer(inputEscaped);
    CommonTokenStream tokensEscaped = new CommonTokenStream(lexEscaped);
    EsperEPL2GrammarParser gEscaped = ParseHelper.newParser(tokensEscaped);

    try {
        return gEscaped.startEventPropertyRule();
    } catch (Exception eEscaped) {
    }

    throw ExceptionConvertor.convertProperty(e, propertyName, true, g);
}

From source file:com.espertech.esper.support.epl.parse.SupportParserHelper.java

License:Open Source License

public static Pair<Tree, CommonTokenStream> parse(ParseRuleSelector parseRuleSelector, String text)
        throws Exception {
    CharStream input;//  w  w  w  .  ja  va2  s  .c  o  m
    try {
        input = new NoCaseSensitiveStream(new StringReader(text));
    } catch (IOException ex) {
        throw new RuntimeException("IOException parsing text '" + text + '\'', ex);
    }

    EsperEPL2GrammarLexer lex = ParseHelper.newLexer(input);

    CommonTokenStream tokens = new CommonTokenStream(lex);
    EsperEPL2GrammarParser g = ParseHelper.newParser(tokens);

    Tree ctx = parseRuleSelector.invokeParseRule(g);
    return new Pair<Tree, CommonTokenStream>(ctx, tokens);
}

From source file:com.facebook.presto.type.TypeCalculation.java

License:Apache License

private static ParserRuleContext parseTypeCalculation(String calculation) {
    TypeCalculationLexer lexer = new TypeCalculationLexer(
            new CaseInsensitiveStream(new ANTLRInputStream(calculation)));
    CommonTokenStream tokenStream = new CommonTokenStream(lexer);
    TypeCalculationParser parser = new TypeCalculationParser(tokenStream);

    lexer.removeErrorListeners();/*from ww w .  j av a2  s.c  o m*/
    lexer.addErrorListener(ERROR_LISTENER);

    parser.removeErrorListeners();
    parser.addErrorListener(ERROR_LISTENER);

    ParserRuleContext tree;
    try {
        // first, try parsing with potentially faster SLL mode
        parser.getInterpreter().setPredictionMode(PredictionMode.SLL);
        tree = parser.typeCalculation();
    } catch (ParseCancellationException ex) {
        // if we fail, parse with LL mode
        tokenStream.reset(); // rewind input stream
        parser.reset();

        parser.getInterpreter().setPredictionMode(PredictionMode.LL);
        tree = parser.typeCalculation();
    }
    return tree;
}

From source file:com.fizzed.rocker.compiler.TemplateParser.java

License:Apache License

private TemplateModel parse(ANTLRInputStream input, String packageName, String templateName, long modifiedAt)
        throws ParserException {
    // construct path for more helpful error messages
    String templatePath = packageName.replace(".", File.separator) + "/" + templateName;

    // get our lexer
    log.trace("Lexer for input stream");
    RockerLexer lexer = new RockerLexer(input);
    lexer.removeErrorListeners();/*  w w  w.  ja  v a2  s  .  com*/
    lexer.addErrorListener(new DescriptiveErrorListener());

    //
    // lexer
    //
    CommonTokenStream tokens = null;
    try {
        // get a list of matched tokens
        log.trace("Tokenizing lexer");
        tokens = new CommonTokenStream(lexer);
    } catch (ParserRuntimeException e) {
        throw unwrapParserRuntimeException(templatePath, e);
    }

    if (log.isTraceEnabled()) {
        // just for debugging lexer
        tokens.fill();
        for (Token token : tokens.getTokens()) {
            log.trace("{}", token);
        }
    }

    //
    // parser & new model
    //
    try {
        // pass the tokens to the parser
        log.trace("Parsing tokens");
        RockerParser parser = new RockerParser(tokens);
        parser.removeErrorListeners();
        parser.addErrorListener(new DescriptiveErrorListener());

        TemplateModel model = new TemplateModel(packageName, templateName, modifiedAt,
                configuration.getOptions().copy());

        // walk it and attach our listener
        TemplateParserListener listener = new TemplateParserListener(input, model, templatePath);
        ParseTreeWalker walker = new ParseTreeWalker();
        log.trace("Walking parse tree");
        walker.walk(listener, parser.template());

        if (model.getOptions().getCombineAdjacentPlain()) {
            combineAdjacentPlain(model);
        }

        // discard whitespace either globally or template-set or also fallsback
        // to the default per content-type
        if (model.getOptions().getDiscardLogicWhitespaceForContentType(model.getContentType())) {
            discardLogicWhitespace(model);
        }

        return model;
    } catch (ParserRuntimeException e) {
        throw unwrapParserRuntimeException(templatePath, e);
    }
}