Example usage for org.antlr.v4.runtime.tree ParseTree toStringTree

List of usage examples for org.antlr.v4.runtime.tree ParseTree toStringTree

Introduction

In this page you can find the example usage for org.antlr.v4.runtime.tree ParseTree toStringTree.

Prototype

String toStringTree(Parser parser);

Source Link

Document

Specialize toStringTree so that it can print out more information based upon the parser.

Usage

From source file:SExpr.java

License:Open Source License

public void print_AST(MusicboxParser parser) {
    ParseTree tree = parser.start(); // begin parsing at init rule
    System.out.println(tree.toStringTree(parser));
}

From source file:Cymbol.java

/**
 * @param args the command line arguments
 *//* w  w  w  .ja  v a  2  s  .  co m*/
public static void main(String[] args) {

    if (args.length == 1) {
        try {
            // parsing
            // create file input stream
            FileInputStream source = new FileInputStream(args[0]);
            // create a CharStream that reads from standard input
            ANTLRInputStream input = new ANTLRInputStream(source);
            // create a lexer that feeds off of input CharStream
            CymbolLexer lexer = new CymbolLexer(input);
            // create a buffer of tokens pulled from the lexer
            CommonTokenStream tokens = new CommonTokenStream(lexer);
            // create a parser that feeds off the tokens buffer
            CymbolParser parser = new CymbolParser(tokens);
            ParseTree tree = parser.file(); // begin parsing at init rule

            // dump ast
            System.out.println(tree.toStringTree(parser)); // print LISP-style tree

            // build call graph
            ParseTreeWalker walker = new ParseTreeWalker();
            FunctionListener collector = new FunctionListener();
            walker.walk(collector, tree);
            System.out.println(collector.graph.toString());
            System.out.println(collector.graph.toDOT());

        } catch (IOException e) {
            System.out.print("error: " + e.getMessage());
        }
    } else {
        System.out.print("error: syntax is Cymbol <file path> !");
    }
}

From source file:Ecmascript.java

/**
 * @param args the command line arguments
 *//* ww  w .  j  a  v  a 2 s  . co  m*/
public static void main(String[] args) {
    if (args.length == 1) {
        try {
            // parsing
            // create file input stream
            FileInputStream source = new FileInputStream(args[0]);
            // create a CharStream that reads from standard input
            ANTLRInputStream input = new ANTLRInputStream(source);
            // create a lexer that feeds off of input CharStream
            ECMAScriptLexer lexer = new ECMAScriptLexer(input);
            // create a buffer of tokens pulled from the lexer
            CommonTokenStream tokens = new CommonTokenStream(lexer);
            // create a parser that feeds off the tokens buffer
            ECMAScriptParser parser = new ECMAScriptParser(tokens);
            ParseTree tree = parser.program(); // begin parsing at init rule

            // dump ast
            System.out.println("AST is : " + tree.toStringTree(parser)); // print LISP-style tree

            // build call graph
            ParseTreeWalker walker = new ParseTreeWalker();
            FunctionListener collector = new FunctionListener();
            walker.walk(collector, tree);
            System.out.println(collector.graph.toString());
            System.out.println(collector.graph.toDOT());

        } catch (IOException e) {
            System.out.print("error: " + e.getMessage());
        }
    } else {
        System.out.print("error: syntax is Cymbol <file path> !");
    }
}

From source file:cdql.cqe.ContextQueryExecutor.java

@Override
public Graph execute(String query) throws CDQLSyntaxtErrorException {
    StringBuilder res = new StringBuilder();
    ANTLRInputStream input = new ANTLRInputStream(query); // create a lexer that feeds off of input CharStream
    CDQLLexer lexer = new CDQLLexer(input); // create a buffer of tokens pulled from the lexer
    CommonTokenStream tokens = new CommonTokenStream(lexer); // create a parser that feeds off the tokens buffer
    CDQLParser parser = new CDQLParser(tokens);
    ParseTree tree = parser.cdql(); // begin parsing at init rule        
    if (parser.getNumberOfSyntaxErrors() != 0) {
        throw new CDQLSyntaxtErrorException("syntaxt error");
    }/*from w w w  . j a  v  a 2 s.co m*/
    CDQLVisitor stringCDQLBaseVisitor = new CDQLVisitor();
    // Walk the tree created during the parse, trigger callbacks
    res.append(tree.toStringTree(parser));
    stringCDQLBaseVisitor.visit(tree);
    String error = "";
    for (String s : stringCDQLBaseVisitor.getUsedContextEntities()) {
        if (!stringCDQLBaseVisitor.getDefinedEntities().containsKey(s)) {
            error += ("\n" + s + " not defined");
        }
    }
    if (!error.isEmpty()) {
        throw new CDQLSyntaxtErrorException(error);
    }
    error = "";
    for (String s : stringCDQLBaseVisitor.getCalledFunctions()) {
        if (!stringCDQLBaseVisitor.getDefinedFunctions().containsKey(s)) {
            error += ("\n" + s + " not defined");
        } else if (stringCDQLBaseVisitor.getDefinedFunctions().get(s) instanceof AggregationFunction) {
            //stringCDQLBaseVisitor.getDefinedFunctions().get(s)
        }
    }
    if (!error.isEmpty()) {
        throw new CDQLSyntaxtErrorException(error);
    }
    error = "";
    Map<String, Vertex> parsedEntites = new HashMap<>();
    List<ContextEntity> executionPlan = new ArrayList<>();
    Graph graph = new Graph();
    boolean flag = true;
    while (flag) {
        flag = false;
        for (Map.Entry<String, ContextEntity> entry : stringCDQLBaseVisitor.getDefinedEntities().entrySet()) {
            ContextEntity value = entry.getValue();
            if (value.getCondition() == null || value.getCondition().getDependency() == null
                    || value.getCondition().getDependency().isEmpty()) {
                if (!parsedEntites.containsKey(entry.getKey())) {
                    Vertex vertex = new Vertex(value);
                    graph.addVertex(vertex, false);
                    executionPlan.add(value);
                    parsedEntites.put(entry.getKey(), vertex);
                    res.append("\n" + entry.getKey());
                    flag = true;
                }
            } else {
                boolean flag2 = true;
                Vertex vertex = new Vertex(value);
                List<Edge> edges = new ArrayList<>();
                for (Map.Entry<String, List<String>> s : value.getCondition().getDependency().entrySet()) {
                    if (!parsedEntites.containsKey(s.getKey())) {
                        flag2 = false;
                        break;
                    } else {
                        edges.add(new Edge(vertex, parsedEntites.get(s.getKey())));
                    }
                }
                if (flag2) {
                    if (!parsedEntites.containsKey(entry.getKey())) {
                        graph.addVertex(vertex, false);
                        for (Edge e : edges) {
                            graph.addEdge(e.getOne(), e.getTwo());
                        }
                        executionPlan.add(value);
                        parsedEntites.put(entry.getKey(), vertex);
                        flag = true;
                        res.append("\n" + entry.getKey());
                    }
                }
            }
        }
    }
    if (parsedEntites.size() != stringCDQLBaseVisitor.getDefinedEntities().size()) {

        throw new CDQLSyntaxtErrorException("the relationship between entites cannot be solved");
    }
    Query q = new Query();
    q.setQuery(query);
    q.setQuerystatus("IN_PROGRESS");
    q = em.merge(q);
    em.flush();
    try {
        for (ContextEntity e : executionPlan) {
            switch (e.getType()) {
            case DEVICE:
                String where = "";
                if (e.getCondition() != null && !e.getCondition().getRPNCondition().isEmpty()) {
                    where = " where " + e.getCondition().toJPAWhereClause();
                }
                List<Device> result = em
                        .createQuery("SELECT " + e.getEntityID() + " from Device as " + e.getEntityID() + where)
                        .getResultList();
                HashSet<String> requestedEntities = stringCDQLBaseVisitor.getDefinedContextAttributes()
                        .get(e.getEntityID());

                JSONArray requesteContext = new JSONArray();
                ObjectsType objectsType = new ObjectsType();

                Map<String, ObjectType> objs = new HashMap<>();
                for (String re : requestedEntities) {
                    try {
                        String replaceFirst = re.replaceFirst("\\.", "");
                        requesteContext.put(replaceFirst);
                        String[] split = replaceFirst.split("\\.");
                        InfoItemType infoItem = new InfoItemType();
                        if (split.length < 2) {
                            infoItem = null;
                        } else {
                            infoItem.setNameAttribute(split[1]);

                        }
                        if (objs.containsKey(split[0]) && infoItem != null) {
                            objs.get(split[0]).getInfoItem().add(infoItem);
                        } else {
                            ObjectType obj = new ObjectType();
                            QlmID qlmID = new QlmID();
                            qlmID.setValue(split[0]);
                            obj.getId().add(qlmID);
                            if (infoItem != null) {
                                obj.getInfoItem().add(infoItem);
                            }
                            objs.put(split[0], obj);
                        }
                    } catch (Exception es) {

                    }
                }
                for (Map.Entry<String, ObjectType> obj : objs.entrySet()) {
                    objectsType.getObject().add(obj.getValue());
                }
                String ipAddress = "";
                try {
                    InetAddress find = IpAddressFinder.find();
                    ipAddress = find.getHostAddress();
                } catch (UnknownHostException ex) {
                    Logger.getLogger(ContextQueryExecutor.class.getName()).log(Level.SEVERE, null, ex);
                }

                OmiEnvelope createReadRequestEnvelope = OmiFactory.createReadRequestEnvelope(100, objectsType,
                        "v1", "http://" + ipAddress + ":59646/CoaaS-war/webresources/generic");
                IdType idType = new IdType();
                idType.setFormat("db");
                idType.setValue(q.getQueryid().toString());
                createReadRequestEnvelope.getRead().getRequestID().add(idType);
                Gson gson = new Gson();
                String toJson = gson.toJson(createReadRequestEnvelope);
                JSONObject msg = null;
                try {
                    msg = new JSONObject(toJson);
                } catch (JSONException ex) {
                    Logger.getLogger(ContextQueryExecutor.class.getName()).log(Level.SEVERE, null, ex);
                }
                // infoItem.set
                for (Device d : result) {
                    try {
                        FCM.pushFCMNotification(d.getFcmid(), msg);
                    } catch (Exception ex) {
                        Logger.getLogger(ContextQueryExecutor.class.getName()).log(Level.SEVERE, null, ex);
                    }
                }
                break;
            case PERSON:
                break;
            }
        }
    } catch (Exception e) {

    }
    return graph;
}

From source file:com.rocana.configuration.ConfigurationParser.java

License:Apache License

public <T> T parse(Reader reader, Class<T> targetType) throws IOException {
    logger.debug("Parsing configuration for type:{}", targetType);

    ANTLRErrorListener listener = new BaseErrorListener() {

        @Override//from  ww  w.j a  v  a2 s .c  o  m
        public void syntaxError(Recognizer<?, ?> recognizer, Object offendingSymbol, int line,
                int charPositionInLine, String msg, RecognitionException e) {
            throw new ConfigurationException(String.format(
                    "Unable to parse configuration: %s (at line:%s pos:%s)", msg, line, charPositionInLine), e);
        }

    };

    TypeDescriptor typeDescriptor = TypeMapping.ofType(targetType);

    ANTLRInputStream inputStream = new ANTLRInputStream(reader);
    ConfigurationLexer lexer = new ConfigurationLexer(inputStream);
    lexer.removeErrorListeners();
    lexer.addErrorListener(listener);

    CommonTokenStream tokenStream = new CommonTokenStream(lexer);
    com.rocana.configuration.antlr.ConfigurationParser parser = new com.rocana.configuration.antlr.ConfigurationParser(
            tokenStream);

    parser.removeErrorListeners();
    parser.addErrorListener(listener);

    ParseTree parseTree = parser.config();

    logger.debug("Parsed configuration:{}", parseTree.toStringTree(parser));

    Visitor<T> visitor = new Visitor<>(typeDescriptor);

    visitor.visit(parseTree);

    logger.debug("Configured object:{}", visitor.getResult());

    return visitor.getResult();
}

From source file:de.dfki.kiara.tool.ThriftIDLParser.java

License:Open Source License

public static void main(String[] args) throws Exception {
    System.out.println("Parsing file: " + args[0]);
    // create a CharStream that reads from standard input
    ANTLRInputStream input = new ANTLRInputStream(new FileInputStream(args[0]));
    // create a lexer that feeds off of input CharStream
    ThriftLexer lexer = new ThriftLexer(input);
    // create a buffer of tokens pulled from the lexer
    CommonTokenStream tokens = new CommonTokenStream(lexer);
    // create a parser that feeds off the tokens buffer
    ThriftParser parser = new ThriftParser(tokens);
    ParseTree tree = parser.program(); // begin parsing at program rule
    System.out.println(tree.toStringTree(parser)); // print LISP-style tree
}

From source file:de.interactive_instruments.ShapeChange.SBVR.Sbvr2FolParser.java

License:Open Source License

/**
 * Parsed a first order logic expression from the given constraint. If
 * errors occur while parsing they are logged and <code>null</code> is
 * returned.//w ww  .j a  v a  2s  .c o  m
 * 
 * @param con
 * @return the first order logic expression represented by the constraint,
 *         or <code>null</code> if errors were detected while parsing
 */
public FolExpression parse(FolConstraint con) {

    Variable.reset();

    SbvrParsingResult parsingResult = new SbvrParsingResult();
    parsingResult.setConstraint(con);

    ANTLRInputStream input = new ANTLRInputStream(con.text());

    // create a lexer that feeds off of input CharStream
    SBVRLexer lexer = new SBVRLexer(input);

    // create a buffer of tokens pulled from the lexer
    CommonTokenStream tokens = new CommonTokenStream(lexer);

    // create a parser that feeds off the tokens buffer
    SBVRParser parser = new SBVRParser(tokens);
    parser.helper = helper;

    /*
     * remove ConsoleErrorListener and add our own
     */
    parser.removeErrorListeners();
    SbvrErrorListener parsingErrorListener = new SbvrErrorListener();
    parser.addErrorListener(parsingErrorListener);

    // execute parsing, starting with rule 'sentence'
    ParseTree tree = parser.sentence();

    // get rule invocation stack for debugging
    parsingResult.setRuleInvocationStack(tree.toStringTree(parser));

    // if there were parsing errors, log them
    if (parsingErrorListener.hasErrors()) {

        parsingResult.addErrors(parsingErrorListener.getErrors());

    } else {

        // walk parse tree to apply further validation
        SbvrValidationErrorListener validationErrorListener = new SbvrValidationErrorListener(nouns, verbs);

        ParseTreeWalker walker = new ParseTreeWalker();
        walker.walk(validationErrorListener, tree);

        // if there were validation errors, log them
        if (validationErrorListener.hasErrors()) {

            parsingResult.addErrors(validationErrorListener.getErrors());

        } else {

            // no parsing or validation errors encountered

            // create FOL expression

            Sbvr2FolVisitor folVisitor = new Sbvr2FolVisitor(model, con);

            FolExpression folExpr = folVisitor.visit(tree);

            if (folExpr == null) {

                if (folVisitor.hasErrors()) {
                    parsingResult.addErrors(folVisitor.getErrors());
                } else {
                    result.addError(this, 1);
                }

            } else {
                parsingResult.setFirstOrderLogicExpression(folExpr);
            }
        }
    }

    logParsingResult(parsingResult);

    if (parsingResult.hasFirstOrderLogicExpression()) {
        return parsingResult.getFirstOrderLogicExpression();
    } else {
        return null;
    }
}

From source file:fr.inria.oak.paxquery.xparser.client.XClient.java

License:Apache License

private void printParseDetails(ParseTree tree, XQueryParser parser, XQueryVisitorImplementation loader) {
    System.out.println();//from w w  w  . ja v a 2  s . c  om
    System.out.println("PARSE OUTPUT: ");
    System.out.println(tree.toStringTree(parser));

    System.out.println();
    System.out.println("TREE PATTERNS:");
    for (int i = 0; i < loader.navigationTreePatterns.size(); i++) {
        System.out.println("TreePattern (" + i + "): ");
        System.out.println(loader.navigationTreePatterns.get(i).toString(PrintingLevel.SIMPLIFY));
    }
    System.out.println();
    System.out.println("PATTERN-NODE MAP:");
    System.out.println(loader.patternNodeMap.toString());
    System.out.println();
    System.out.println("TEMPORARY VAR POSITIONS: ");
    System.out.println(loader.varMap.toString());
    System.out.println();
    System.out.println("LOGICAL PLAN:");
    System.out.println(loader.logicalPlan.toString());
    System.out.println();
    System.out.println("CONSTRUCTION TREE:");
    System.out.println(loader.constructionTreePattern.toString());
    System.out.println();
}

From source file:fr.inria.oak.paxquery.xparser.XPathMain.java

License:Apache License

public static void main(String args[]) {
    try {// w w  w .  j  a v  a 2 s .  co  m
        System.out.println("Enter a valid XPath expression followed by Enter and Ctrl+D: ");
        //create a CharStream that reads from standard input
        ANTLRInputStream input = new ANTLRInputStream(System.in);
        //create a lexer that feeds off of input CharStream
        XPathLexer lexer = new XPathLexer(input);
        //create a buffer of tokens pulled from the lexer
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        //create a parser that feeds off the tokens buffer
        XPathParser parser = new XPathParser(tokens);

        ParseTree tree = parser.xpath(); //begin parsing at start rule
        System.out.println(tree.toStringTree(parser));
    } catch (Exception e) {
        System.out.println("Query is malformed or not yet supported.");
    }

}

From source file:fr.inria.oak.paxquery.xparser.XPathMain.java

License:Apache License

public static boolean test_main(String test_query) {
    try {// w w w .j av a 2s.c o m
        System.out.println("Query: " + test_query);
        //create a CharStream that reads from standard input
        ANTLRInputStream input = new ANTLRInputStream(new java.io.ByteArrayInputStream(test_query.getBytes()));
        //create a lexer that feeds off of input CharStream
        XPathLexer lexer = new XPathLexer(input);
        //create a buffer of tokens pulled from the lexer
        CommonTokenStream tokens = new CommonTokenStream(lexer);
        //create a parser that feeds off the tokens buffer
        XPathParser parser = new XPathParser(tokens);

        ParseTree tree = parser.xpath(); //begin parsing at start rule
        System.out.println(tree.toStringTree(parser));

        return true;
    } catch (Exception e) {
        System.out.println("Error in input " + test_query);
        System.out.println(e.getMessage());
        return false;
    }
}