Example usage for org.antlr.v4.runtime CommonTokenStream 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:dk.dma.ais.packet.ExpressionFilterParserBase.java

License:Apache License

static ExpressionFilterParser.FilterContext createFilterContext(String filter) {
    ANTLRInputStream input = new ANTLRInputStream(requireNonNull(filter));
    ExpressionFilterLexer lexer = new ExpressionFilterLexer(input);
    CommonTokenStream tokens = new CommonTokenStream(lexer);
    ExpressionFilterParser parser = new ExpressionFilterParser(tokens);

    // Better errors
    lexer.removeErrorListeners();//from  w  w w  . ja va  2s.  co  m
    parser.removeErrorListeners();
    lexer.addErrorListener(new VerboseListener());
    parser.addErrorListener(new VerboseListener());

    return parser.filter();
}

From source file:domain.LanguageTools.java

public LanguageTools(String input) {
    ANTLRInputStream ais = new ANTLRInputStream(input);
    lexer = new PortugolLexer(ais);
    CommonTokenStream stream = new CommonTokenStream(lexer);
    parser = new PortugolParser(stream);
}

From source file:dsl.utility.DSLFactory.java

License:Open Source License

/**
 * @param inputText//  www .  jav  a  2s  . c  o m
 * @return
 */
static public DSLParser makeParser(ANTLRInputStream inputText) {
    final DSLLexer lexer = makeLexer(inputText);
    final CommonTokenStream tokenStream = new CommonTokenStream(lexer);
    final DSLParser parser = new DSLParser(tokenStream);
    parser.addErrorListener(new BaseErrorListener() {
        @Override
        public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line,
                int charPositionInLine, String msg, RecognitionException e) {
            throw new DSLParserException(e.getMessage(), e);
        }
    });
    return parser;
}

From source file:eagle.query.parser.EagleQueryParser.java

License:Apache License

public ORExpression parse() throws EagleQueryParseException {
    try {//from  w w  w .j av a2s.  com
        EagleFilterLexer lexer = new EagleFilterLexer(new ANTLRInputStream(_query));
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        tokens.fill();
        EagleFilterParser p = new EagleFilterParser(tokens);
        p.setErrorHandler(new EagleANTLRErrorStrategy());
        p.setBuildParseTree(true);
        EagleQueryFilterListenerImpl listener = new EagleQueryFilterListenerImpl();
        p.addParseListener(listener);
        EagleFilterParser.FilterContext fc = p.filter();
        if (fc.exception != null) {
            LOG.error("Can not successfully parse the query:" + _query, fc.exception);
            throw fc.exception;
        }
        return listener.result();
    } catch (Exception ex) {
        LOG.error("Can not successfully parse the query:", ex);
        throw new EagleQueryParseException("can not successfully parse the query:" + _query);
    }
}

From source file:ebnfdoc.Ebnf.java

License:Open Source License

public static EbnfParser.EbnfContext parse(File ebnfDoc) throws IOException {
    final FileInputStream fis = new FileInputStream(ebnfDoc);
    final ANTLRInputStream in = new ANTLRInputStream(fis);

    final EbnfLexer lex = new EbnfLexer(in);
    final CommonTokenStream ts = new CommonTokenStream(lex);

    final EbnfParser ast = new EbnfParser(ts);

    return ast.ebnf();
}

From source file:ebnfdoc.EbnfDocComment.java

License:Open Source License

public static EbnfDocParser.DocContext parse(InputStream docCommentStream) throws IOException {
    final ANTLRInputStream in = new ANTLRInputStream(docCommentStream);
    final EbnfDocLexer lex = new EbnfDocLexer(in);
    final CommonTokenStream ts = new CommonTokenStream(lex);
    final EbnfDocParser ast = new EbnfDocParser(ts);
    return ast.doc();
}

From source file:edu.byu.ece.rapidSmith.interfaces.ise.XDLReader.java

License:Open Source License

public XdlDesign readDesign(Path xdlFile) throws IOException {
    XDLLexer lexer = new XDLLexer(new ANTLRFileStream(xdlFile.toString()));
    XDLParser parser = new XDLParser(new CommonTokenStream(lexer));
    XDLParser.DesignContext design = parser.design();
    ParseTreeWalker walker = new ParseTreeWalker();
    DesignListener listener = new DesignListener();
    walker.walk(listener, design);/*from w  w  w .  ja  v  a  2s.co  m*/
    return listener.design;
}

From source file:edu.byu.ece.rapidSmith.util.luts.LutConfig.java

License:Open Source License

/**
 * Parses an XDL LUT attribute string into a LutConfig.
 *
 * @param attr the attribute to parse//from  ww w .java 2s .co  m
 * @param numInputs the number of inputs to the LUT
 * @return the parsed LutConfig
 */
public static LutConfig parseXdlLutAttribute(String attr, int numInputs) {
    // prep the parser
    ANTLRInputStream input = new ANTLRInputStream(attr);
    LutEquationLexer lexer = new LutEquationLexer(input);
    CommonTokenStream tokens = new CommonTokenStream(lexer);
    LutEquationParser parser = new LutEquationParser(tokens);
    // Replace the default error listener with my fail hard listener
    parser.removeErrorListeners();
    parser.addErrorListener(new LutParseErrorListener());

    // do the actual parsing
    ParseTree tree = parser.config_string();

    // traverse the tree
    LutParserListener listener = new LutParserListener(numInputs);
    ParseTreeWalker walker = new ParseTreeWalker();
    walker.walk(listener, tree);
    return listener.makeLutConfig();
}

From source file:edu.byu.ece.rapidSmith.util.luts.LutEquation.java

License:Open Source License

/**
 * Parses an XDL LUT equation into a LutEquation tree.
 *
 * @param string string representation of an equation to parse
 * @return the equivalent LutEquation object
 * @throws LutParseException if equation is improperly formatted
 *///  w  ww.  ja v  a2  s  . c  o m
public static LutEquation parse(String string) {
    ANTLRInputStream input = new ANTLRInputStream(string);
    LutEquationLexer lexer = new LutEquationLexer(input);
    CommonTokenStream tokens = new CommonTokenStream(lexer);
    LutEquationParser parser = new LutEquationParser(tokens);
    // Replace the default error listener with my fail hard listener
    parser.removeErrorListeners();
    parser.addErrorListener(new LutParseErrorListener());
    LutEquationParser.Equation_onlyContext tree = parser.equation_only();
    return new EqnParserVisitor().visitEquation_only(tree);
}

From source file:edu.clemson.cs.r2jt.absynnew.ResolveParserFactory.java

License:Open Source License

/**
 * <p>Returns an {@link ResolveParser} that feeds off of the
 * {@link ANTLRInputStream} passed.</p>
 *
 * @throws IllegalArgumentException If <code>input</code> is
 *                                              <code>null</code>
 * @param input An valid input stream; file or otherwise.
 * @return A {@link ResolveParser}.// ww  w . ja va  2s.  c o m
 */
public ResolveParser createParser(ANTLRInputStream input) {
    if (input == null) {
        throw new IllegalArgumentException("ANTLRInputStream null");
    }
    ResolveLexer lexer = new ResolveLexer(input);
    ResolveTokenFactory factory = new ResolveTokenFactory(input);
    lexer.setTokenFactory(factory);

    CommonTokenStream tokens = new CommonTokenStream(lexer);
    ResolveParser result = new ResolveParser(tokens);
    result.setTokenFactory(factory);

    result.removeErrorListeners();
    result.addErrorListener(UnderliningErrorListener.INSTANCE);
    return result;
}