1814 lines
68 KiB
Java
1814 lines
68 KiB
Java
// $ANTLR 3.2 Aug 13, 2010 19:41:25 /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g 2010-08-13 19:42:18
|
|
|
|
import org.antlr.runtime.*;
|
|
import java.util.Stack;
|
|
import java.util.List;
|
|
import java.util.ArrayList;
|
|
|
|
|
|
import org.antlr.runtime.tree.*;
|
|
|
|
public class SimpleCParser extends Parser {
|
|
public static final String[] tokenNames = new String[] {
|
|
"<invalid>", "<EOR>", "<DOWN>", "<UP>", "VAR_DEF", "ARG_DEF", "FUNC_HDR", "FUNC_DECL", "FUNC_DEF", "BLOCK", "ID", "EQ", "INT", "FOR", "INT_TYPE", "CHAR", "VOID", "EQEQ", "LT", "PLUS", "WS", "';'", "'('", "','", "')'", "'{'", "'}'"
|
|
};
|
|
public static final int LT=18;
|
|
public static final int T__26=26;
|
|
public static final int T__25=25;
|
|
public static final int T__24=24;
|
|
public static final int T__23=23;
|
|
public static final int T__22=22;
|
|
public static final int T__21=21;
|
|
public static final int CHAR=15;
|
|
public static final int FOR=13;
|
|
public static final int FUNC_HDR=6;
|
|
public static final int INT=12;
|
|
public static final int FUNC_DEF=8;
|
|
public static final int INT_TYPE=14;
|
|
public static final int ID=10;
|
|
public static final int EOF=-1;
|
|
public static final int FUNC_DECL=7;
|
|
public static final int ARG_DEF=5;
|
|
public static final int WS=20;
|
|
public static final int BLOCK=9;
|
|
public static final int PLUS=19;
|
|
public static final int VOID=16;
|
|
public static final int EQ=11;
|
|
public static final int VAR_DEF=4;
|
|
public static final int EQEQ=17;
|
|
|
|
// delegates
|
|
// delegators
|
|
|
|
|
|
public SimpleCParser(TokenStream input) {
|
|
this(input, new RecognizerSharedState());
|
|
}
|
|
public SimpleCParser(TokenStream input, RecognizerSharedState state) {
|
|
super(input, state);
|
|
|
|
}
|
|
|
|
protected TreeAdaptor adaptor = new CommonTreeAdaptor();
|
|
|
|
public void setTreeAdaptor(TreeAdaptor adaptor) {
|
|
this.adaptor = adaptor;
|
|
}
|
|
public TreeAdaptor getTreeAdaptor() {
|
|
return adaptor;
|
|
}
|
|
|
|
public String[] getTokenNames() { return SimpleCParser.tokenNames; }
|
|
public String getGrammarFileName() { return "/usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g"; }
|
|
|
|
|
|
public static class program_return extends ParserRuleReturnScope {
|
|
Object tree;
|
|
public Object getTree() { return tree; }
|
|
};
|
|
|
|
// $ANTLR start "program"
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:16:1: program : ( declaration )+ ;
|
|
public final SimpleCParser.program_return program() throws RecognitionException {
|
|
SimpleCParser.program_return retval = new SimpleCParser.program_return();
|
|
retval.start = input.LT(1);
|
|
|
|
Object root_0 = null;
|
|
|
|
SimpleCParser.declaration_return declaration1 = null;
|
|
|
|
|
|
|
|
try {
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:17:5: ( ( declaration )+ )
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:17:9: ( declaration )+
|
|
{
|
|
root_0 = (Object)adaptor.nil();
|
|
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:17:9: ( declaration )+
|
|
int cnt1=0;
|
|
loop1:
|
|
do {
|
|
int alt1=2;
|
|
int LA1_0 = input.LA(1);
|
|
|
|
if ( (LA1_0==ID||(LA1_0>=INT_TYPE && LA1_0<=VOID)) ) {
|
|
alt1=1;
|
|
}
|
|
|
|
|
|
switch (alt1) {
|
|
case 1 :
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:17:9: declaration
|
|
{
|
|
pushFollow(FOLLOW_declaration_in_program85);
|
|
declaration1=declaration();
|
|
|
|
state._fsp--;
|
|
|
|
adaptor.addChild(root_0, declaration1.getTree());
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
if ( cnt1 >= 1 ) break loop1;
|
|
EarlyExitException eee =
|
|
new EarlyExitException(1, input);
|
|
throw eee;
|
|
}
|
|
cnt1++;
|
|
} while (true);
|
|
|
|
|
|
}
|
|
|
|
retval.stop = input.LT(-1);
|
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
|
|
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
}
|
|
// $ANTLR end "program"
|
|
|
|
public static class declaration_return extends ParserRuleReturnScope {
|
|
Object tree;
|
|
public Object getTree() { return tree; }
|
|
};
|
|
|
|
// $ANTLR start "declaration"
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:20:1: declaration : ( variable | functionHeader ';' -> ^( FUNC_DECL functionHeader ) | functionHeader block -> ^( FUNC_DEF functionHeader block ) );
|
|
public final SimpleCParser.declaration_return declaration() throws RecognitionException {
|
|
SimpleCParser.declaration_return retval = new SimpleCParser.declaration_return();
|
|
retval.start = input.LT(1);
|
|
|
|
Object root_0 = null;
|
|
|
|
Token char_literal4=null;
|
|
SimpleCParser.variable_return variable2 = null;
|
|
|
|
SimpleCParser.functionHeader_return functionHeader3 = null;
|
|
|
|
SimpleCParser.functionHeader_return functionHeader5 = null;
|
|
|
|
SimpleCParser.block_return block6 = null;
|
|
|
|
|
|
Object char_literal4_tree=null;
|
|
RewriteRuleTokenStream stream_21=new RewriteRuleTokenStream(adaptor,"token 21");
|
|
RewriteRuleSubtreeStream stream_functionHeader=new RewriteRuleSubtreeStream(adaptor,"rule functionHeader");
|
|
RewriteRuleSubtreeStream stream_block=new RewriteRuleSubtreeStream(adaptor,"rule block");
|
|
try {
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:21:5: ( variable | functionHeader ';' -> ^( FUNC_DECL functionHeader ) | functionHeader block -> ^( FUNC_DEF functionHeader block ) )
|
|
int alt2=3;
|
|
alt2 = dfa2.predict(input);
|
|
switch (alt2) {
|
|
case 1 :
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:21:9: variable
|
|
{
|
|
root_0 = (Object)adaptor.nil();
|
|
|
|
pushFollow(FOLLOW_variable_in_declaration105);
|
|
variable2=variable();
|
|
|
|
state._fsp--;
|
|
|
|
adaptor.addChild(root_0, variable2.getTree());
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:22:9: functionHeader ';'
|
|
{
|
|
pushFollow(FOLLOW_functionHeader_in_declaration115);
|
|
functionHeader3=functionHeader();
|
|
|
|
state._fsp--;
|
|
|
|
stream_functionHeader.add(functionHeader3.getTree());
|
|
char_literal4=(Token)match(input,21,FOLLOW_21_in_declaration117);
|
|
stream_21.add(char_literal4);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: functionHeader
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
// wildcard labels:
|
|
retval.tree = root_0;
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = (Object)adaptor.nil();
|
|
// 22:28: -> ^( FUNC_DECL functionHeader )
|
|
{
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:22:31: ^( FUNC_DECL functionHeader )
|
|
{
|
|
Object root_1 = (Object)adaptor.nil();
|
|
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(FUNC_DECL, "FUNC_DECL"), root_1);
|
|
|
|
adaptor.addChild(root_1, stream_functionHeader.nextTree());
|
|
|
|
adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;
|
|
}
|
|
break;
|
|
case 3 :
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:23:9: functionHeader block
|
|
{
|
|
pushFollow(FOLLOW_functionHeader_in_declaration135);
|
|
functionHeader5=functionHeader();
|
|
|
|
state._fsp--;
|
|
|
|
stream_functionHeader.add(functionHeader5.getTree());
|
|
pushFollow(FOLLOW_block_in_declaration137);
|
|
block6=block();
|
|
|
|
state._fsp--;
|
|
|
|
stream_block.add(block6.getTree());
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: functionHeader, block
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
// wildcard labels:
|
|
retval.tree = root_0;
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = (Object)adaptor.nil();
|
|
// 23:30: -> ^( FUNC_DEF functionHeader block )
|
|
{
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:23:33: ^( FUNC_DEF functionHeader block )
|
|
{
|
|
Object root_1 = (Object)adaptor.nil();
|
|
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(FUNC_DEF, "FUNC_DEF"), root_1);
|
|
|
|
adaptor.addChild(root_1, stream_functionHeader.nextTree());
|
|
adaptor.addChild(root_1, stream_block.nextTree());
|
|
|
|
adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;
|
|
}
|
|
break;
|
|
|
|
}
|
|
retval.stop = input.LT(-1);
|
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
|
|
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
}
|
|
// $ANTLR end "declaration"
|
|
|
|
public static class variable_return extends ParserRuleReturnScope {
|
|
Object tree;
|
|
public Object getTree() { return tree; }
|
|
};
|
|
|
|
// $ANTLR start "variable"
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:26:1: variable : type declarator ';' -> ^( VAR_DEF type declarator ) ;
|
|
public final SimpleCParser.variable_return variable() throws RecognitionException {
|
|
SimpleCParser.variable_return retval = new SimpleCParser.variable_return();
|
|
retval.start = input.LT(1);
|
|
|
|
Object root_0 = null;
|
|
|
|
Token char_literal9=null;
|
|
SimpleCParser.type_return type7 = null;
|
|
|
|
SimpleCParser.declarator_return declarator8 = null;
|
|
|
|
|
|
Object char_literal9_tree=null;
|
|
RewriteRuleTokenStream stream_21=new RewriteRuleTokenStream(adaptor,"token 21");
|
|
RewriteRuleSubtreeStream stream_declarator=new RewriteRuleSubtreeStream(adaptor,"rule declarator");
|
|
RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
|
|
try {
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:27:5: ( type declarator ';' -> ^( VAR_DEF type declarator ) )
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:27:9: type declarator ';'
|
|
{
|
|
pushFollow(FOLLOW_type_in_variable166);
|
|
type7=type();
|
|
|
|
state._fsp--;
|
|
|
|
stream_type.add(type7.getTree());
|
|
pushFollow(FOLLOW_declarator_in_variable168);
|
|
declarator8=declarator();
|
|
|
|
state._fsp--;
|
|
|
|
stream_declarator.add(declarator8.getTree());
|
|
char_literal9=(Token)match(input,21,FOLLOW_21_in_variable170);
|
|
stream_21.add(char_literal9);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: type, declarator
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
// wildcard labels:
|
|
retval.tree = root_0;
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = (Object)adaptor.nil();
|
|
// 27:29: -> ^( VAR_DEF type declarator )
|
|
{
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:27:32: ^( VAR_DEF type declarator )
|
|
{
|
|
Object root_1 = (Object)adaptor.nil();
|
|
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(VAR_DEF, "VAR_DEF"), root_1);
|
|
|
|
adaptor.addChild(root_1, stream_type.nextTree());
|
|
adaptor.addChild(root_1, stream_declarator.nextTree());
|
|
|
|
adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;
|
|
}
|
|
|
|
retval.stop = input.LT(-1);
|
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
|
|
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
}
|
|
// $ANTLR end "variable"
|
|
|
|
public static class declarator_return extends ParserRuleReturnScope {
|
|
Object tree;
|
|
public Object getTree() { return tree; }
|
|
};
|
|
|
|
// $ANTLR start "declarator"
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:30:1: declarator : ID ;
|
|
public final SimpleCParser.declarator_return declarator() throws RecognitionException {
|
|
SimpleCParser.declarator_return retval = new SimpleCParser.declarator_return();
|
|
retval.start = input.LT(1);
|
|
|
|
Object root_0 = null;
|
|
|
|
Token ID10=null;
|
|
|
|
Object ID10_tree=null;
|
|
|
|
try {
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:31:5: ( ID )
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:31:9: ID
|
|
{
|
|
root_0 = (Object)adaptor.nil();
|
|
|
|
ID10=(Token)match(input,ID,FOLLOW_ID_in_declarator199);
|
|
ID10_tree = (Object)adaptor.create(ID10);
|
|
adaptor.addChild(root_0, ID10_tree);
|
|
|
|
|
|
}
|
|
|
|
retval.stop = input.LT(-1);
|
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
|
|
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
}
|
|
// $ANTLR end "declarator"
|
|
|
|
public static class functionHeader_return extends ParserRuleReturnScope {
|
|
Object tree;
|
|
public Object getTree() { return tree; }
|
|
};
|
|
|
|
// $ANTLR start "functionHeader"
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:34:1: functionHeader : type ID '(' ( formalParameter ( ',' formalParameter )* )? ')' -> ^( FUNC_HDR type ID ( formalParameter )+ ) ;
|
|
public final SimpleCParser.functionHeader_return functionHeader() throws RecognitionException {
|
|
SimpleCParser.functionHeader_return retval = new SimpleCParser.functionHeader_return();
|
|
retval.start = input.LT(1);
|
|
|
|
Object root_0 = null;
|
|
|
|
Token ID12=null;
|
|
Token char_literal13=null;
|
|
Token char_literal15=null;
|
|
Token char_literal17=null;
|
|
SimpleCParser.type_return type11 = null;
|
|
|
|
SimpleCParser.formalParameter_return formalParameter14 = null;
|
|
|
|
SimpleCParser.formalParameter_return formalParameter16 = null;
|
|
|
|
|
|
Object ID12_tree=null;
|
|
Object char_literal13_tree=null;
|
|
Object char_literal15_tree=null;
|
|
Object char_literal17_tree=null;
|
|
RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
|
|
RewriteRuleTokenStream stream_22=new RewriteRuleTokenStream(adaptor,"token 22");
|
|
RewriteRuleTokenStream stream_23=new RewriteRuleTokenStream(adaptor,"token 23");
|
|
RewriteRuleTokenStream stream_24=new RewriteRuleTokenStream(adaptor,"token 24");
|
|
RewriteRuleSubtreeStream stream_formalParameter=new RewriteRuleSubtreeStream(adaptor,"rule formalParameter");
|
|
RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
|
|
try {
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:35:5: ( type ID '(' ( formalParameter ( ',' formalParameter )* )? ')' -> ^( FUNC_HDR type ID ( formalParameter )+ ) )
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:35:9: type ID '(' ( formalParameter ( ',' formalParameter )* )? ')'
|
|
{
|
|
pushFollow(FOLLOW_type_in_functionHeader219);
|
|
type11=type();
|
|
|
|
state._fsp--;
|
|
|
|
stream_type.add(type11.getTree());
|
|
ID12=(Token)match(input,ID,FOLLOW_ID_in_functionHeader221);
|
|
stream_ID.add(ID12);
|
|
|
|
char_literal13=(Token)match(input,22,FOLLOW_22_in_functionHeader223);
|
|
stream_22.add(char_literal13);
|
|
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:35:21: ( formalParameter ( ',' formalParameter )* )?
|
|
int alt4=2;
|
|
int LA4_0 = input.LA(1);
|
|
|
|
if ( (LA4_0==ID||(LA4_0>=INT_TYPE && LA4_0<=VOID)) ) {
|
|
alt4=1;
|
|
}
|
|
switch (alt4) {
|
|
case 1 :
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:35:23: formalParameter ( ',' formalParameter )*
|
|
{
|
|
pushFollow(FOLLOW_formalParameter_in_functionHeader227);
|
|
formalParameter14=formalParameter();
|
|
|
|
state._fsp--;
|
|
|
|
stream_formalParameter.add(formalParameter14.getTree());
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:35:39: ( ',' formalParameter )*
|
|
loop3:
|
|
do {
|
|
int alt3=2;
|
|
int LA3_0 = input.LA(1);
|
|
|
|
if ( (LA3_0==23) ) {
|
|
alt3=1;
|
|
}
|
|
|
|
|
|
switch (alt3) {
|
|
case 1 :
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:35:41: ',' formalParameter
|
|
{
|
|
char_literal15=(Token)match(input,23,FOLLOW_23_in_functionHeader231);
|
|
stream_23.add(char_literal15);
|
|
|
|
pushFollow(FOLLOW_formalParameter_in_functionHeader233);
|
|
formalParameter16=formalParameter();
|
|
|
|
state._fsp--;
|
|
|
|
stream_formalParameter.add(formalParameter16.getTree());
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
break loop3;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
char_literal17=(Token)match(input,24,FOLLOW_24_in_functionHeader241);
|
|
stream_24.add(char_literal17);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: formalParameter, ID, type
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
// wildcard labels:
|
|
retval.tree = root_0;
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = (Object)adaptor.nil();
|
|
// 36:9: -> ^( FUNC_HDR type ID ( formalParameter )+ )
|
|
{
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:36:12: ^( FUNC_HDR type ID ( formalParameter )+ )
|
|
{
|
|
Object root_1 = (Object)adaptor.nil();
|
|
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(FUNC_HDR, "FUNC_HDR"), root_1);
|
|
|
|
adaptor.addChild(root_1, stream_type.nextTree());
|
|
adaptor.addChild(root_1, stream_ID.nextNode());
|
|
if ( !(stream_formalParameter.hasNext()) ) {
|
|
throw new RewriteEarlyExitException();
|
|
}
|
|
while ( stream_formalParameter.hasNext() ) {
|
|
adaptor.addChild(root_1, stream_formalParameter.nextTree());
|
|
|
|
}
|
|
stream_formalParameter.reset();
|
|
|
|
adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;
|
|
}
|
|
|
|
retval.stop = input.LT(-1);
|
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
|
|
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
}
|
|
// $ANTLR end "functionHeader"
|
|
|
|
public static class formalParameter_return extends ParserRuleReturnScope {
|
|
Object tree;
|
|
public Object getTree() { return tree; }
|
|
};
|
|
|
|
// $ANTLR start "formalParameter"
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:39:1: formalParameter : type declarator -> ^( ARG_DEF type declarator ) ;
|
|
public final SimpleCParser.formalParameter_return formalParameter() throws RecognitionException {
|
|
SimpleCParser.formalParameter_return retval = new SimpleCParser.formalParameter_return();
|
|
retval.start = input.LT(1);
|
|
|
|
Object root_0 = null;
|
|
|
|
SimpleCParser.type_return type18 = null;
|
|
|
|
SimpleCParser.declarator_return declarator19 = null;
|
|
|
|
|
|
RewriteRuleSubtreeStream stream_declarator=new RewriteRuleSubtreeStream(adaptor,"rule declarator");
|
|
RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
|
|
try {
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:40:5: ( type declarator -> ^( ARG_DEF type declarator ) )
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:40:9: type declarator
|
|
{
|
|
pushFollow(FOLLOW_type_in_formalParameter281);
|
|
type18=type();
|
|
|
|
state._fsp--;
|
|
|
|
stream_type.add(type18.getTree());
|
|
pushFollow(FOLLOW_declarator_in_formalParameter283);
|
|
declarator19=declarator();
|
|
|
|
state._fsp--;
|
|
|
|
stream_declarator.add(declarator19.getTree());
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: declarator, type
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
// wildcard labels:
|
|
retval.tree = root_0;
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = (Object)adaptor.nil();
|
|
// 40:25: -> ^( ARG_DEF type declarator )
|
|
{
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:40:28: ^( ARG_DEF type declarator )
|
|
{
|
|
Object root_1 = (Object)adaptor.nil();
|
|
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(ARG_DEF, "ARG_DEF"), root_1);
|
|
|
|
adaptor.addChild(root_1, stream_type.nextTree());
|
|
adaptor.addChild(root_1, stream_declarator.nextTree());
|
|
|
|
adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;
|
|
}
|
|
|
|
retval.stop = input.LT(-1);
|
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
|
|
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
}
|
|
// $ANTLR end "formalParameter"
|
|
|
|
public static class type_return extends ParserRuleReturnScope {
|
|
Object tree;
|
|
public Object getTree() { return tree; }
|
|
};
|
|
|
|
// $ANTLR start "type"
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:43:1: type : ( 'int' | 'char' | 'void' | ID );
|
|
public final SimpleCParser.type_return type() throws RecognitionException {
|
|
SimpleCParser.type_return retval = new SimpleCParser.type_return();
|
|
retval.start = input.LT(1);
|
|
|
|
Object root_0 = null;
|
|
|
|
Token set20=null;
|
|
|
|
Object set20_tree=null;
|
|
|
|
try {
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:44:5: ( 'int' | 'char' | 'void' | ID )
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:
|
|
{
|
|
root_0 = (Object)adaptor.nil();
|
|
|
|
set20=(Token)input.LT(1);
|
|
if ( input.LA(1)==ID||(input.LA(1)>=INT_TYPE && input.LA(1)<=VOID) ) {
|
|
input.consume();
|
|
adaptor.addChild(root_0, (Object)adaptor.create(set20));
|
|
state.errorRecovery=false;
|
|
}
|
|
else {
|
|
MismatchedSetException mse = new MismatchedSetException(null,input);
|
|
throw mse;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
retval.stop = input.LT(-1);
|
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
|
|
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
}
|
|
// $ANTLR end "type"
|
|
|
|
public static class block_return extends ParserRuleReturnScope {
|
|
Object tree;
|
|
public Object getTree() { return tree; }
|
|
};
|
|
|
|
// $ANTLR start "block"
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:50:1: block : lc= '{' ( variable )* ( stat )* '}' -> ^( BLOCK[$lc,@\"BLOCK\"] ( variable )* ( stat )* ) ;
|
|
public final SimpleCParser.block_return block() throws RecognitionException {
|
|
SimpleCParser.block_return retval = new SimpleCParser.block_return();
|
|
retval.start = input.LT(1);
|
|
|
|
Object root_0 = null;
|
|
|
|
Token lc=null;
|
|
Token char_literal23=null;
|
|
SimpleCParser.variable_return variable21 = null;
|
|
|
|
SimpleCParser.stat_return stat22 = null;
|
|
|
|
|
|
Object lc_tree=null;
|
|
Object char_literal23_tree=null;
|
|
RewriteRuleTokenStream stream_25=new RewriteRuleTokenStream(adaptor,"token 25");
|
|
RewriteRuleTokenStream stream_26=new RewriteRuleTokenStream(adaptor,"token 26");
|
|
RewriteRuleSubtreeStream stream_variable=new RewriteRuleSubtreeStream(adaptor,"rule variable");
|
|
RewriteRuleSubtreeStream stream_stat=new RewriteRuleSubtreeStream(adaptor,"rule stat");
|
|
try {
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:51:5: (lc= '{' ( variable )* ( stat )* '}' -> ^( BLOCK[$lc,@\"BLOCK\"] ( variable )* ( stat )* ) )
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:51:9: lc= '{' ( variable )* ( stat )* '}'
|
|
{
|
|
lc=(Token)match(input,25,FOLLOW_25_in_block376);
|
|
stream_25.add(lc);
|
|
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:52:13: ( variable )*
|
|
loop5:
|
|
do {
|
|
int alt5=2;
|
|
int LA5_0 = input.LA(1);
|
|
|
|
if ( (LA5_0==ID) ) {
|
|
int LA5_2 = input.LA(2);
|
|
|
|
if ( (LA5_2==ID) ) {
|
|
alt5=1;
|
|
}
|
|
|
|
|
|
}
|
|
else if ( ((LA5_0>=INT_TYPE && LA5_0<=VOID)) ) {
|
|
alt5=1;
|
|
}
|
|
|
|
|
|
switch (alt5) {
|
|
case 1 :
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:52:13: variable
|
|
{
|
|
pushFollow(FOLLOW_variable_in_block390);
|
|
variable21=variable();
|
|
|
|
state._fsp--;
|
|
|
|
stream_variable.add(variable21.getTree());
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
break loop5;
|
|
}
|
|
} while (true);
|
|
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:53:13: ( stat )*
|
|
loop6:
|
|
do {
|
|
int alt6=2;
|
|
int LA6_0 = input.LA(1);
|
|
|
|
if ( (LA6_0==ID||(LA6_0>=INT && LA6_0<=FOR)||(LA6_0>=21 && LA6_0<=22)||LA6_0==25) ) {
|
|
alt6=1;
|
|
}
|
|
|
|
|
|
switch (alt6) {
|
|
case 1 :
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:53:13: stat
|
|
{
|
|
pushFollow(FOLLOW_stat_in_block405);
|
|
stat22=stat();
|
|
|
|
state._fsp--;
|
|
|
|
stream_stat.add(stat22.getTree());
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
break loop6;
|
|
}
|
|
} while (true);
|
|
|
|
char_literal23=(Token)match(input,26,FOLLOW_26_in_block416);
|
|
stream_26.add(char_literal23);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: variable, stat
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
// wildcard labels:
|
|
retval.tree = root_0;
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = (Object)adaptor.nil();
|
|
// 55:9: -> ^( BLOCK[$lc,@\"BLOCK\"] ( variable )* ( stat )* )
|
|
{
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:55:12: ^( BLOCK[$lc,@\"BLOCK\"] ( variable )* ( stat )* )
|
|
{
|
|
Object root_1 = (Object)adaptor.nil();
|
|
root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(BLOCK, lc, @"BLOCK"), root_1);
|
|
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:55:34: ( variable )*
|
|
while ( stream_variable.hasNext() ) {
|
|
adaptor.addChild(root_1, stream_variable.nextTree());
|
|
|
|
}
|
|
stream_variable.reset();
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:55:44: ( stat )*
|
|
while ( stream_stat.hasNext() ) {
|
|
adaptor.addChild(root_1, stream_stat.nextTree());
|
|
|
|
}
|
|
stream_stat.reset();
|
|
|
|
adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;
|
|
}
|
|
|
|
retval.stop = input.LT(-1);
|
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
|
|
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
}
|
|
// $ANTLR end "block"
|
|
|
|
public static class stat_return extends ParserRuleReturnScope {
|
|
Object tree;
|
|
public Object getTree() { return tree; }
|
|
};
|
|
|
|
// $ANTLR start "stat"
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:58:1: stat : ( forStat | expr ';' | block | assignStat ';' | ';' );
|
|
public final SimpleCParser.stat_return stat() throws RecognitionException {
|
|
SimpleCParser.stat_return retval = new SimpleCParser.stat_return();
|
|
retval.start = input.LT(1);
|
|
|
|
Object root_0 = null;
|
|
|
|
Token char_literal26=null;
|
|
Token char_literal29=null;
|
|
Token char_literal30=null;
|
|
SimpleCParser.forStat_return forStat24 = null;
|
|
|
|
SimpleCParser.expr_return expr25 = null;
|
|
|
|
SimpleCParser.block_return block27 = null;
|
|
|
|
SimpleCParser.assignStat_return assignStat28 = null;
|
|
|
|
|
|
Object char_literal26_tree=null;
|
|
Object char_literal29_tree=null;
|
|
Object char_literal30_tree=null;
|
|
|
|
try {
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:58:5: ( forStat | expr ';' | block | assignStat ';' | ';' )
|
|
int alt7=5;
|
|
switch ( input.LA(1) ) {
|
|
case FOR:
|
|
{
|
|
alt7=1;
|
|
}
|
|
break;
|
|
case ID:
|
|
{
|
|
int LA7_2 = input.LA(2);
|
|
|
|
if ( (LA7_2==EQ) ) {
|
|
alt7=4;
|
|
}
|
|
else if ( ((LA7_2>=EQEQ && LA7_2<=PLUS)||LA7_2==21) ) {
|
|
alt7=2;
|
|
}
|
|
else {
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 7, 2, input);
|
|
|
|
throw nvae;
|
|
}
|
|
}
|
|
break;
|
|
case INT:
|
|
case 22:
|
|
{
|
|
alt7=2;
|
|
}
|
|
break;
|
|
case 25:
|
|
{
|
|
alt7=3;
|
|
}
|
|
break;
|
|
case 21:
|
|
{
|
|
alt7=5;
|
|
}
|
|
break;
|
|
default:
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 7, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt7) {
|
|
case 1 :
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:58:7: forStat
|
|
{
|
|
root_0 = (Object)adaptor.nil();
|
|
|
|
pushFollow(FOLLOW_forStat_in_stat449);
|
|
forStat24=forStat();
|
|
|
|
state._fsp--;
|
|
|
|
adaptor.addChild(root_0, forStat24.getTree());
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:59:7: expr ';'
|
|
{
|
|
root_0 = (Object)adaptor.nil();
|
|
|
|
pushFollow(FOLLOW_expr_in_stat457);
|
|
expr25=expr();
|
|
|
|
state._fsp--;
|
|
|
|
adaptor.addChild(root_0, expr25.getTree());
|
|
char_literal26=(Token)match(input,21,FOLLOW_21_in_stat459);
|
|
|
|
}
|
|
break;
|
|
case 3 :
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:60:7: block
|
|
{
|
|
root_0 = (Object)adaptor.nil();
|
|
|
|
pushFollow(FOLLOW_block_in_stat468);
|
|
block27=block();
|
|
|
|
state._fsp--;
|
|
|
|
adaptor.addChild(root_0, block27.getTree());
|
|
|
|
}
|
|
break;
|
|
case 4 :
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:61:7: assignStat ';'
|
|
{
|
|
root_0 = (Object)adaptor.nil();
|
|
|
|
pushFollow(FOLLOW_assignStat_in_stat476);
|
|
assignStat28=assignStat();
|
|
|
|
state._fsp--;
|
|
|
|
adaptor.addChild(root_0, assignStat28.getTree());
|
|
char_literal29=(Token)match(input,21,FOLLOW_21_in_stat478);
|
|
|
|
}
|
|
break;
|
|
case 5 :
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:62:7: ';'
|
|
{
|
|
root_0 = (Object)adaptor.nil();
|
|
|
|
char_literal30=(Token)match(input,21,FOLLOW_21_in_stat487);
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
retval.stop = input.LT(-1);
|
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
|
|
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
}
|
|
// $ANTLR end "stat"
|
|
|
|
public static class forStat_return extends ParserRuleReturnScope {
|
|
Object tree;
|
|
public Object getTree() { return tree; }
|
|
};
|
|
|
|
// $ANTLR start "forStat"
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:65:1: forStat : 'for' '(' start= assignStat ';' expr ';' next= assignStat ')' block -> ^( 'for' $start expr $next block ) ;
|
|
public final SimpleCParser.forStat_return forStat() throws RecognitionException {
|
|
SimpleCParser.forStat_return retval = new SimpleCParser.forStat_return();
|
|
retval.start = input.LT(1);
|
|
|
|
Object root_0 = null;
|
|
|
|
Token string_literal31=null;
|
|
Token char_literal32=null;
|
|
Token char_literal33=null;
|
|
Token char_literal35=null;
|
|
Token char_literal36=null;
|
|
SimpleCParser.assignStat_return start = null;
|
|
|
|
SimpleCParser.assignStat_return next = null;
|
|
|
|
SimpleCParser.expr_return expr34 = null;
|
|
|
|
SimpleCParser.block_return block37 = null;
|
|
|
|
|
|
Object string_literal31_tree=null;
|
|
Object char_literal32_tree=null;
|
|
Object char_literal33_tree=null;
|
|
Object char_literal35_tree=null;
|
|
Object char_literal36_tree=null;
|
|
RewriteRuleTokenStream stream_21=new RewriteRuleTokenStream(adaptor,"token 21");
|
|
RewriteRuleTokenStream stream_FOR=new RewriteRuleTokenStream(adaptor,"token FOR");
|
|
RewriteRuleTokenStream stream_22=new RewriteRuleTokenStream(adaptor,"token 22");
|
|
RewriteRuleTokenStream stream_24=new RewriteRuleTokenStream(adaptor,"token 24");
|
|
RewriteRuleSubtreeStream stream_assignStat=new RewriteRuleSubtreeStream(adaptor,"rule assignStat");
|
|
RewriteRuleSubtreeStream stream_block=new RewriteRuleSubtreeStream(adaptor,"rule block");
|
|
RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");
|
|
try {
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:66:5: ( 'for' '(' start= assignStat ';' expr ';' next= assignStat ')' block -> ^( 'for' $start expr $next block ) )
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:66:9: 'for' '(' start= assignStat ';' expr ';' next= assignStat ')' block
|
|
{
|
|
string_literal31=(Token)match(input,FOR,FOLLOW_FOR_in_forStat507);
|
|
stream_FOR.add(string_literal31);
|
|
|
|
char_literal32=(Token)match(input,22,FOLLOW_22_in_forStat509);
|
|
stream_22.add(char_literal32);
|
|
|
|
pushFollow(FOLLOW_assignStat_in_forStat513);
|
|
start=assignStat();
|
|
|
|
state._fsp--;
|
|
|
|
stream_assignStat.add(start.getTree());
|
|
char_literal33=(Token)match(input,21,FOLLOW_21_in_forStat515);
|
|
stream_21.add(char_literal33);
|
|
|
|
pushFollow(FOLLOW_expr_in_forStat517);
|
|
expr34=expr();
|
|
|
|
state._fsp--;
|
|
|
|
stream_expr.add(expr34.getTree());
|
|
char_literal35=(Token)match(input,21,FOLLOW_21_in_forStat519);
|
|
stream_21.add(char_literal35);
|
|
|
|
pushFollow(FOLLOW_assignStat_in_forStat523);
|
|
next=assignStat();
|
|
|
|
state._fsp--;
|
|
|
|
stream_assignStat.add(next.getTree());
|
|
char_literal36=(Token)match(input,24,FOLLOW_24_in_forStat525);
|
|
stream_24.add(char_literal36);
|
|
|
|
pushFollow(FOLLOW_block_in_forStat527);
|
|
block37=block();
|
|
|
|
state._fsp--;
|
|
|
|
stream_block.add(block37.getTree());
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: block, expr, FOR, start, next
|
|
// token labels:
|
|
// rule labels: retval, start, next
|
|
// token list labels:
|
|
// rule list labels:
|
|
// wildcard labels:
|
|
retval.tree = root_0;
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
|
|
RewriteRuleSubtreeStream stream_start=new RewriteRuleSubtreeStream(adaptor,"rule start",start!=null?start.tree:null);
|
|
RewriteRuleSubtreeStream stream_next=new RewriteRuleSubtreeStream(adaptor,"rule next",next!=null?next.tree:null);
|
|
|
|
root_0 = (Object)adaptor.nil();
|
|
// 67:9: -> ^( 'for' $start expr $next block )
|
|
{
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:67:12: ^( 'for' $start expr $next block )
|
|
{
|
|
Object root_1 = (Object)adaptor.nil();
|
|
root_1 = (Object)adaptor.becomeRoot(stream_FOR.nextNode(), root_1);
|
|
|
|
adaptor.addChild(root_1, stream_start.nextTree());
|
|
adaptor.addChild(root_1, stream_expr.nextTree());
|
|
adaptor.addChild(root_1, stream_next.nextTree());
|
|
adaptor.addChild(root_1, stream_block.nextTree());
|
|
|
|
adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;
|
|
}
|
|
|
|
retval.stop = input.LT(-1);
|
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
|
|
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
}
|
|
// $ANTLR end "forStat"
|
|
|
|
public static class assignStat_return extends ParserRuleReturnScope {
|
|
Object tree;
|
|
public Object getTree() { return tree; }
|
|
};
|
|
|
|
// $ANTLR start "assignStat"
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:70:1: assignStat : ID EQ expr -> ^( EQ ID expr ) ;
|
|
public final SimpleCParser.assignStat_return assignStat() throws RecognitionException {
|
|
SimpleCParser.assignStat_return retval = new SimpleCParser.assignStat_return();
|
|
retval.start = input.LT(1);
|
|
|
|
Object root_0 = null;
|
|
|
|
Token ID38=null;
|
|
Token EQ39=null;
|
|
SimpleCParser.expr_return expr40 = null;
|
|
|
|
|
|
Object ID38_tree=null;
|
|
Object EQ39_tree=null;
|
|
RewriteRuleTokenStream stream_EQ=new RewriteRuleTokenStream(adaptor,"token EQ");
|
|
RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
|
|
RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");
|
|
try {
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:71:5: ( ID EQ expr -> ^( EQ ID expr ) )
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:71:9: ID EQ expr
|
|
{
|
|
ID38=(Token)match(input,ID,FOLLOW_ID_in_assignStat570);
|
|
stream_ID.add(ID38);
|
|
|
|
EQ39=(Token)match(input,EQ,FOLLOW_EQ_in_assignStat572);
|
|
stream_EQ.add(EQ39);
|
|
|
|
pushFollow(FOLLOW_expr_in_assignStat574);
|
|
expr40=expr();
|
|
|
|
state._fsp--;
|
|
|
|
stream_expr.add(expr40.getTree());
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: EQ, expr, ID
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
// wildcard labels:
|
|
retval.tree = root_0;
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = (Object)adaptor.nil();
|
|
// 71:20: -> ^( EQ ID expr )
|
|
{
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:71:23: ^( EQ ID expr )
|
|
{
|
|
Object root_1 = (Object)adaptor.nil();
|
|
root_1 = (Object)adaptor.becomeRoot(stream_EQ.nextNode(), root_1);
|
|
|
|
adaptor.addChild(root_1, stream_ID.nextNode());
|
|
adaptor.addChild(root_1, stream_expr.nextTree());
|
|
|
|
adaptor.addChild(root_0, root_1);
|
|
}
|
|
|
|
}
|
|
|
|
retval.tree = root_0;
|
|
}
|
|
|
|
retval.stop = input.LT(-1);
|
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
|
|
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
}
|
|
// $ANTLR end "assignStat"
|
|
|
|
public static class expr_return extends ParserRuleReturnScope {
|
|
Object tree;
|
|
public Object getTree() { return tree; }
|
|
};
|
|
|
|
// $ANTLR start "expr"
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:74:1: expr : condExpr ;
|
|
public final SimpleCParser.expr_return expr() throws RecognitionException {
|
|
SimpleCParser.expr_return retval = new SimpleCParser.expr_return();
|
|
retval.start = input.LT(1);
|
|
|
|
Object root_0 = null;
|
|
|
|
SimpleCParser.condExpr_return condExpr41 = null;
|
|
|
|
|
|
|
|
try {
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:74:5: ( condExpr )
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:74:9: condExpr
|
|
{
|
|
root_0 = (Object)adaptor.nil();
|
|
|
|
pushFollow(FOLLOW_condExpr_in_expr598);
|
|
condExpr41=condExpr();
|
|
|
|
state._fsp--;
|
|
|
|
adaptor.addChild(root_0, condExpr41.getTree());
|
|
|
|
}
|
|
|
|
retval.stop = input.LT(-1);
|
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
|
|
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
}
|
|
// $ANTLR end "expr"
|
|
|
|
public static class condExpr_return extends ParserRuleReturnScope {
|
|
Object tree;
|
|
public Object getTree() { return tree; }
|
|
};
|
|
|
|
// $ANTLR start "condExpr"
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:77:1: condExpr : aexpr ( ( '==' | '<' ) aexpr )? ;
|
|
public final SimpleCParser.condExpr_return condExpr() throws RecognitionException {
|
|
SimpleCParser.condExpr_return retval = new SimpleCParser.condExpr_return();
|
|
retval.start = input.LT(1);
|
|
|
|
Object root_0 = null;
|
|
|
|
Token string_literal43=null;
|
|
Token char_literal44=null;
|
|
SimpleCParser.aexpr_return aexpr42 = null;
|
|
|
|
SimpleCParser.aexpr_return aexpr45 = null;
|
|
|
|
|
|
Object string_literal43_tree=null;
|
|
Object char_literal44_tree=null;
|
|
|
|
try {
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:78:5: ( aexpr ( ( '==' | '<' ) aexpr )? )
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:78:9: aexpr ( ( '==' | '<' ) aexpr )?
|
|
{
|
|
root_0 = (Object)adaptor.nil();
|
|
|
|
pushFollow(FOLLOW_aexpr_in_condExpr617);
|
|
aexpr42=aexpr();
|
|
|
|
state._fsp--;
|
|
|
|
adaptor.addChild(root_0, aexpr42.getTree());
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:78:15: ( ( '==' | '<' ) aexpr )?
|
|
int alt9=2;
|
|
int LA9_0 = input.LA(1);
|
|
|
|
if ( ((LA9_0>=EQEQ && LA9_0<=LT)) ) {
|
|
alt9=1;
|
|
}
|
|
switch (alt9) {
|
|
case 1 :
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:78:17: ( '==' | '<' ) aexpr
|
|
{
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:78:17: ( '==' | '<' )
|
|
int alt8=2;
|
|
int LA8_0 = input.LA(1);
|
|
|
|
if ( (LA8_0==EQEQ) ) {
|
|
alt8=1;
|
|
}
|
|
else if ( (LA8_0==LT) ) {
|
|
alt8=2;
|
|
}
|
|
else {
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 8, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
switch (alt8) {
|
|
case 1 :
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:78:18: '=='
|
|
{
|
|
string_literal43=(Token)match(input,EQEQ,FOLLOW_EQEQ_in_condExpr622);
|
|
string_literal43_tree = (Object)adaptor.create(string_literal43);
|
|
root_0 = (Object)adaptor.becomeRoot(string_literal43_tree, root_0);
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:78:26: '<'
|
|
{
|
|
char_literal44=(Token)match(input,LT,FOLLOW_LT_in_condExpr627);
|
|
char_literal44_tree = (Object)adaptor.create(char_literal44);
|
|
root_0 = (Object)adaptor.becomeRoot(char_literal44_tree, root_0);
|
|
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
pushFollow(FOLLOW_aexpr_in_condExpr631);
|
|
aexpr45=aexpr();
|
|
|
|
state._fsp--;
|
|
|
|
adaptor.addChild(root_0, aexpr45.getTree());
|
|
|
|
}
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
retval.stop = input.LT(-1);
|
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
|
|
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
}
|
|
// $ANTLR end "condExpr"
|
|
|
|
public static class aexpr_return extends ParserRuleReturnScope {
|
|
Object tree;
|
|
public Object getTree() { return tree; }
|
|
};
|
|
|
|
// $ANTLR start "aexpr"
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:81:1: aexpr : atom ( '+' atom )* ;
|
|
public final SimpleCParser.aexpr_return aexpr() throws RecognitionException {
|
|
SimpleCParser.aexpr_return retval = new SimpleCParser.aexpr_return();
|
|
retval.start = input.LT(1);
|
|
|
|
Object root_0 = null;
|
|
|
|
Token char_literal47=null;
|
|
SimpleCParser.atom_return atom46 = null;
|
|
|
|
SimpleCParser.atom_return atom48 = null;
|
|
|
|
|
|
Object char_literal47_tree=null;
|
|
|
|
try {
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:82:5: ( atom ( '+' atom )* )
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:82:9: atom ( '+' atom )*
|
|
{
|
|
root_0 = (Object)adaptor.nil();
|
|
|
|
pushFollow(FOLLOW_atom_in_aexpr653);
|
|
atom46=atom();
|
|
|
|
state._fsp--;
|
|
|
|
adaptor.addChild(root_0, atom46.getTree());
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:82:14: ( '+' atom )*
|
|
loop10:
|
|
do {
|
|
int alt10=2;
|
|
int LA10_0 = input.LA(1);
|
|
|
|
if ( (LA10_0==PLUS) ) {
|
|
alt10=1;
|
|
}
|
|
|
|
|
|
switch (alt10) {
|
|
case 1 :
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:82:16: '+' atom
|
|
{
|
|
char_literal47=(Token)match(input,PLUS,FOLLOW_PLUS_in_aexpr657);
|
|
char_literal47_tree = (Object)adaptor.create(char_literal47);
|
|
root_0 = (Object)adaptor.becomeRoot(char_literal47_tree, root_0);
|
|
|
|
pushFollow(FOLLOW_atom_in_aexpr660);
|
|
atom48=atom();
|
|
|
|
state._fsp--;
|
|
|
|
adaptor.addChild(root_0, atom48.getTree());
|
|
|
|
}
|
|
break;
|
|
|
|
default :
|
|
break loop10;
|
|
}
|
|
} while (true);
|
|
|
|
|
|
}
|
|
|
|
retval.stop = input.LT(-1);
|
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
|
|
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
}
|
|
// $ANTLR end "aexpr"
|
|
|
|
public static class atom_return extends ParserRuleReturnScope {
|
|
Object tree;
|
|
public Object getTree() { return tree; }
|
|
};
|
|
|
|
// $ANTLR start "atom"
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:85:1: atom : ( ID | INT | '(' expr ')' -> expr );
|
|
public final SimpleCParser.atom_return atom() throws RecognitionException {
|
|
SimpleCParser.atom_return retval = new SimpleCParser.atom_return();
|
|
retval.start = input.LT(1);
|
|
|
|
Object root_0 = null;
|
|
|
|
Token ID49=null;
|
|
Token INT50=null;
|
|
Token char_literal51=null;
|
|
Token char_literal53=null;
|
|
SimpleCParser.expr_return expr52 = null;
|
|
|
|
|
|
Object ID49_tree=null;
|
|
Object INT50_tree=null;
|
|
Object char_literal51_tree=null;
|
|
Object char_literal53_tree=null;
|
|
RewriteRuleTokenStream stream_22=new RewriteRuleTokenStream(adaptor,"token 22");
|
|
RewriteRuleTokenStream stream_24=new RewriteRuleTokenStream(adaptor,"token 24");
|
|
RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");
|
|
try {
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:86:5: ( ID | INT | '(' expr ')' -> expr )
|
|
int alt11=3;
|
|
switch ( input.LA(1) ) {
|
|
case ID:
|
|
{
|
|
alt11=1;
|
|
}
|
|
break;
|
|
case INT:
|
|
{
|
|
alt11=2;
|
|
}
|
|
break;
|
|
case 22:
|
|
{
|
|
alt11=3;
|
|
}
|
|
break;
|
|
default:
|
|
NoViableAltException nvae =
|
|
new NoViableAltException("", 11, 0, input);
|
|
|
|
throw nvae;
|
|
}
|
|
|
|
switch (alt11) {
|
|
case 1 :
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:86:7: ID
|
|
{
|
|
root_0 = (Object)adaptor.nil();
|
|
|
|
ID49=(Token)match(input,ID,FOLLOW_ID_in_atom680);
|
|
ID49_tree = (Object)adaptor.create(ID49);
|
|
adaptor.addChild(root_0, ID49_tree);
|
|
|
|
|
|
}
|
|
break;
|
|
case 2 :
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:87:7: INT
|
|
{
|
|
root_0 = (Object)adaptor.nil();
|
|
|
|
INT50=(Token)match(input,INT,FOLLOW_INT_in_atom694);
|
|
INT50_tree = (Object)adaptor.create(INT50);
|
|
adaptor.addChild(root_0, INT50_tree);
|
|
|
|
|
|
}
|
|
break;
|
|
case 3 :
|
|
// /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:88:7: '(' expr ')'
|
|
{
|
|
char_literal51=(Token)match(input,22,FOLLOW_22_in_atom708);
|
|
stream_22.add(char_literal51);
|
|
|
|
pushFollow(FOLLOW_expr_in_atom710);
|
|
expr52=expr();
|
|
|
|
state._fsp--;
|
|
|
|
stream_expr.add(expr52.getTree());
|
|
char_literal53=(Token)match(input,24,FOLLOW_24_in_atom712);
|
|
stream_24.add(char_literal53);
|
|
|
|
|
|
|
|
// AST REWRITE
|
|
// elements: expr
|
|
// token labels:
|
|
// rule labels: retval
|
|
// token list labels:
|
|
// rule list labels:
|
|
// wildcard labels:
|
|
retval.tree = root_0;
|
|
RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
|
|
|
|
root_0 = (Object)adaptor.nil();
|
|
// 88:20: -> expr
|
|
{
|
|
adaptor.addChild(root_0, stream_expr.nextTree());
|
|
|
|
}
|
|
|
|
retval.tree = root_0;
|
|
}
|
|
break;
|
|
|
|
}
|
|
retval.stop = input.LT(-1);
|
|
|
|
retval.tree = (Object)adaptor.rulePostProcessing(root_0);
|
|
adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
|
|
|
|
}
|
|
catch (RecognitionException re) {
|
|
reportError(re);
|
|
recover(input,re);
|
|
retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
|
|
|
|
}
|
|
finally {
|
|
}
|
|
return retval;
|
|
}
|
|
// $ANTLR end "atom"
|
|
|
|
// Delegated rules
|
|
|
|
|
|
protected DFA2 dfa2 = new DFA2(this);
|
|
static final String DFA2_eotS =
|
|
"\15\uffff";
|
|
static final String DFA2_eofS =
|
|
"\15\uffff";
|
|
static final String DFA2_minS =
|
|
"\2\12\1\25\1\12\1\uffff\1\12\1\25\1\27\2\uffff\2\12\1\27";
|
|
static final String DFA2_maxS =
|
|
"\1\20\1\12\1\26\1\30\1\uffff\1\12\1\31\1\30\2\uffff\1\20\1\12\1"+
|
|
"\30";
|
|
static final String DFA2_acceptS =
|
|
"\4\uffff\1\1\3\uffff\1\3\1\2\3\uffff";
|
|
static final String DFA2_specialS =
|
|
"\15\uffff}>";
|
|
static final String[] DFA2_transitionS = {
|
|
"\1\1\3\uffff\3\1",
|
|
"\1\2",
|
|
"\1\4\1\3",
|
|
"\1\5\3\uffff\3\5\7\uffff\1\6",
|
|
"",
|
|
"\1\7",
|
|
"\1\11\3\uffff\1\10",
|
|
"\1\12\1\6",
|
|
"",
|
|
"",
|
|
"\1\13\3\uffff\3\13",
|
|
"\1\14",
|
|
"\1\12\1\6"
|
|
};
|
|
|
|
static final short[] DFA2_eot = DFA.unpackEncodedString(DFA2_eotS);
|
|
static final short[] DFA2_eof = DFA.unpackEncodedString(DFA2_eofS);
|
|
static final char[] DFA2_min = DFA.unpackEncodedStringToUnsignedChars(DFA2_minS);
|
|
static final char[] DFA2_max = DFA.unpackEncodedStringToUnsignedChars(DFA2_maxS);
|
|
static final short[] DFA2_accept = DFA.unpackEncodedString(DFA2_acceptS);
|
|
static final short[] DFA2_special = DFA.unpackEncodedString(DFA2_specialS);
|
|
static final short[][] DFA2_transition;
|
|
|
|
static {
|
|
int numStates = DFA2_transitionS.length;
|
|
DFA2_transition = new short[numStates][];
|
|
for (int i=0; i<numStates; i++) {
|
|
DFA2_transition[i] = DFA.unpackEncodedString(DFA2_transitionS[i]);
|
|
}
|
|
}
|
|
|
|
class DFA2 extends DFA {
|
|
|
|
public DFA2(BaseRecognizer recognizer) {
|
|
this.recognizer = recognizer;
|
|
this.decisionNumber = 2;
|
|
this.eot = DFA2_eot;
|
|
this.eof = DFA2_eof;
|
|
this.min = DFA2_min;
|
|
this.max = DFA2_max;
|
|
this.accept = DFA2_accept;
|
|
this.special = DFA2_special;
|
|
this.transition = DFA2_transition;
|
|
}
|
|
public String getDescription() {
|
|
return "20:1: declaration : ( variable | functionHeader ';' -> ^( FUNC_DECL functionHeader ) | functionHeader block -> ^( FUNC_DEF functionHeader block ) );";
|
|
}
|
|
}
|
|
|
|
|
|
public static final BitSet FOLLOW_declaration_in_program85 = new BitSet(new long[]{0x000000000001C402L});
|
|
public static final BitSet FOLLOW_variable_in_declaration105 = new BitSet(new long[]{0x0000000000000002L});
|
|
public static final BitSet FOLLOW_functionHeader_in_declaration115 = new BitSet(new long[]{0x0000000000200000L});
|
|
public static final BitSet FOLLOW_21_in_declaration117 = new BitSet(new long[]{0x0000000000000002L});
|
|
public static final BitSet FOLLOW_functionHeader_in_declaration135 = new BitSet(new long[]{0x0000000002000000L});
|
|
public static final BitSet FOLLOW_block_in_declaration137 = new BitSet(new long[]{0x0000000000000002L});
|
|
public static final BitSet FOLLOW_type_in_variable166 = new BitSet(new long[]{0x0000000000000400L});
|
|
public static final BitSet FOLLOW_declarator_in_variable168 = new BitSet(new long[]{0x0000000000200000L});
|
|
public static final BitSet FOLLOW_21_in_variable170 = new BitSet(new long[]{0x0000000000000002L});
|
|
public static final BitSet FOLLOW_ID_in_declarator199 = new BitSet(new long[]{0x0000000000000002L});
|
|
public static final BitSet FOLLOW_type_in_functionHeader219 = new BitSet(new long[]{0x0000000000000400L});
|
|
public static final BitSet FOLLOW_ID_in_functionHeader221 = new BitSet(new long[]{0x0000000000400000L});
|
|
public static final BitSet FOLLOW_22_in_functionHeader223 = new BitSet(new long[]{0x000000000101C400L});
|
|
public static final BitSet FOLLOW_formalParameter_in_functionHeader227 = new BitSet(new long[]{0x0000000001800000L});
|
|
public static final BitSet FOLLOW_23_in_functionHeader231 = new BitSet(new long[]{0x000000000001C400L});
|
|
public static final BitSet FOLLOW_formalParameter_in_functionHeader233 = new BitSet(new long[]{0x0000000001800000L});
|
|
public static final BitSet FOLLOW_24_in_functionHeader241 = new BitSet(new long[]{0x0000000000000002L});
|
|
public static final BitSet FOLLOW_type_in_formalParameter281 = new BitSet(new long[]{0x0000000000000400L});
|
|
public static final BitSet FOLLOW_declarator_in_formalParameter283 = new BitSet(new long[]{0x0000000000000002L});
|
|
public static final BitSet FOLLOW_set_in_type0 = new BitSet(new long[]{0x0000000000000002L});
|
|
public static final BitSet FOLLOW_25_in_block376 = new BitSet(new long[]{0x000000000661F400L});
|
|
public static final BitSet FOLLOW_variable_in_block390 = new BitSet(new long[]{0x000000000661F400L});
|
|
public static final BitSet FOLLOW_stat_in_block405 = new BitSet(new long[]{0x0000000006603400L});
|
|
public static final BitSet FOLLOW_26_in_block416 = new BitSet(new long[]{0x0000000000000002L});
|
|
public static final BitSet FOLLOW_forStat_in_stat449 = new BitSet(new long[]{0x0000000000000002L});
|
|
public static final BitSet FOLLOW_expr_in_stat457 = new BitSet(new long[]{0x0000000000200000L});
|
|
public static final BitSet FOLLOW_21_in_stat459 = new BitSet(new long[]{0x0000000000000002L});
|
|
public static final BitSet FOLLOW_block_in_stat468 = new BitSet(new long[]{0x0000000000000002L});
|
|
public static final BitSet FOLLOW_assignStat_in_stat476 = new BitSet(new long[]{0x0000000000200000L});
|
|
public static final BitSet FOLLOW_21_in_stat478 = new BitSet(new long[]{0x0000000000000002L});
|
|
public static final BitSet FOLLOW_21_in_stat487 = new BitSet(new long[]{0x0000000000000002L});
|
|
public static final BitSet FOLLOW_FOR_in_forStat507 = new BitSet(new long[]{0x0000000000400000L});
|
|
public static final BitSet FOLLOW_22_in_forStat509 = new BitSet(new long[]{0x0000000000000400L});
|
|
public static final BitSet FOLLOW_assignStat_in_forStat513 = new BitSet(new long[]{0x0000000000200000L});
|
|
public static final BitSet FOLLOW_21_in_forStat515 = new BitSet(new long[]{0x0000000000401400L});
|
|
public static final BitSet FOLLOW_expr_in_forStat517 = new BitSet(new long[]{0x0000000000200000L});
|
|
public static final BitSet FOLLOW_21_in_forStat519 = new BitSet(new long[]{0x0000000000000400L});
|
|
public static final BitSet FOLLOW_assignStat_in_forStat523 = new BitSet(new long[]{0x0000000001000000L});
|
|
public static final BitSet FOLLOW_24_in_forStat525 = new BitSet(new long[]{0x0000000002000000L});
|
|
public static final BitSet FOLLOW_block_in_forStat527 = new BitSet(new long[]{0x0000000000000002L});
|
|
public static final BitSet FOLLOW_ID_in_assignStat570 = new BitSet(new long[]{0x0000000000000800L});
|
|
public static final BitSet FOLLOW_EQ_in_assignStat572 = new BitSet(new long[]{0x0000000000401400L});
|
|
public static final BitSet FOLLOW_expr_in_assignStat574 = new BitSet(new long[]{0x0000000000000002L});
|
|
public static final BitSet FOLLOW_condExpr_in_expr598 = new BitSet(new long[]{0x0000000000000002L});
|
|
public static final BitSet FOLLOW_aexpr_in_condExpr617 = new BitSet(new long[]{0x0000000000060002L});
|
|
public static final BitSet FOLLOW_EQEQ_in_condExpr622 = new BitSet(new long[]{0x0000000000401400L});
|
|
public static final BitSet FOLLOW_LT_in_condExpr627 = new BitSet(new long[]{0x0000000000401400L});
|
|
public static final BitSet FOLLOW_aexpr_in_condExpr631 = new BitSet(new long[]{0x0000000000000002L});
|
|
public static final BitSet FOLLOW_atom_in_aexpr653 = new BitSet(new long[]{0x0000000000080002L});
|
|
public static final BitSet FOLLOW_PLUS_in_aexpr657 = new BitSet(new long[]{0x0000000000401400L});
|
|
public static final BitSet FOLLOW_atom_in_aexpr660 = new BitSet(new long[]{0x0000000000080002L});
|
|
public static final BitSet FOLLOW_ID_in_atom680 = new BitSet(new long[]{0x0000000000000002L});
|
|
public static final BitSet FOLLOW_INT_in_atom694 = new BitSet(new long[]{0x0000000000000002L});
|
|
public static final BitSet FOLLOW_22_in_atom708 = new BitSet(new long[]{0x0000000000401400L});
|
|
public static final BitSet FOLLOW_expr_in_atom710 = new BitSet(new long[]{0x0000000001000000L});
|
|
public static final BitSet FOLLOW_24_in_atom712 = new BitSet(new long[]{0x0000000000000002L});
|
|
|
|
} |