Example usage for org.antlr.v4.runtime CharStreams fromStream

Introduction

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

Prototype

public static CharStream fromStream(InputStream is, Charset charset) throws IOException 

Source Link

Document

Creates a CharStream given an opened InputStream and the charset of the bytes contained in the stream.

Usage

From source file:com.intuit.karate.core.FeatureParser.java

License:Open Source License

private FeatureParser(Feature feature, InputStream is) {
    this.feature = feature;
    CharStream stream;/*from ww w . ja va  2s  .  co  m*/
    try {
        stream = CharStreams.fromStream(is, StandardCharsets.UTF_8);
    } catch (IOException e) {
        throw new RuntimeException(e);
    }
    KarateLexer lexer = new KarateLexer(stream);
    CommonTokenStream tokens = new CommonTokenStream(lexer);
    KarateParser parser = new KarateParser(tokens);
    parser.addErrorListener(errorListener);
    RuleContext tree = parser.feature();
    if (logger.isTraceEnabled()) {
        logger.debug(tree.toStringTree(parser));
    }
    ParseTreeWalker walker = new ParseTreeWalker();
    walker.walk(this, tree);
    if (errorListener.isFail()) {
        String errorMessage = errorListener.getMessage();
        logger.error("not a valid feature file: {} - {}", feature.getResource().getRelativePath(),
                errorMessage);
        throw new RuntimeException(errorMessage);
    }
}

---

From source file:io.mxnet.caffetranslator.Converter.java

License:Apache License

public boolean parseTrainingPrototxt() {

    CharStream cs = null;/*  w ww. ja  v a 2  s  .  c o m*/
    try {
        FileInputStream fis = new FileInputStream(new File(trainPrototxt));
        cs = CharStreams.fromStream(fis, StandardCharsets.UTF_8);
    } catch (IOException e) {
        System.err.println("Unable to read prototxt: " + trainPrototxt);
        return false;
    }

    CaffePrototxtLexer lexer = new CaffePrototxtLexer(cs);

    CommonTokenStream tokens = new CommonTokenStream(lexer);
    CaffePrototxtParser parser = new CaffePrototxtParser(tokens);

    CreateModelListener modelCreator = new CreateModelListener(parser, mlModel);
    parser.addParseListener(modelCreator);
    parser.prototxt();

    return true;
}

---

From source file:io.mxnet.caffetranslator.misc.CollectStats.java

License:Apache License

public static void main(String arsg[]) {
    String filePath = "path";

    CharStream cs = null;/*from   w  ww  .  jav  a  2  s  .c  o m*/
    try {
        FileInputStream fis = new FileInputStream(new File(filePath));
        cs = CharStreams.fromStream(fis, StandardCharsets.UTF_8);
    } catch (Exception e) {
        e.printStackTrace();
    }

    CaffePrototxtLexer lexer = new CaffePrototxtLexer(cs);
    CommonTokenStream tokens = new CommonTokenStream(lexer);
    CaffePrototxtParser parser = new CaffePrototxtParser(tokens);

    StatsListener statsListener = new StatsListener();
    parser.addParseListener(statsListener);
    parser.prototxt();

    Map<String, Set<String>> attrMap = statsListener.getAttrMap();

    Iterator it = attrMap.entrySet().iterator();
    while (it.hasNext()) {
        Map.Entry<String, Set<String>> pair = (Map.Entry) it.next();
        System.out.println(pair.getKey() + ":");
        for (String value : pair.getValue()) {
            System.out.println("    " + value);
        }
    }
}

---

From source file:io.mxnet.caffetranslator.Solver.java

License:Apache License

public boolean parsePrototxt() {
    CharStream cs = null;/*from  w w w.j  av  a 2s. co m*/
    try {
        FileInputStream fis = new FileInputStream(new File(solverPath));
        cs = CharStreams.fromStream(fis, StandardCharsets.UTF_8);
    } catch (IOException e) {
        System.err.println("Unable to read prototxt " + solverPath);
        return false;
    }

    CaffePrototxtLexer lexer = new CaffePrototxtLexer(cs);
    CommonTokenStream tokens = new CommonTokenStream(lexer);
    CaffePrototxtParser parser = new CaffePrototxtParser(tokens);

    SolverListener solverListener = new SolverListener();
    parser.addParseListener(solverListener);
    parser.solver();

    properties = solverListener.getProperties();

    setFields(properties);

    parseDone = true;
    return true;
}

---

From source file:io.proleap.vb6.asg.runner.impl.VbParserRunnerImpl.java

License:Open Source License

protected void parseFile(final File inputFile, final Charset charset, final Program program)
        throws IOException {
    if (!inputFile.isFile()) {
        LOG.warn("Could not find file {}", inputFile.getAbsolutePath());
    } else {/*from w ww . ja  va  2 s. com*/
        final String input = FileUtils.readFileToString(inputFile, charset);

        LOG.info("Parsing file {}.", inputFile.getName());

        final InputStream inputStream = new FileInputStream(inputFile);

        final VisualBasic6Lexer lexer = new VisualBasic6Lexer(CharStreams.fromStream(inputStream, charset));

        // get a list of matched tokens
        final CommonTokenStream tokens = new CommonTokenStream(lexer);

        // pass the tokens to the parser
        final VisualBasic6Parser parser = new VisualBasic6Parser(tokens);

        // specify our entry point
        final StartRuleContext ctx = parser.startRule();

        // determine the module name
        final String declaredModuleName = analyzeDeclaredModuleName(ctx);
        final String moduleName;

        if (declaredModuleName != null && !declaredModuleName.isEmpty()) {
            moduleName = declaredModuleName;
        } else {
            moduleName = getModuleName(inputFile);
        }

        // analyze contained modules and types
        final boolean isClazzModule = isClazzModule(inputFile);
        final boolean isStandardModule = isStandardModule(inputFile);

        final List<String> lines = splitLines(input);
        final ParserVisitor visitor = new VbModuleVisitorImpl(moduleName, lines, isClazzModule,
                isStandardModule, tokens, program);

        LOG.info("Collecting types in file {}.", inputFile.getName());
        visitor.visit(ctx);
    }
}

---

From source file:org.cirdles.squid.gui.expressions.ExpressionBuilderController.java

License:Apache License

private void makeTextFlowFromString(String string) {

    List<Node> children = new ArrayList<>();

    //The lexer separates the expression into tokens
    // updated to fix deprecations July 2018
    try {/*from w  w w .  j  a va2 s.c o  m*/
        InputStream stream = new ByteArrayInputStream(string.getBytes(StandardCharsets.UTF_8));
        ExpressionsForSquid2Lexer lexer = new ExpressionsForSquid2Lexer(
                CharStreams.fromStream(stream, StandardCharsets.UTF_8));
        List<? extends Token> tokens = lexer.getAllTokens();

        //Creates the notes from tokens
        for (int i = 0; i < tokens.size(); i++) {
            Token token = tokens.get(i);
            String nodeText = token.getText();

            ExpressionTextNode etn;

            // Make a node of the corresponding type
            if (ShuntingYard.isNumber(nodeText) || NUMBERSTRING.equals(nodeText)) {
                etn = new NumberTextNode(' ' + nodeText + ' ');
            } else if (listOperators.contains(nodeText)) {
                etn = new OperationTextNode(' ' + nodeText + ' ');
            } else if (nodeText.equals("\n") || nodeText.equals("\r")) {
                if (whiteSpaceVisible.get()) {
                    etn = new PresentationTextNode(VISIBLENEWLINEPLACEHOLDER);
                } else {
                    etn = new PresentationTextNode(INVISIBLENEWLINEPLACEHOLDER);
                }
            } else if (nodeText.equals("\t")) {
                if (whiteSpaceVisible.get()) {
                    etn = new PresentationTextNode(VISIBLETABPLACEHOLDER);
                } else {
                    etn = new PresentationTextNode(INVISIBLETABPLACEHOLDER);
                }
            } else if (nodeText.equals(" ")) {
                if (whiteSpaceVisible.get()) {
                    etn = new PresentationTextNode(VISIBLEWHITESPACEPLACEHOLDER);
                } else {
                    etn = new PresentationTextNode(INVISIBLEWHITESPACEPLACEHOLDER);
                }
            } else {
                etn = new ExpressionTextNode(' ' + nodeText + ' ');
            }

            etn.setOrdinalIndex(i);
            children.add(etn);
        }
    } catch (IOException iOException) {
    }
    expressionTextFlow.getChildren().setAll(children);
}

---

From source file:org.cirdles.squid.tasks.expressions.parsing.ExpressionParser.java

License:Apache License

/**
 *
 * @param expression/*from  w ww  . ja v  a 2  s . co  m*/
 * @param expressionString
 * @return
 */
public ExpressionTreeInterface parseExpressionStringAndBuildExpressionTree(Expression expression) {
    eqnSwitchNU = expression.isSquidSwitchNU();

    ExpressionTreeInterface returnExpressionTree = new ExpressionTree(expression.getName());

    // Get our lexer
    // updated due to deprecations Jul 2018
    ExpressionsForSquid2Lexer lexer;
    try {
        InputStream stream = new ByteArrayInputStream(
                expression.getExcelExpressionString().getBytes(StandardCharsets.UTF_8));
        lexer = new ExpressionsForSquid2Lexer(CharStreams.fromStream(stream, StandardCharsets.UTF_8));

        // Get a list of matched tokens
        CommonTokenStream tokens = new CommonTokenStream(lexer);

        // Pass the tokens to the parser
        ExpressionsForSquid2Parser parser = new ExpressionsForSquid2Parser(tokens);

        // https://stackoverflow.com/questions/18132078/handling-errors-in-antlr4
        lexer.removeErrorListeners();
        DescriptiveErrorListener descriptiveErrorListenerLexer = new DescriptiveErrorListener(true);
        lexer.addErrorListener(descriptiveErrorListenerLexer);

        parser.removeErrorListeners();
        DescriptiveErrorListener descriptiveErrorListenerParser = new DescriptiveErrorListener(true);
        parser.addErrorListener(descriptiveErrorListenerParser);

        // Specify our entry point
        ExpressionsForSquid2Parser.ExprContext expSentenceContext = parser.expr();

        // we don't want to build expressiontree if any bad parsing present
        if (descriptiveErrorListenerLexer.getSyntaxErrors().length()
                + descriptiveErrorListenerParser.getSyntaxErrors().length() > 0) {
            expression.setParsingStatusReport(descriptiveErrorListenerLexer.getSyntaxErrors()
                    + (String) (descriptiveErrorListenerLexer.getSyntaxErrors().length() > 0
                            ? descriptiveErrorListenerLexer.getSyntaxErrors() + "\n"
                            : "")
                    + descriptiveErrorListenerParser.getSyntaxErrors());
        } else {
            parser.setBuildParseTree(true);
            List<ParseTree> children = expSentenceContext.children;

            List<String> parsed = new ArrayList<>();
            List<String> parsedRPN = new ArrayList<>();

            if (children != null) {
                for (int i = 0; i < children.size(); i++) {
                    printTree(parser, children.get(i), parsed);
                }
                parsedRPN = ShuntingYard.infixToPostfix(parsed);
            }

            Collections.reverse(parsedRPN);

            // detect if top-level singleton and if so, wrap in expression with hidden Value operation, '$$'
            if (parsedRPN.size() == 1) {
                parsedRPN.add(0, "$$");
            }

            returnExpressionTree = buildTree(parsedRPN);

            // if single objects are the actual expression, don't change
            if (!(returnExpressionTree instanceof SpotFieldNode)
                    && !(returnExpressionTree instanceof ShrimpSpeciesNode)
                    && !(returnExpressionTree instanceof VariableNodeForIsotopicRatios)
                    && !(returnExpressionTree instanceof VariableNodeForSummary)
                    && returnExpressionTree.isValid()) {

                returnExpressionTree.setName(expression.getName());

            }

            // be sure top level expression is root
            returnExpressionTree.setRootExpressionTree(
                    !(((ExpressionTree) returnExpressionTree).getLeftET() instanceof ShrimpSpeciesNode));

        }
    } catch (IOException iOException) {
    }
    return returnExpressionTree;

}

---

From source file:org.kie.dmn.feel.parser.feel11.FEELTestRig.java

License:Apache License

@Override
public void process() throws Exception {
    Charset charset = (encoding == null ? Charset.defaultCharset() : Charset.forName(encoding));
    if (inputFiles.size() == 0) {
        CharStream charStream = CharStreams.fromStream(System.in, charset);
        process(lexer, parserClass, parser, charStream);
        return;//from  ww w  . ja va 2 s.co  m
    }
    for (String inputFile : inputFiles) {
        CharStream charStream = CharStreams.fromPath(Paths.get(inputFile), charset);
        if (inputFiles.size() > 1) {
            System.err.println(inputFile);
        }
        process(lexer, parserClass, parser, charStream);
    }
}

---