With the LISP notation

Start grun

grun Hello r -tree

where:

• Hello is the name of the grammar (ie the file name without the extension)
• r is the start rule to where to build the tree
• -tree prints the parse tree in LISP notation.

Enter the text to parse and terminate with an End of File Character

• Type Ctrl+D (^D) on unix
• or Ctrl+Z (^Z) on Windows

hello Nico # Type hello + your name
^Z  # End of file (Ctrl+Z)

• Output

(r hello nico)

With the gui parse tree inspector

With the minimal grun gui parse tree inspector

grun Hello r -gui

hello nicoooo # Type your text to parse
^Z # send an end of file ( Ctrl+Z - windows or Ctrl-Z linux)

With Idea plugin

With the idea plugin:

• right click on the line of the start rule
• start to type a text to see the tree

With Java

With all import from org.antlr.v4

public class Hello {

    public static void main(String[] args) {

        // The input
        String input = "hello nico";
        ANTLRInputStream inputStream = new ANTLRInputStream(input);

        // Lexer
        HelloLexer lexer = new HelloLexer(inputStream);

        // Stream of token
        CommonTokenStream commonTokenStream = new CommonTokenStream(lexer);

        // Create the parser
        HelloParser parser = new HelloParser(commonTokenStream);

        // Create the tree from the r parser rule
        ParseTree tree = parser.r();

        // Print the tree
        printNode(tree, 0, Arrays.asList(parser.getRuleNames()));

        // Or with the utility function to print the LISP-style tree
        // equivalent to `grun Hello r --tree`
        System.out.println(tree.toStringTree(parser));
        
    }

    /**
     * Recursive function to print a node
     * @param node
     * @param level
     * @param ruleNames
     */
    private static void printNode(ParseTree node, int level, List<String> ruleNames) {
        String nodeText = Trees.getNodeText(node, ruleNames);

        // Print
        StringBuilder line = new StringBuilder();
        IntStream.range(0, level).forEach(i -> line.append(" "));
        line
                .append("Level ")
                .append(level)
                .append(" - ")
                .append(nodeText);
        System.out.println(line.toString());


        // Chilrdnre
        if (node instanceof ParserRuleContext) {
            ParserRuleContext parserRuleContext = (ParserRuleContext) node;
            if (parserRuleContext.children != null) {
                for (ParseTree child : parserRuleContext.children) {
                    printNode(child, level + 1, ruleNames);
                }
            }
        }
    }
}

Level 0 - r
 Level 1 - hello
 Level 1 - nico

• LISP

(r hello nico)