ANTLR Cheat Sheet - ANTLR 3

Example

grammar T;
def : modifier+ 'int' ID '=' INT ';'
    | modifier+ 'int' ID ';'
    ;
modifier : 'public' | 'static' ;
INT : '0'..'9'+ ;
ID  : 'a'..'z'+ ;
WS  : (' '|'\r'|'\n')+ {$channel = HIDDEN;} ;

Matches input such as public static int i = 3;.

Here's a main program to invoke the parser on the file argument from command-line.

import java.io.*;
import org.antlr.runtime.*;
import org.antlr.runtime.tree.*;
public class Test {
    public static void main(String args[]) throws Exception {
        TLexer lex = new TLexer(new ANTLRFileStream(args[0]));
        CommonTokenStream tokens = new CommonTokenStream(lex);

        TParser parser = new TParser(tokens);
        TParser.startRule_return r = parser.startRule(); // launch parsing
        // print tree if building trees
        if ( r!=null ) System.out.println(((CommonTree)r.tree).toStringTree());
    }
}

Here is a test rig for building an AST with a parser and walking it with a tree parser:

import java.io.*;
import org.antlr.runtime.*;
import org.antlr.runtime.tree.*;
public class Test {
    public static void main(String args[]) throws Exception {
        TLexer lex = new TLexer(new ANTLRFileStream(args[0]));
        CommonTokenStream tokens = new CommonTokenStream(lex);

        TParser parser = new TParser(tokens); // created from T.g
        TParser.startRule_return r = parser.startRule(); // launch parsing
        if ( r!=null ) System.out.println(((CommonTree)r.tree).toStringTree());

        CommonTreeNodeStream nodes = new CommonTreeNodeStream((Tree)r.tree);
        nodes.setTokenStream(tokens);
        TP walker = new TP(nodes); // created from TP.g
        TP.startRule_return r2 = walker.startRule();
        CommonTree rt = ((CommonTree)r2.tree);
        // if tree parser constructs trees
        if ( rt!=null ) System.out.println(((CommonTree)r2.tree).toStringTree());               
    }
}

ANTLR Symbols

See also Grammars and Special symbols in actions.

Symbol	Description
$	Attribute
@	Action
::	action or dynamically-scoped attribute scope specifier
:	rule definition
;	end rule
\|	alternative
's'	char or string literal
.	wildcard
=	label assignment
+=	list label assignment
[..]	argument or return value spec
{...}	action
`...`	forced action; execute even while backtracking
(...)	subrule
+	1 or more
*	0 or more
?	optional or semantic predicate
~	match not
!	don't include in AST
^	make AST root node
=>	always execute predicate
->	rewrite rule
<token options>	token option spec like ID<node=VarNode>
^(...)	tree grammar or rewrite element
// ...	single-line comment
/* ... */	multi-line comment

Keyword	Description
scope	Dynamically-scoped attribute
fragment	lexer rule is a helper rule, not real token for parser
lexer	grammar type
tree	grammar type
parser	grammar type
grammar	grammar header
returns	rule return value(s)
throws	rule throws exception(s)
catch	catch rule exceptions
finally	do this no matter what
options	grammar or rule options
tokens	can add tokens with this; usually imaginary tokens
import	import grammar(s)