Home | History | Annotate | Download | only in output1
      1 // $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
      2 
      3 import org.antlr.runtime.*;
      4 import java.util.Stack;
      5 import java.util.List;
      6 import java.util.ArrayList;
      7 
      8 
      9 import org.antlr.runtime.tree.*;
     10 
     11 public class SimpleCParser extends Parser {
     12     public static final String[] tokenNames = new String[] {
     13         "<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", "';'", "'('", "','", "')'", "'{'", "'}'"
     14     };
     15     public static final int LT=18;
     16     public static final int T__26=26;
     17     public static final int T__25=25;
     18     public static final int T__24=24;
     19     public static final int T__23=23;
     20     public static final int T__22=22;
     21     public static final int T__21=21;
     22     public static final int CHAR=15;
     23     public static final int FOR=13;
     24     public static final int FUNC_HDR=6;
     25     public static final int INT=12;
     26     public static final int FUNC_DEF=8;
     27     public static final int INT_TYPE=14;
     28     public static final int ID=10;
     29     public static final int EOF=-1;
     30     public static final int FUNC_DECL=7;
     31     public static final int ARG_DEF=5;
     32     public static final int WS=20;
     33     public static final int BLOCK=9;
     34     public static final int PLUS=19;
     35     public static final int VOID=16;
     36     public static final int EQ=11;
     37     public static final int VAR_DEF=4;
     38     public static final int EQEQ=17;
     39 
     40     // delegates
     41     // delegators
     42 
     43 
     44         public SimpleCParser(TokenStream input) {
     45             this(input, new RecognizerSharedState());
     46         }
     47         public SimpleCParser(TokenStream input, RecognizerSharedState state) {
     48             super(input, state);
     49 
     50         }
     51 
     52     protected TreeAdaptor adaptor = new CommonTreeAdaptor();
     53 
     54     public void setTreeAdaptor(TreeAdaptor adaptor) {
     55         this.adaptor = adaptor;
     56     }
     57     public TreeAdaptor getTreeAdaptor() {
     58         return adaptor;
     59     }
     60 
     61     public String[] getTokenNames() { return SimpleCParser.tokenNames; }
     62     public String getGrammarFileName() { return "/usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g"; }
     63 
     64 
     65     public static class program_return extends ParserRuleReturnScope {
     66         Object tree;
     67         public Object getTree() { return tree; }
     68     };
     69 
     70     // $ANTLR start "program"
     71     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:16:1: program : ( declaration )+ ;
     72     public final SimpleCParser.program_return program() throws RecognitionException {
     73         SimpleCParser.program_return retval = new SimpleCParser.program_return();
     74         retval.start = input.LT(1);
     75 
     76         Object root_0 = null;
     77 
     78         SimpleCParser.declaration_return declaration1 = null;
     79 
     80 
     81 
     82         try {
     83             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:17:5: ( ( declaration )+ )
     84             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:17:9: ( declaration )+
     85             {
     86             root_0 = (Object)adaptor.nil();
     87 
     88             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:17:9: ( declaration )+
     89             int cnt1=0;
     90             loop1:
     91             do {
     92                 int alt1=2;
     93                 int LA1_0 = input.LA(1);
     94 
     95                 if ( (LA1_0==ID||(LA1_0>=INT_TYPE && LA1_0<=VOID)) ) {
     96                     alt1=1;
     97                 }
     98 
     99 
    100                 switch (alt1) {
    101             	case 1 :
    102             	    // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:17:9: declaration
    103             	    {
    104             	    pushFollow(FOLLOW_declaration_in_program85);
    105             	    declaration1=declaration();
    106 
    107             	    state._fsp--;
    108 
    109             	    adaptor.addChild(root_0, declaration1.getTree());
    110 
    111             	    }
    112             	    break;
    113 
    114             	default :
    115             	    if ( cnt1 >= 1 ) break loop1;
    116                         EarlyExitException eee =
    117                             new EarlyExitException(1, input);
    118                         throw eee;
    119                 }
    120                 cnt1++;
    121             } while (true);
    122 
    123 
    124             }
    125 
    126             retval.stop = input.LT(-1);
    127 
    128             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
    129             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    130 
    131         }
    132         catch (RecognitionException re) {
    133             reportError(re);
    134             recover(input,re);
    135     	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    136 
    137         }
    138         finally {
    139         }
    140         return retval;
    141     }
    142     // $ANTLR end "program"
    143 
    144     public static class declaration_return extends ParserRuleReturnScope {
    145         Object tree;
    146         public Object getTree() { return tree; }
    147     };
    148 
    149     // $ANTLR start "declaration"
    150     // /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 ) );
    151     public final SimpleCParser.declaration_return declaration() throws RecognitionException {
    152         SimpleCParser.declaration_return retval = new SimpleCParser.declaration_return();
    153         retval.start = input.LT(1);
    154 
    155         Object root_0 = null;
    156 
    157         Token char_literal4=null;
    158         SimpleCParser.variable_return variable2 = null;
    159 
    160         SimpleCParser.functionHeader_return functionHeader3 = null;
    161 
    162         SimpleCParser.functionHeader_return functionHeader5 = null;
    163 
    164         SimpleCParser.block_return block6 = null;
    165 
    166 
    167         Object char_literal4_tree=null;
    168         RewriteRuleTokenStream stream_21=new RewriteRuleTokenStream(adaptor,"token 21");
    169         RewriteRuleSubtreeStream stream_functionHeader=new RewriteRuleSubtreeStream(adaptor,"rule functionHeader");
    170         RewriteRuleSubtreeStream stream_block=new RewriteRuleSubtreeStream(adaptor,"rule block");
    171         try {
    172             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:21:5: ( variable | functionHeader ';' -> ^( FUNC_DECL functionHeader ) | functionHeader block -> ^( FUNC_DEF functionHeader block ) )
    173             int alt2=3;
    174             alt2 = dfa2.predict(input);
    175             switch (alt2) {
    176                 case 1 :
    177                     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:21:9: variable
    178                     {
    179                     root_0 = (Object)adaptor.nil();
    180 
    181                     pushFollow(FOLLOW_variable_in_declaration105);
    182                     variable2=variable();
    183 
    184                     state._fsp--;
    185 
    186                     adaptor.addChild(root_0, variable2.getTree());
    187 
    188                     }
    189                     break;
    190                 case 2 :
    191                     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:22:9: functionHeader ';'
    192                     {
    193                     pushFollow(FOLLOW_functionHeader_in_declaration115);
    194                     functionHeader3=functionHeader();
    195 
    196                     state._fsp--;
    197 
    198                     stream_functionHeader.add(functionHeader3.getTree());
    199                     char_literal4=(Token)match(input,21,FOLLOW_21_in_declaration117);
    200                     stream_21.add(char_literal4);
    201 
    202 
    203 
    204                     // AST REWRITE
    205                     // elements: functionHeader
    206                     // token labels:
    207                     // rule labels: retval
    208                     // token list labels:
    209                     // rule list labels:
    210                     // wildcard labels:
    211                     retval.tree = root_0;
    212                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
    213 
    214                     root_0 = (Object)adaptor.nil();
    215                     // 22:28: -> ^( FUNC_DECL functionHeader )
    216                     {
    217                         // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:22:31: ^( FUNC_DECL functionHeader )
    218                         {
    219                         Object root_1 = (Object)adaptor.nil();
    220                         root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(FUNC_DECL, "FUNC_DECL"), root_1);
    221 
    222                         adaptor.addChild(root_1, stream_functionHeader.nextTree());
    223 
    224                         adaptor.addChild(root_0, root_1);
    225                         }
    226 
    227                     }
    228 
    229                     retval.tree = root_0;
    230                     }
    231                     break;
    232                 case 3 :
    233                     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:23:9: functionHeader block
    234                     {
    235                     pushFollow(FOLLOW_functionHeader_in_declaration135);
    236                     functionHeader5=functionHeader();
    237 
    238                     state._fsp--;
    239 
    240                     stream_functionHeader.add(functionHeader5.getTree());
    241                     pushFollow(FOLLOW_block_in_declaration137);
    242                     block6=block();
    243 
    244                     state._fsp--;
    245 
    246                     stream_block.add(block6.getTree());
    247 
    248 
    249                     // AST REWRITE
    250                     // elements: functionHeader, block
    251                     // token labels:
    252                     // rule labels: retval
    253                     // token list labels:
    254                     // rule list labels:
    255                     // wildcard labels:
    256                     retval.tree = root_0;
    257                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
    258 
    259                     root_0 = (Object)adaptor.nil();
    260                     // 23:30: -> ^( FUNC_DEF functionHeader block )
    261                     {
    262                         // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:23:33: ^( FUNC_DEF functionHeader block )
    263                         {
    264                         Object root_1 = (Object)adaptor.nil();
    265                         root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(FUNC_DEF, "FUNC_DEF"), root_1);
    266 
    267                         adaptor.addChild(root_1, stream_functionHeader.nextTree());
    268                         adaptor.addChild(root_1, stream_block.nextTree());
    269 
    270                         adaptor.addChild(root_0, root_1);
    271                         }
    272 
    273                     }
    274 
    275                     retval.tree = root_0;
    276                     }
    277                     break;
    278 
    279             }
    280             retval.stop = input.LT(-1);
    281 
    282             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
    283             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    284 
    285         }
    286         catch (RecognitionException re) {
    287             reportError(re);
    288             recover(input,re);
    289     	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    290 
    291         }
    292         finally {
    293         }
    294         return retval;
    295     }
    296     // $ANTLR end "declaration"
    297 
    298     public static class variable_return extends ParserRuleReturnScope {
    299         Object tree;
    300         public Object getTree() { return tree; }
    301     };
    302 
    303     // $ANTLR start "variable"
    304     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:26:1: variable : type declarator ';' -> ^( VAR_DEF type declarator ) ;
    305     public final SimpleCParser.variable_return variable() throws RecognitionException {
    306         SimpleCParser.variable_return retval = new SimpleCParser.variable_return();
    307         retval.start = input.LT(1);
    308 
    309         Object root_0 = null;
    310 
    311         Token char_literal9=null;
    312         SimpleCParser.type_return type7 = null;
    313 
    314         SimpleCParser.declarator_return declarator8 = null;
    315 
    316 
    317         Object char_literal9_tree=null;
    318         RewriteRuleTokenStream stream_21=new RewriteRuleTokenStream(adaptor,"token 21");
    319         RewriteRuleSubtreeStream stream_declarator=new RewriteRuleSubtreeStream(adaptor,"rule declarator");
    320         RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
    321         try {
    322             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:27:5: ( type declarator ';' -> ^( VAR_DEF type declarator ) )
    323             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:27:9: type declarator ';'
    324             {
    325             pushFollow(FOLLOW_type_in_variable166);
    326             type7=type();
    327 
    328             state._fsp--;
    329 
    330             stream_type.add(type7.getTree());
    331             pushFollow(FOLLOW_declarator_in_variable168);
    332             declarator8=declarator();
    333 
    334             state._fsp--;
    335 
    336             stream_declarator.add(declarator8.getTree());
    337             char_literal9=(Token)match(input,21,FOLLOW_21_in_variable170);
    338             stream_21.add(char_literal9);
    339 
    340 
    341 
    342             // AST REWRITE
    343             // elements: type, declarator
    344             // token labels:
    345             // rule labels: retval
    346             // token list labels:
    347             // rule list labels:
    348             // wildcard labels:
    349             retval.tree = root_0;
    350             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
    351 
    352             root_0 = (Object)adaptor.nil();
    353             // 27:29: -> ^( VAR_DEF type declarator )
    354             {
    355                 // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:27:32: ^( VAR_DEF type declarator )
    356                 {
    357                 Object root_1 = (Object)adaptor.nil();
    358                 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(VAR_DEF, "VAR_DEF"), root_1);
    359 
    360                 adaptor.addChild(root_1, stream_type.nextTree());
    361                 adaptor.addChild(root_1, stream_declarator.nextTree());
    362 
    363                 adaptor.addChild(root_0, root_1);
    364                 }
    365 
    366             }
    367 
    368             retval.tree = root_0;
    369             }
    370 
    371             retval.stop = input.LT(-1);
    372 
    373             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
    374             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    375 
    376         }
    377         catch (RecognitionException re) {
    378             reportError(re);
    379             recover(input,re);
    380     	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    381 
    382         }
    383         finally {
    384         }
    385         return retval;
    386     }
    387     // $ANTLR end "variable"
    388 
    389     public static class declarator_return extends ParserRuleReturnScope {
    390         Object tree;
    391         public Object getTree() { return tree; }
    392     };
    393 
    394     // $ANTLR start "declarator"
    395     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:30:1: declarator : ID ;
    396     public final SimpleCParser.declarator_return declarator() throws RecognitionException {
    397         SimpleCParser.declarator_return retval = new SimpleCParser.declarator_return();
    398         retval.start = input.LT(1);
    399 
    400         Object root_0 = null;
    401 
    402         Token ID10=null;
    403 
    404         Object ID10_tree=null;
    405 
    406         try {
    407             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:31:5: ( ID )
    408             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:31:9: ID
    409             {
    410             root_0 = (Object)adaptor.nil();
    411 
    412             ID10=(Token)match(input,ID,FOLLOW_ID_in_declarator199);
    413             ID10_tree = (Object)adaptor.create(ID10);
    414             adaptor.addChild(root_0, ID10_tree);
    415 
    416 
    417             }
    418 
    419             retval.stop = input.LT(-1);
    420 
    421             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
    422             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    423 
    424         }
    425         catch (RecognitionException re) {
    426             reportError(re);
    427             recover(input,re);
    428     	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    429 
    430         }
    431         finally {
    432         }
    433         return retval;
    434     }
    435     // $ANTLR end "declarator"
    436 
    437     public static class functionHeader_return extends ParserRuleReturnScope {
    438         Object tree;
    439         public Object getTree() { return tree; }
    440     };
    441 
    442     // $ANTLR start "functionHeader"
    443     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:34:1: functionHeader : type ID '(' ( formalParameter ( ',' formalParameter )* )? ')' -> ^( FUNC_HDR type ID ( formalParameter )+ ) ;
    444     public final SimpleCParser.functionHeader_return functionHeader() throws RecognitionException {
    445         SimpleCParser.functionHeader_return retval = new SimpleCParser.functionHeader_return();
    446         retval.start = input.LT(1);
    447 
    448         Object root_0 = null;
    449 
    450         Token ID12=null;
    451         Token char_literal13=null;
    452         Token char_literal15=null;
    453         Token char_literal17=null;
    454         SimpleCParser.type_return type11 = null;
    455 
    456         SimpleCParser.formalParameter_return formalParameter14 = null;
    457 
    458         SimpleCParser.formalParameter_return formalParameter16 = null;
    459 
    460 
    461         Object ID12_tree=null;
    462         Object char_literal13_tree=null;
    463         Object char_literal15_tree=null;
    464         Object char_literal17_tree=null;
    465         RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
    466         RewriteRuleTokenStream stream_22=new RewriteRuleTokenStream(adaptor,"token 22");
    467         RewriteRuleTokenStream stream_23=new RewriteRuleTokenStream(adaptor,"token 23");
    468         RewriteRuleTokenStream stream_24=new RewriteRuleTokenStream(adaptor,"token 24");
    469         RewriteRuleSubtreeStream stream_formalParameter=new RewriteRuleSubtreeStream(adaptor,"rule formalParameter");
    470         RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
    471         try {
    472             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:35:5: ( type ID '(' ( formalParameter ( ',' formalParameter )* )? ')' -> ^( FUNC_HDR type ID ( formalParameter )+ ) )
    473             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:35:9: type ID '(' ( formalParameter ( ',' formalParameter )* )? ')'
    474             {
    475             pushFollow(FOLLOW_type_in_functionHeader219);
    476             type11=type();
    477 
    478             state._fsp--;
    479 
    480             stream_type.add(type11.getTree());
    481             ID12=(Token)match(input,ID,FOLLOW_ID_in_functionHeader221);
    482             stream_ID.add(ID12);
    483 
    484             char_literal13=(Token)match(input,22,FOLLOW_22_in_functionHeader223);
    485             stream_22.add(char_literal13);
    486 
    487             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:35:21: ( formalParameter ( ',' formalParameter )* )?
    488             int alt4=2;
    489             int LA4_0 = input.LA(1);
    490 
    491             if ( (LA4_0==ID||(LA4_0>=INT_TYPE && LA4_0<=VOID)) ) {
    492                 alt4=1;
    493             }
    494             switch (alt4) {
    495                 case 1 :
    496                     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:35:23: formalParameter ( ',' formalParameter )*
    497                     {
    498                     pushFollow(FOLLOW_formalParameter_in_functionHeader227);
    499                     formalParameter14=formalParameter();
    500 
    501                     state._fsp--;
    502 
    503                     stream_formalParameter.add(formalParameter14.getTree());
    504                     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:35:39: ( ',' formalParameter )*
    505                     loop3:
    506                     do {
    507                         int alt3=2;
    508                         int LA3_0 = input.LA(1);
    509 
    510                         if ( (LA3_0==23) ) {
    511                             alt3=1;
    512                         }
    513 
    514 
    515                         switch (alt3) {
    516                     	case 1 :
    517                     	    // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:35:41: ',' formalParameter
    518                     	    {
    519                     	    char_literal15=(Token)match(input,23,FOLLOW_23_in_functionHeader231);
    520                     	    stream_23.add(char_literal15);
    521 
    522                     	    pushFollow(FOLLOW_formalParameter_in_functionHeader233);
    523                     	    formalParameter16=formalParameter();
    524 
    525                     	    state._fsp--;
    526 
    527                     	    stream_formalParameter.add(formalParameter16.getTree());
    528 
    529                     	    }
    530                     	    break;
    531 
    532                     	default :
    533                     	    break loop3;
    534                         }
    535                     } while (true);
    536 
    537 
    538                     }
    539                     break;
    540 
    541             }
    542 
    543             char_literal17=(Token)match(input,24,FOLLOW_24_in_functionHeader241);
    544             stream_24.add(char_literal17);
    545 
    546 
    547 
    548             // AST REWRITE
    549             // elements: formalParameter, ID, type
    550             // token labels:
    551             // rule labels: retval
    552             // token list labels:
    553             // rule list labels:
    554             // wildcard labels:
    555             retval.tree = root_0;
    556             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
    557 
    558             root_0 = (Object)adaptor.nil();
    559             // 36:9: -> ^( FUNC_HDR type ID ( formalParameter )+ )
    560             {
    561                 // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:36:12: ^( FUNC_HDR type ID ( formalParameter )+ )
    562                 {
    563                 Object root_1 = (Object)adaptor.nil();
    564                 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(FUNC_HDR, "FUNC_HDR"), root_1);
    565 
    566                 adaptor.addChild(root_1, stream_type.nextTree());
    567                 adaptor.addChild(root_1, stream_ID.nextNode());
    568                 if ( !(stream_formalParameter.hasNext()) ) {
    569                     throw new RewriteEarlyExitException();
    570                 }
    571                 while ( stream_formalParameter.hasNext() ) {
    572                     adaptor.addChild(root_1, stream_formalParameter.nextTree());
    573 
    574                 }
    575                 stream_formalParameter.reset();
    576 
    577                 adaptor.addChild(root_0, root_1);
    578                 }
    579 
    580             }
    581 
    582             retval.tree = root_0;
    583             }
    584 
    585             retval.stop = input.LT(-1);
    586 
    587             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
    588             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    589 
    590         }
    591         catch (RecognitionException re) {
    592             reportError(re);
    593             recover(input,re);
    594     	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    595 
    596         }
    597         finally {
    598         }
    599         return retval;
    600     }
    601     // $ANTLR end "functionHeader"
    602 
    603     public static class formalParameter_return extends ParserRuleReturnScope {
    604         Object tree;
    605         public Object getTree() { return tree; }
    606     };
    607 
    608     // $ANTLR start "formalParameter"
    609     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:39:1: formalParameter : type declarator -> ^( ARG_DEF type declarator ) ;
    610     public final SimpleCParser.formalParameter_return formalParameter() throws RecognitionException {
    611         SimpleCParser.formalParameter_return retval = new SimpleCParser.formalParameter_return();
    612         retval.start = input.LT(1);
    613 
    614         Object root_0 = null;
    615 
    616         SimpleCParser.type_return type18 = null;
    617 
    618         SimpleCParser.declarator_return declarator19 = null;
    619 
    620 
    621         RewriteRuleSubtreeStream stream_declarator=new RewriteRuleSubtreeStream(adaptor,"rule declarator");
    622         RewriteRuleSubtreeStream stream_type=new RewriteRuleSubtreeStream(adaptor,"rule type");
    623         try {
    624             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:40:5: ( type declarator -> ^( ARG_DEF type declarator ) )
    625             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:40:9: type declarator
    626             {
    627             pushFollow(FOLLOW_type_in_formalParameter281);
    628             type18=type();
    629 
    630             state._fsp--;
    631 
    632             stream_type.add(type18.getTree());
    633             pushFollow(FOLLOW_declarator_in_formalParameter283);
    634             declarator19=declarator();
    635 
    636             state._fsp--;
    637 
    638             stream_declarator.add(declarator19.getTree());
    639 
    640 
    641             // AST REWRITE
    642             // elements: declarator, type
    643             // token labels:
    644             // rule labels: retval
    645             // token list labels:
    646             // rule list labels:
    647             // wildcard labels:
    648             retval.tree = root_0;
    649             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
    650 
    651             root_0 = (Object)adaptor.nil();
    652             // 40:25: -> ^( ARG_DEF type declarator )
    653             {
    654                 // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:40:28: ^( ARG_DEF type declarator )
    655                 {
    656                 Object root_1 = (Object)adaptor.nil();
    657                 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(ARG_DEF, "ARG_DEF"), root_1);
    658 
    659                 adaptor.addChild(root_1, stream_type.nextTree());
    660                 adaptor.addChild(root_1, stream_declarator.nextTree());
    661 
    662                 adaptor.addChild(root_0, root_1);
    663                 }
    664 
    665             }
    666 
    667             retval.tree = root_0;
    668             }
    669 
    670             retval.stop = input.LT(-1);
    671 
    672             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
    673             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    674 
    675         }
    676         catch (RecognitionException re) {
    677             reportError(re);
    678             recover(input,re);
    679     	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    680 
    681         }
    682         finally {
    683         }
    684         return retval;
    685     }
    686     // $ANTLR end "formalParameter"
    687 
    688     public static class type_return extends ParserRuleReturnScope {
    689         Object tree;
    690         public Object getTree() { return tree; }
    691     };
    692 
    693     // $ANTLR start "type"
    694     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:43:1: type : ( 'int' | 'char' | 'void' | ID );
    695     public final SimpleCParser.type_return type() throws RecognitionException {
    696         SimpleCParser.type_return retval = new SimpleCParser.type_return();
    697         retval.start = input.LT(1);
    698 
    699         Object root_0 = null;
    700 
    701         Token set20=null;
    702 
    703         Object set20_tree=null;
    704 
    705         try {
    706             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:44:5: ( 'int' | 'char' | 'void' | ID )
    707             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:
    708             {
    709             root_0 = (Object)adaptor.nil();
    710 
    711             set20=(Token)input.LT(1);
    712             if ( input.LA(1)==ID||(input.LA(1)>=INT_TYPE && input.LA(1)<=VOID) ) {
    713                 input.consume();
    714                 adaptor.addChild(root_0, (Object)adaptor.create(set20));
    715                 state.errorRecovery=false;
    716             }
    717             else {
    718                 MismatchedSetException mse = new MismatchedSetException(null,input);
    719                 throw mse;
    720             }
    721 
    722 
    723             }
    724 
    725             retval.stop = input.LT(-1);
    726 
    727             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
    728             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    729 
    730         }
    731         catch (RecognitionException re) {
    732             reportError(re);
    733             recover(input,re);
    734     	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    735 
    736         }
    737         finally {
    738         }
    739         return retval;
    740     }
    741     // $ANTLR end "type"
    742 
    743     public static class block_return extends ParserRuleReturnScope {
    744         Object tree;
    745         public Object getTree() { return tree; }
    746     };
    747 
    748     // $ANTLR start "block"
    749     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:50:1: block : lc= '{' ( variable )* ( stat )* '}' -> ^( BLOCK[$lc,@\"BLOCK\"] ( variable )* ( stat )* ) ;
    750     public final SimpleCParser.block_return block() throws RecognitionException {
    751         SimpleCParser.block_return retval = new SimpleCParser.block_return();
    752         retval.start = input.LT(1);
    753 
    754         Object root_0 = null;
    755 
    756         Token lc=null;
    757         Token char_literal23=null;
    758         SimpleCParser.variable_return variable21 = null;
    759 
    760         SimpleCParser.stat_return stat22 = null;
    761 
    762 
    763         Object lc_tree=null;
    764         Object char_literal23_tree=null;
    765         RewriteRuleTokenStream stream_25=new RewriteRuleTokenStream(adaptor,"token 25");
    766         RewriteRuleTokenStream stream_26=new RewriteRuleTokenStream(adaptor,"token 26");
    767         RewriteRuleSubtreeStream stream_variable=new RewriteRuleSubtreeStream(adaptor,"rule variable");
    768         RewriteRuleSubtreeStream stream_stat=new RewriteRuleSubtreeStream(adaptor,"rule stat");
    769         try {
    770             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:51:5: (lc= '{' ( variable )* ( stat )* '}' -> ^( BLOCK[$lc,@\"BLOCK\"] ( variable )* ( stat )* ) )
    771             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:51:9: lc= '{' ( variable )* ( stat )* '}'
    772             {
    773             lc=(Token)match(input,25,FOLLOW_25_in_block376);
    774             stream_25.add(lc);
    775 
    776             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:52:13: ( variable )*
    777             loop5:
    778             do {
    779                 int alt5=2;
    780                 int LA5_0 = input.LA(1);
    781 
    782                 if ( (LA5_0==ID) ) {
    783                     int LA5_2 = input.LA(2);
    784 
    785                     if ( (LA5_2==ID) ) {
    786                         alt5=1;
    787                     }
    788 
    789 
    790                 }
    791                 else if ( ((LA5_0>=INT_TYPE && LA5_0<=VOID)) ) {
    792                     alt5=1;
    793                 }
    794 
    795 
    796                 switch (alt5) {
    797             	case 1 :
    798             	    // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:52:13: variable
    799             	    {
    800             	    pushFollow(FOLLOW_variable_in_block390);
    801             	    variable21=variable();
    802 
    803             	    state._fsp--;
    804 
    805             	    stream_variable.add(variable21.getTree());
    806 
    807             	    }
    808             	    break;
    809 
    810             	default :
    811             	    break loop5;
    812                 }
    813             } while (true);
    814 
    815             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:53:13: ( stat )*
    816             loop6:
    817             do {
    818                 int alt6=2;
    819                 int LA6_0 = input.LA(1);
    820 
    821                 if ( (LA6_0==ID||(LA6_0>=INT && LA6_0<=FOR)||(LA6_0>=21 && LA6_0<=22)||LA6_0==25) ) {
    822                     alt6=1;
    823                 }
    824 
    825 
    826                 switch (alt6) {
    827             	case 1 :
    828             	    // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:53:13: stat
    829             	    {
    830             	    pushFollow(FOLLOW_stat_in_block405);
    831             	    stat22=stat();
    832 
    833             	    state._fsp--;
    834 
    835             	    stream_stat.add(stat22.getTree());
    836 
    837             	    }
    838             	    break;
    839 
    840             	default :
    841             	    break loop6;
    842                 }
    843             } while (true);
    844 
    845             char_literal23=(Token)match(input,26,FOLLOW_26_in_block416);
    846             stream_26.add(char_literal23);
    847 
    848 
    849 
    850             // AST REWRITE
    851             // elements: variable, stat
    852             // token labels:
    853             // rule labels: retval
    854             // token list labels:
    855             // rule list labels:
    856             // wildcard labels:
    857             retval.tree = root_0;
    858             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
    859 
    860             root_0 = (Object)adaptor.nil();
    861             // 55:9: -> ^( BLOCK[$lc,@\"BLOCK\"] ( variable )* ( stat )* )
    862             {
    863                 // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:55:12: ^( BLOCK[$lc,@\"BLOCK\"] ( variable )* ( stat )* )
    864                 {
    865                 Object root_1 = (Object)adaptor.nil();
    866                 root_1 = (Object)adaptor.becomeRoot((Object)adaptor.create(BLOCK, lc, @"BLOCK"), root_1);
    867 
    868                 // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:55:34: ( variable )*
    869                 while ( stream_variable.hasNext() ) {
    870                     adaptor.addChild(root_1, stream_variable.nextTree());
    871 
    872                 }
    873                 stream_variable.reset();
    874                 // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:55:44: ( stat )*
    875                 while ( stream_stat.hasNext() ) {
    876                     adaptor.addChild(root_1, stream_stat.nextTree());
    877 
    878                 }
    879                 stream_stat.reset();
    880 
    881                 adaptor.addChild(root_0, root_1);
    882                 }
    883 
    884             }
    885 
    886             retval.tree = root_0;
    887             }
    888 
    889             retval.stop = input.LT(-1);
    890 
    891             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
    892             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
    893 
    894         }
    895         catch (RecognitionException re) {
    896             reportError(re);
    897             recover(input,re);
    898     	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
    899 
    900         }
    901         finally {
    902         }
    903         return retval;
    904     }
    905     // $ANTLR end "block"
    906 
    907     public static class stat_return extends ParserRuleReturnScope {
    908         Object tree;
    909         public Object getTree() { return tree; }
    910     };
    911 
    912     // $ANTLR start "stat"
    913     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:58:1: stat : ( forStat | expr ';' | block | assignStat ';' | ';' );
    914     public final SimpleCParser.stat_return stat() throws RecognitionException {
    915         SimpleCParser.stat_return retval = new SimpleCParser.stat_return();
    916         retval.start = input.LT(1);
    917 
    918         Object root_0 = null;
    919 
    920         Token char_literal26=null;
    921         Token char_literal29=null;
    922         Token char_literal30=null;
    923         SimpleCParser.forStat_return forStat24 = null;
    924 
    925         SimpleCParser.expr_return expr25 = null;
    926 
    927         SimpleCParser.block_return block27 = null;
    928 
    929         SimpleCParser.assignStat_return assignStat28 = null;
    930 
    931 
    932         Object char_literal26_tree=null;
    933         Object char_literal29_tree=null;
    934         Object char_literal30_tree=null;
    935 
    936         try {
    937             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:58:5: ( forStat | expr ';' | block | assignStat ';' | ';' )
    938             int alt7=5;
    939             switch ( input.LA(1) ) {
    940             case FOR:
    941                 {
    942                 alt7=1;
    943                 }
    944                 break;
    945             case ID:
    946                 {
    947                 int LA7_2 = input.LA(2);
    948 
    949                 if ( (LA7_2==EQ) ) {
    950                     alt7=4;
    951                 }
    952                 else if ( ((LA7_2>=EQEQ && LA7_2<=PLUS)||LA7_2==21) ) {
    953                     alt7=2;
    954                 }
    955                 else {
    956                     NoViableAltException nvae =
    957                         new NoViableAltException("", 7, 2, input);
    958 
    959                     throw nvae;
    960                 }
    961                 }
    962                 break;
    963             case INT:
    964             case 22:
    965                 {
    966                 alt7=2;
    967                 }
    968                 break;
    969             case 25:
    970                 {
    971                 alt7=3;
    972                 }
    973                 break;
    974             case 21:
    975                 {
    976                 alt7=5;
    977                 }
    978                 break;
    979             default:
    980                 NoViableAltException nvae =
    981                     new NoViableAltException("", 7, 0, input);
    982 
    983                 throw nvae;
    984             }
    985 
    986             switch (alt7) {
    987                 case 1 :
    988                     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:58:7: forStat
    989                     {
    990                     root_0 = (Object)adaptor.nil();
    991 
    992                     pushFollow(FOLLOW_forStat_in_stat449);
    993                     forStat24=forStat();
    994 
    995                     state._fsp--;
    996 
    997                     adaptor.addChild(root_0, forStat24.getTree());
    998 
    999                     }
   1000                     break;
   1001                 case 2 :
   1002                     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:59:7: expr ';'
   1003                     {
   1004                     root_0 = (Object)adaptor.nil();
   1005 
   1006                     pushFollow(FOLLOW_expr_in_stat457);
   1007                     expr25=expr();
   1008 
   1009                     state._fsp--;
   1010 
   1011                     adaptor.addChild(root_0, expr25.getTree());
   1012                     char_literal26=(Token)match(input,21,FOLLOW_21_in_stat459);
   1013 
   1014                     }
   1015                     break;
   1016                 case 3 :
   1017                     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:60:7: block
   1018                     {
   1019                     root_0 = (Object)adaptor.nil();
   1020 
   1021                     pushFollow(FOLLOW_block_in_stat468);
   1022                     block27=block();
   1023 
   1024                     state._fsp--;
   1025 
   1026                     adaptor.addChild(root_0, block27.getTree());
   1027 
   1028                     }
   1029                     break;
   1030                 case 4 :
   1031                     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:61:7: assignStat ';'
   1032                     {
   1033                     root_0 = (Object)adaptor.nil();
   1034 
   1035                     pushFollow(FOLLOW_assignStat_in_stat476);
   1036                     assignStat28=assignStat();
   1037 
   1038                     state._fsp--;
   1039 
   1040                     adaptor.addChild(root_0, assignStat28.getTree());
   1041                     char_literal29=(Token)match(input,21,FOLLOW_21_in_stat478);
   1042 
   1043                     }
   1044                     break;
   1045                 case 5 :
   1046                     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:62:7: ';'
   1047                     {
   1048                     root_0 = (Object)adaptor.nil();
   1049 
   1050                     char_literal30=(Token)match(input,21,FOLLOW_21_in_stat487);
   1051 
   1052                     }
   1053                     break;
   1054 
   1055             }
   1056             retval.stop = input.LT(-1);
   1057 
   1058             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
   1059             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   1060 
   1061         }
   1062         catch (RecognitionException re) {
   1063             reportError(re);
   1064             recover(input,re);
   1065     	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   1066 
   1067         }
   1068         finally {
   1069         }
   1070         return retval;
   1071     }
   1072     // $ANTLR end "stat"
   1073 
   1074     public static class forStat_return extends ParserRuleReturnScope {
   1075         Object tree;
   1076         public Object getTree() { return tree; }
   1077     };
   1078 
   1079     // $ANTLR start "forStat"
   1080     // /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 ) ;
   1081     public final SimpleCParser.forStat_return forStat() throws RecognitionException {
   1082         SimpleCParser.forStat_return retval = new SimpleCParser.forStat_return();
   1083         retval.start = input.LT(1);
   1084 
   1085         Object root_0 = null;
   1086 
   1087         Token string_literal31=null;
   1088         Token char_literal32=null;
   1089         Token char_literal33=null;
   1090         Token char_literal35=null;
   1091         Token char_literal36=null;
   1092         SimpleCParser.assignStat_return start = null;
   1093 
   1094         SimpleCParser.assignStat_return next = null;
   1095 
   1096         SimpleCParser.expr_return expr34 = null;
   1097 
   1098         SimpleCParser.block_return block37 = null;
   1099 
   1100 
   1101         Object string_literal31_tree=null;
   1102         Object char_literal32_tree=null;
   1103         Object char_literal33_tree=null;
   1104         Object char_literal35_tree=null;
   1105         Object char_literal36_tree=null;
   1106         RewriteRuleTokenStream stream_21=new RewriteRuleTokenStream(adaptor,"token 21");
   1107         RewriteRuleTokenStream stream_FOR=new RewriteRuleTokenStream(adaptor,"token FOR");
   1108         RewriteRuleTokenStream stream_22=new RewriteRuleTokenStream(adaptor,"token 22");
   1109         RewriteRuleTokenStream stream_24=new RewriteRuleTokenStream(adaptor,"token 24");
   1110         RewriteRuleSubtreeStream stream_assignStat=new RewriteRuleSubtreeStream(adaptor,"rule assignStat");
   1111         RewriteRuleSubtreeStream stream_block=new RewriteRuleSubtreeStream(adaptor,"rule block");
   1112         RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");
   1113         try {
   1114             // /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 ) )
   1115             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:66:9: 'for' '(' start= assignStat ';' expr ';' next= assignStat ')' block
   1116             {
   1117             string_literal31=(Token)match(input,FOR,FOLLOW_FOR_in_forStat507);
   1118             stream_FOR.add(string_literal31);
   1119 
   1120             char_literal32=(Token)match(input,22,FOLLOW_22_in_forStat509);
   1121             stream_22.add(char_literal32);
   1122 
   1123             pushFollow(FOLLOW_assignStat_in_forStat513);
   1124             start=assignStat();
   1125 
   1126             state._fsp--;
   1127 
   1128             stream_assignStat.add(start.getTree());
   1129             char_literal33=(Token)match(input,21,FOLLOW_21_in_forStat515);
   1130             stream_21.add(char_literal33);
   1131 
   1132             pushFollow(FOLLOW_expr_in_forStat517);
   1133             expr34=expr();
   1134 
   1135             state._fsp--;
   1136 
   1137             stream_expr.add(expr34.getTree());
   1138             char_literal35=(Token)match(input,21,FOLLOW_21_in_forStat519);
   1139             stream_21.add(char_literal35);
   1140 
   1141             pushFollow(FOLLOW_assignStat_in_forStat523);
   1142             next=assignStat();
   1143 
   1144             state._fsp--;
   1145 
   1146             stream_assignStat.add(next.getTree());
   1147             char_literal36=(Token)match(input,24,FOLLOW_24_in_forStat525);
   1148             stream_24.add(char_literal36);
   1149 
   1150             pushFollow(FOLLOW_block_in_forStat527);
   1151             block37=block();
   1152 
   1153             state._fsp--;
   1154 
   1155             stream_block.add(block37.getTree());
   1156 
   1157 
   1158             // AST REWRITE
   1159             // elements: block, expr, FOR, start, next
   1160             // token labels:
   1161             // rule labels: retval, start, next
   1162             // token list labels:
   1163             // rule list labels:
   1164             // wildcard labels:
   1165             retval.tree = root_0;
   1166             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
   1167             RewriteRuleSubtreeStream stream_start=new RewriteRuleSubtreeStream(adaptor,"rule start",start!=null?start.tree:null);
   1168             RewriteRuleSubtreeStream stream_next=new RewriteRuleSubtreeStream(adaptor,"rule next",next!=null?next.tree:null);
   1169 
   1170             root_0 = (Object)adaptor.nil();
   1171             // 67:9: -> ^( 'for' $start expr $next block )
   1172             {
   1173                 // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:67:12: ^( 'for' $start expr $next block )
   1174                 {
   1175                 Object root_1 = (Object)adaptor.nil();
   1176                 root_1 = (Object)adaptor.becomeRoot(stream_FOR.nextNode(), root_1);
   1177 
   1178                 adaptor.addChild(root_1, stream_start.nextTree());
   1179                 adaptor.addChild(root_1, stream_expr.nextTree());
   1180                 adaptor.addChild(root_1, stream_next.nextTree());
   1181                 adaptor.addChild(root_1, stream_block.nextTree());
   1182 
   1183                 adaptor.addChild(root_0, root_1);
   1184                 }
   1185 
   1186             }
   1187 
   1188             retval.tree = root_0;
   1189             }
   1190 
   1191             retval.stop = input.LT(-1);
   1192 
   1193             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
   1194             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   1195 
   1196         }
   1197         catch (RecognitionException re) {
   1198             reportError(re);
   1199             recover(input,re);
   1200     	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   1201 
   1202         }
   1203         finally {
   1204         }
   1205         return retval;
   1206     }
   1207     // $ANTLR end "forStat"
   1208 
   1209     public static class assignStat_return extends ParserRuleReturnScope {
   1210         Object tree;
   1211         public Object getTree() { return tree; }
   1212     };
   1213 
   1214     // $ANTLR start "assignStat"
   1215     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:70:1: assignStat : ID EQ expr -> ^( EQ ID expr ) ;
   1216     public final SimpleCParser.assignStat_return assignStat() throws RecognitionException {
   1217         SimpleCParser.assignStat_return retval = new SimpleCParser.assignStat_return();
   1218         retval.start = input.LT(1);
   1219 
   1220         Object root_0 = null;
   1221 
   1222         Token ID38=null;
   1223         Token EQ39=null;
   1224         SimpleCParser.expr_return expr40 = null;
   1225 
   1226 
   1227         Object ID38_tree=null;
   1228         Object EQ39_tree=null;
   1229         RewriteRuleTokenStream stream_EQ=new RewriteRuleTokenStream(adaptor,"token EQ");
   1230         RewriteRuleTokenStream stream_ID=new RewriteRuleTokenStream(adaptor,"token ID");
   1231         RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");
   1232         try {
   1233             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:71:5: ( ID EQ expr -> ^( EQ ID expr ) )
   1234             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:71:9: ID EQ expr
   1235             {
   1236             ID38=(Token)match(input,ID,FOLLOW_ID_in_assignStat570);
   1237             stream_ID.add(ID38);
   1238 
   1239             EQ39=(Token)match(input,EQ,FOLLOW_EQ_in_assignStat572);
   1240             stream_EQ.add(EQ39);
   1241 
   1242             pushFollow(FOLLOW_expr_in_assignStat574);
   1243             expr40=expr();
   1244 
   1245             state._fsp--;
   1246 
   1247             stream_expr.add(expr40.getTree());
   1248 
   1249 
   1250             // AST REWRITE
   1251             // elements: EQ, expr, ID
   1252             // token labels:
   1253             // rule labels: retval
   1254             // token list labels:
   1255             // rule list labels:
   1256             // wildcard labels:
   1257             retval.tree = root_0;
   1258             RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
   1259 
   1260             root_0 = (Object)adaptor.nil();
   1261             // 71:20: -> ^( EQ ID expr )
   1262             {
   1263                 // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:71:23: ^( EQ ID expr )
   1264                 {
   1265                 Object root_1 = (Object)adaptor.nil();
   1266                 root_1 = (Object)adaptor.becomeRoot(stream_EQ.nextNode(), root_1);
   1267 
   1268                 adaptor.addChild(root_1, stream_ID.nextNode());
   1269                 adaptor.addChild(root_1, stream_expr.nextTree());
   1270 
   1271                 adaptor.addChild(root_0, root_1);
   1272                 }
   1273 
   1274             }
   1275 
   1276             retval.tree = root_0;
   1277             }
   1278 
   1279             retval.stop = input.LT(-1);
   1280 
   1281             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
   1282             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   1283 
   1284         }
   1285         catch (RecognitionException re) {
   1286             reportError(re);
   1287             recover(input,re);
   1288     	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   1289 
   1290         }
   1291         finally {
   1292         }
   1293         return retval;
   1294     }
   1295     // $ANTLR end "assignStat"
   1296 
   1297     public static class expr_return extends ParserRuleReturnScope {
   1298         Object tree;
   1299         public Object getTree() { return tree; }
   1300     };
   1301 
   1302     // $ANTLR start "expr"
   1303     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:74:1: expr : condExpr ;
   1304     public final SimpleCParser.expr_return expr() throws RecognitionException {
   1305         SimpleCParser.expr_return retval = new SimpleCParser.expr_return();
   1306         retval.start = input.LT(1);
   1307 
   1308         Object root_0 = null;
   1309 
   1310         SimpleCParser.condExpr_return condExpr41 = null;
   1311 
   1312 
   1313 
   1314         try {
   1315             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:74:5: ( condExpr )
   1316             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:74:9: condExpr
   1317             {
   1318             root_0 = (Object)adaptor.nil();
   1319 
   1320             pushFollow(FOLLOW_condExpr_in_expr598);
   1321             condExpr41=condExpr();
   1322 
   1323             state._fsp--;
   1324 
   1325             adaptor.addChild(root_0, condExpr41.getTree());
   1326 
   1327             }
   1328 
   1329             retval.stop = input.LT(-1);
   1330 
   1331             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
   1332             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   1333 
   1334         }
   1335         catch (RecognitionException re) {
   1336             reportError(re);
   1337             recover(input,re);
   1338     	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   1339 
   1340         }
   1341         finally {
   1342         }
   1343         return retval;
   1344     }
   1345     // $ANTLR end "expr"
   1346 
   1347     public static class condExpr_return extends ParserRuleReturnScope {
   1348         Object tree;
   1349         public Object getTree() { return tree; }
   1350     };
   1351 
   1352     // $ANTLR start "condExpr"
   1353     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:77:1: condExpr : aexpr ( ( '==' | '<' ) aexpr )? ;
   1354     public final SimpleCParser.condExpr_return condExpr() throws RecognitionException {
   1355         SimpleCParser.condExpr_return retval = new SimpleCParser.condExpr_return();
   1356         retval.start = input.LT(1);
   1357 
   1358         Object root_0 = null;
   1359 
   1360         Token string_literal43=null;
   1361         Token char_literal44=null;
   1362         SimpleCParser.aexpr_return aexpr42 = null;
   1363 
   1364         SimpleCParser.aexpr_return aexpr45 = null;
   1365 
   1366 
   1367         Object string_literal43_tree=null;
   1368         Object char_literal44_tree=null;
   1369 
   1370         try {
   1371             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:78:5: ( aexpr ( ( '==' | '<' ) aexpr )? )
   1372             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:78:9: aexpr ( ( '==' | '<' ) aexpr )?
   1373             {
   1374             root_0 = (Object)adaptor.nil();
   1375 
   1376             pushFollow(FOLLOW_aexpr_in_condExpr617);
   1377             aexpr42=aexpr();
   1378 
   1379             state._fsp--;
   1380 
   1381             adaptor.addChild(root_0, aexpr42.getTree());
   1382             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:78:15: ( ( '==' | '<' ) aexpr )?
   1383             int alt9=2;
   1384             int LA9_0 = input.LA(1);
   1385 
   1386             if ( ((LA9_0>=EQEQ && LA9_0<=LT)) ) {
   1387                 alt9=1;
   1388             }
   1389             switch (alt9) {
   1390                 case 1 :
   1391                     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:78:17: ( '==' | '<' ) aexpr
   1392                     {
   1393                     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:78:17: ( '==' | '<' )
   1394                     int alt8=2;
   1395                     int LA8_0 = input.LA(1);
   1396 
   1397                     if ( (LA8_0==EQEQ) ) {
   1398                         alt8=1;
   1399                     }
   1400                     else if ( (LA8_0==LT) ) {
   1401                         alt8=2;
   1402                     }
   1403                     else {
   1404                         NoViableAltException nvae =
   1405                             new NoViableAltException("", 8, 0, input);
   1406 
   1407                         throw nvae;
   1408                     }
   1409                     switch (alt8) {
   1410                         case 1 :
   1411                             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:78:18: '=='
   1412                             {
   1413                             string_literal43=(Token)match(input,EQEQ,FOLLOW_EQEQ_in_condExpr622);
   1414                             string_literal43_tree = (Object)adaptor.create(string_literal43);
   1415                             root_0 = (Object)adaptor.becomeRoot(string_literal43_tree, root_0);
   1416 
   1417 
   1418                             }
   1419                             break;
   1420                         case 2 :
   1421                             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:78:26: '<'
   1422                             {
   1423                             char_literal44=(Token)match(input,LT,FOLLOW_LT_in_condExpr627);
   1424                             char_literal44_tree = (Object)adaptor.create(char_literal44);
   1425                             root_0 = (Object)adaptor.becomeRoot(char_literal44_tree, root_0);
   1426 
   1427 
   1428                             }
   1429                             break;
   1430 
   1431                     }
   1432 
   1433                     pushFollow(FOLLOW_aexpr_in_condExpr631);
   1434                     aexpr45=aexpr();
   1435 
   1436                     state._fsp--;
   1437 
   1438                     adaptor.addChild(root_0, aexpr45.getTree());
   1439 
   1440                     }
   1441                     break;
   1442 
   1443             }
   1444 
   1445 
   1446             }
   1447 
   1448             retval.stop = input.LT(-1);
   1449 
   1450             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
   1451             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   1452 
   1453         }
   1454         catch (RecognitionException re) {
   1455             reportError(re);
   1456             recover(input,re);
   1457     	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   1458 
   1459         }
   1460         finally {
   1461         }
   1462         return retval;
   1463     }
   1464     // $ANTLR end "condExpr"
   1465 
   1466     public static class aexpr_return extends ParserRuleReturnScope {
   1467         Object tree;
   1468         public Object getTree() { return tree; }
   1469     };
   1470 
   1471     // $ANTLR start "aexpr"
   1472     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:81:1: aexpr : atom ( '+' atom )* ;
   1473     public final SimpleCParser.aexpr_return aexpr() throws RecognitionException {
   1474         SimpleCParser.aexpr_return retval = new SimpleCParser.aexpr_return();
   1475         retval.start = input.LT(1);
   1476 
   1477         Object root_0 = null;
   1478 
   1479         Token char_literal47=null;
   1480         SimpleCParser.atom_return atom46 = null;
   1481 
   1482         SimpleCParser.atom_return atom48 = null;
   1483 
   1484 
   1485         Object char_literal47_tree=null;
   1486 
   1487         try {
   1488             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:82:5: ( atom ( '+' atom )* )
   1489             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:82:9: atom ( '+' atom )*
   1490             {
   1491             root_0 = (Object)adaptor.nil();
   1492 
   1493             pushFollow(FOLLOW_atom_in_aexpr653);
   1494             atom46=atom();
   1495 
   1496             state._fsp--;
   1497 
   1498             adaptor.addChild(root_0, atom46.getTree());
   1499             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:82:14: ( '+' atom )*
   1500             loop10:
   1501             do {
   1502                 int alt10=2;
   1503                 int LA10_0 = input.LA(1);
   1504 
   1505                 if ( (LA10_0==PLUS) ) {
   1506                     alt10=1;
   1507                 }
   1508 
   1509 
   1510                 switch (alt10) {
   1511             	case 1 :
   1512             	    // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:82:16: '+' atom
   1513             	    {
   1514             	    char_literal47=(Token)match(input,PLUS,FOLLOW_PLUS_in_aexpr657);
   1515             	    char_literal47_tree = (Object)adaptor.create(char_literal47);
   1516             	    root_0 = (Object)adaptor.becomeRoot(char_literal47_tree, root_0);
   1517 
   1518             	    pushFollow(FOLLOW_atom_in_aexpr660);
   1519             	    atom48=atom();
   1520 
   1521             	    state._fsp--;
   1522 
   1523             	    adaptor.addChild(root_0, atom48.getTree());
   1524 
   1525             	    }
   1526             	    break;
   1527 
   1528             	default :
   1529             	    break loop10;
   1530                 }
   1531             } while (true);
   1532 
   1533 
   1534             }
   1535 
   1536             retval.stop = input.LT(-1);
   1537 
   1538             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
   1539             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   1540 
   1541         }
   1542         catch (RecognitionException re) {
   1543             reportError(re);
   1544             recover(input,re);
   1545     	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   1546 
   1547         }
   1548         finally {
   1549         }
   1550         return retval;
   1551     }
   1552     // $ANTLR end "aexpr"
   1553 
   1554     public static class atom_return extends ParserRuleReturnScope {
   1555         Object tree;
   1556         public Object getTree() { return tree; }
   1557     };
   1558 
   1559     // $ANTLR start "atom"
   1560     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:85:1: atom : ( ID | INT | '(' expr ')' -> expr );
   1561     public final SimpleCParser.atom_return atom() throws RecognitionException {
   1562         SimpleCParser.atom_return retval = new SimpleCParser.atom_return();
   1563         retval.start = input.LT(1);
   1564 
   1565         Object root_0 = null;
   1566 
   1567         Token ID49=null;
   1568         Token INT50=null;
   1569         Token char_literal51=null;
   1570         Token char_literal53=null;
   1571         SimpleCParser.expr_return expr52 = null;
   1572 
   1573 
   1574         Object ID49_tree=null;
   1575         Object INT50_tree=null;
   1576         Object char_literal51_tree=null;
   1577         Object char_literal53_tree=null;
   1578         RewriteRuleTokenStream stream_22=new RewriteRuleTokenStream(adaptor,"token 22");
   1579         RewriteRuleTokenStream stream_24=new RewriteRuleTokenStream(adaptor,"token 24");
   1580         RewriteRuleSubtreeStream stream_expr=new RewriteRuleSubtreeStream(adaptor,"rule expr");
   1581         try {
   1582             // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:86:5: ( ID | INT | '(' expr ')' -> expr )
   1583             int alt11=3;
   1584             switch ( input.LA(1) ) {
   1585             case ID:
   1586                 {
   1587                 alt11=1;
   1588                 }
   1589                 break;
   1590             case INT:
   1591                 {
   1592                 alt11=2;
   1593                 }
   1594                 break;
   1595             case 22:
   1596                 {
   1597                 alt11=3;
   1598                 }
   1599                 break;
   1600             default:
   1601                 NoViableAltException nvae =
   1602                     new NoViableAltException("", 11, 0, input);
   1603 
   1604                 throw nvae;
   1605             }
   1606 
   1607             switch (alt11) {
   1608                 case 1 :
   1609                     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:86:7: ID
   1610                     {
   1611                     root_0 = (Object)adaptor.nil();
   1612 
   1613                     ID49=(Token)match(input,ID,FOLLOW_ID_in_atom680);
   1614                     ID49_tree = (Object)adaptor.create(ID49);
   1615                     adaptor.addChild(root_0, ID49_tree);
   1616 
   1617 
   1618                     }
   1619                     break;
   1620                 case 2 :
   1621                     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:87:7: INT
   1622                     {
   1623                     root_0 = (Object)adaptor.nil();
   1624 
   1625                     INT50=(Token)match(input,INT,FOLLOW_INT_in_atom694);
   1626                     INT50_tree = (Object)adaptor.create(INT50);
   1627                     adaptor.addChild(root_0, INT50_tree);
   1628 
   1629 
   1630                     }
   1631                     break;
   1632                 case 3 :
   1633                     // /usr/local/ANTLR3-ObjC2.0-Runtime/Framework/examples/simplecTreeParser/SimpleC.g:88:7: '(' expr ')'
   1634                     {
   1635                     char_literal51=(Token)match(input,22,FOLLOW_22_in_atom708);
   1636                     stream_22.add(char_literal51);
   1637 
   1638                     pushFollow(FOLLOW_expr_in_atom710);
   1639                     expr52=expr();
   1640 
   1641                     state._fsp--;
   1642 
   1643                     stream_expr.add(expr52.getTree());
   1644                     char_literal53=(Token)match(input,24,FOLLOW_24_in_atom712);
   1645                     stream_24.add(char_literal53);
   1646 
   1647 
   1648 
   1649                     // AST REWRITE
   1650                     // elements: expr
   1651                     // token labels:
   1652                     // rule labels: retval
   1653                     // token list labels:
   1654                     // rule list labels:
   1655                     // wildcard labels:
   1656                     retval.tree = root_0;
   1657                     RewriteRuleSubtreeStream stream_retval=new RewriteRuleSubtreeStream(adaptor,"rule retval",retval!=null?retval.tree:null);
   1658 
   1659                     root_0 = (Object)adaptor.nil();
   1660                     // 88:20: -> expr
   1661                     {
   1662                         adaptor.addChild(root_0, stream_expr.nextTree());
   1663 
   1664                     }
   1665 
   1666                     retval.tree = root_0;
   1667                     }
   1668                     break;
   1669 
   1670             }
   1671             retval.stop = input.LT(-1);
   1672 
   1673             retval.tree = (Object)adaptor.rulePostProcessing(root_0);
   1674             adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);
   1675 
   1676         }
   1677         catch (RecognitionException re) {
   1678             reportError(re);
   1679             recover(input,re);
   1680     	retval.tree = (Object)adaptor.errorNode(input, retval.start, input.LT(-1), re);
   1681 
   1682         }
   1683         finally {
   1684         }
   1685         return retval;
   1686     }
   1687     // $ANTLR end "atom"
   1688 
   1689     // Delegated rules
   1690 
   1691 
   1692     protected DFA2 dfa2 = new DFA2(this);
   1693     static final String DFA2_eotS =
   1694         "\15\uffff";
   1695     static final String DFA2_eofS =
   1696         "\15\uffff";
   1697     static final String DFA2_minS =
   1698         "\2\12\1\25\1\12\1\uffff\1\12\1\25\1\27\2\uffff\2\12\1\27";
   1699     static final String DFA2_maxS =
   1700         "\1\20\1\12\1\26\1\30\1\uffff\1\12\1\31\1\30\2\uffff\1\20\1\12\1"+
   1701         "\30";
   1702     static final String DFA2_acceptS =
   1703         "\4\uffff\1\1\3\uffff\1\3\1\2\3\uffff";
   1704     static final String DFA2_specialS =
   1705         "\15\uffff}>";
   1706     static final String[] DFA2_transitionS = {
   1707             "\1\1\3\uffff\3\1",
   1708             "\1\2",
   1709             "\1\4\1\3",
   1710             "\1\5\3\uffff\3\5\7\uffff\1\6",
   1711             "",
   1712             "\1\7",
   1713             "\1\11\3\uffff\1\10",
   1714             "\1\12\1\6",
   1715             "",
   1716             "",
   1717             "\1\13\3\uffff\3\13",
   1718             "\1\14",
   1719             "\1\12\1\6"
   1720     };
   1721 
   1722     static final short[] DFA2_eot = DFA.unpackEncodedString(DFA2_eotS);
   1723     static final short[] DFA2_eof = DFA.unpackEncodedString(DFA2_eofS);
   1724     static final char[] DFA2_min = DFA.unpackEncodedStringToUnsignedChars(DFA2_minS);
   1725     static final char[] DFA2_max = DFA.unpackEncodedStringToUnsignedChars(DFA2_maxS);
   1726     static final short[] DFA2_accept = DFA.unpackEncodedString(DFA2_acceptS);
   1727     static final short[] DFA2_special = DFA.unpackEncodedString(DFA2_specialS);
   1728     static final short[][] DFA2_transition;
   1729 
   1730     static {
   1731         int numStates = DFA2_transitionS.length;
   1732         DFA2_transition = new short[numStates][];
   1733         for (int i=0; i<numStates; i++) {
   1734             DFA2_transition[i] = DFA.unpackEncodedString(DFA2_transitionS[i]);
   1735         }
   1736     }
   1737 
   1738     class DFA2 extends DFA {
   1739 
   1740         public DFA2(BaseRecognizer recognizer) {
   1741             this.recognizer = recognizer;
   1742             this.decisionNumber = 2;
   1743             this.eot = DFA2_eot;
   1744             this.eof = DFA2_eof;
   1745             this.min = DFA2_min;
   1746             this.max = DFA2_max;
   1747             this.accept = DFA2_accept;
   1748             this.special = DFA2_special;
   1749             this.transition = DFA2_transition;
   1750         }
   1751         public String getDescription() {
   1752             return "20:1: declaration : ( variable | functionHeader ';' -> ^( FUNC_DECL functionHeader ) | functionHeader block -> ^( FUNC_DEF functionHeader block ) );";
   1753         }
   1754     }
   1755 
   1756 
   1757     public static final BitSet FOLLOW_declaration_in_program85 = new BitSet(new long[]{0x000000000001C402L});
   1758     public static final BitSet FOLLOW_variable_in_declaration105 = new BitSet(new long[]{0x0000000000000002L});
   1759     public static final BitSet FOLLOW_functionHeader_in_declaration115 = new BitSet(new long[]{0x0000000000200000L});
   1760     public static final BitSet FOLLOW_21_in_declaration117 = new BitSet(new long[]{0x0000000000000002L});
   1761     public static final BitSet FOLLOW_functionHeader_in_declaration135 = new BitSet(new long[]{0x0000000002000000L});
   1762     public static final BitSet FOLLOW_block_in_declaration137 = new BitSet(new long[]{0x0000000000000002L});
   1763     public static final BitSet FOLLOW_type_in_variable166 = new BitSet(new long[]{0x0000000000000400L});
   1764     public static final BitSet FOLLOW_declarator_in_variable168 = new BitSet(new long[]{0x0000000000200000L});
   1765     public static final BitSet FOLLOW_21_in_variable170 = new BitSet(new long[]{0x0000000000000002L});
   1766     public static final BitSet FOLLOW_ID_in_declarator199 = new BitSet(new long[]{0x0000000000000002L});
   1767     public static final BitSet FOLLOW_type_in_functionHeader219 = new BitSet(new long[]{0x0000000000000400L});
   1768     public static final BitSet FOLLOW_ID_in_functionHeader221 = new BitSet(new long[]{0x0000000000400000L});
   1769     public static final BitSet FOLLOW_22_in_functionHeader223 = new BitSet(new long[]{0x000000000101C400L});
   1770     public static final BitSet FOLLOW_formalParameter_in_functionHeader227 = new BitSet(new long[]{0x0000000001800000L});
   1771     public static final BitSet FOLLOW_23_in_functionHeader231 = new BitSet(new long[]{0x000000000001C400L});
   1772     public static final BitSet FOLLOW_formalParameter_in_functionHeader233 = new BitSet(new long[]{0x0000000001800000L});
   1773     public static final BitSet FOLLOW_24_in_functionHeader241 = new BitSet(new long[]{0x0000000000000002L});
   1774     public static final BitSet FOLLOW_type_in_formalParameter281 = new BitSet(new long[]{0x0000000000000400L});
   1775     public static final BitSet FOLLOW_declarator_in_formalParameter283 = new BitSet(new long[]{0x0000000000000002L});
   1776     public static final BitSet FOLLOW_set_in_type0 = new BitSet(new long[]{0x0000000000000002L});
   1777     public static final BitSet FOLLOW_25_in_block376 = new BitSet(new long[]{0x000000000661F400L});
   1778     public static final BitSet FOLLOW_variable_in_block390 = new BitSet(new long[]{0x000000000661F400L});
   1779     public static final BitSet FOLLOW_stat_in_block405 = new BitSet(new long[]{0x0000000006603400L});
   1780     public static final BitSet FOLLOW_26_in_block416 = new BitSet(new long[]{0x0000000000000002L});
   1781     public static final BitSet FOLLOW_forStat_in_stat449 = new BitSet(new long[]{0x0000000000000002L});
   1782     public static final BitSet FOLLOW_expr_in_stat457 = new BitSet(new long[]{0x0000000000200000L});
   1783     public static final BitSet FOLLOW_21_in_stat459 = new BitSet(new long[]{0x0000000000000002L});
   1784     public static final BitSet FOLLOW_block_in_stat468 = new BitSet(new long[]{0x0000000000000002L});
   1785     public static final BitSet FOLLOW_assignStat_in_stat476 = new BitSet(new long[]{0x0000000000200000L});
   1786     public static final BitSet FOLLOW_21_in_stat478 = new BitSet(new long[]{0x0000000000000002L});
   1787     public static final BitSet FOLLOW_21_in_stat487 = new BitSet(new long[]{0x0000000000000002L});
   1788     public static final BitSet FOLLOW_FOR_in_forStat507 = new BitSet(new long[]{0x0000000000400000L});
   1789     public static final BitSet FOLLOW_22_in_forStat509 = new BitSet(new long[]{0x0000000000000400L});
   1790     public static final BitSet FOLLOW_assignStat_in_forStat513 = new BitSet(new long[]{0x0000000000200000L});
   1791     public static final BitSet FOLLOW_21_in_forStat515 = new BitSet(new long[]{0x0000000000401400L});
   1792     public static final BitSet FOLLOW_expr_in_forStat517 = new BitSet(new long[]{0x0000000000200000L});
   1793     public static final BitSet FOLLOW_21_in_forStat519 = new BitSet(new long[]{0x0000000000000400L});
   1794     public static final BitSet FOLLOW_assignStat_in_forStat523 = new BitSet(new long[]{0x0000000001000000L});
   1795     public static final BitSet FOLLOW_24_in_forStat525 = new BitSet(new long[]{0x0000000002000000L});
   1796     public static final BitSet FOLLOW_block_in_forStat527 = new BitSet(new long[]{0x0000000000000002L});
   1797     public static final BitSet FOLLOW_ID_in_assignStat570 = new BitSet(new long[]{0x0000000000000800L});
   1798     public static final BitSet FOLLOW_EQ_in_assignStat572 = new BitSet(new long[]{0x0000000000401400L});
   1799     public static final BitSet FOLLOW_expr_in_assignStat574 = new BitSet(new long[]{0x0000000000000002L});
   1800     public static final BitSet FOLLOW_condExpr_in_expr598 = new BitSet(new long[]{0x0000000000000002L});
   1801     public static final BitSet FOLLOW_aexpr_in_condExpr617 = new BitSet(new long[]{0x0000000000060002L});
   1802     public static final BitSet FOLLOW_EQEQ_in_condExpr622 = new BitSet(new long[]{0x0000000000401400L});
   1803     public static final BitSet FOLLOW_LT_in_condExpr627 = new BitSet(new long[]{0x0000000000401400L});
   1804     public static final BitSet FOLLOW_aexpr_in_condExpr631 = new BitSet(new long[]{0x0000000000000002L});
   1805     public static final BitSet FOLLOW_atom_in_aexpr653 = new BitSet(new long[]{0x0000000000080002L});
   1806     public static final BitSet FOLLOW_PLUS_in_aexpr657 = new BitSet(new long[]{0x0000000000401400L});
   1807     public static final BitSet FOLLOW_atom_in_aexpr660 = new BitSet(new long[]{0x0000000000080002L});
   1808     public static final BitSet FOLLOW_ID_in_atom680 = new BitSet(new long[]{0x0000000000000002L});
   1809     public static final BitSet FOLLOW_INT_in_atom694 = new BitSet(new long[]{0x0000000000000002L});
   1810     public static final BitSet FOLLOW_22_in_atom708 = new BitSet(new long[]{0x0000000000401400L});
   1811     public static final BitSet FOLLOW_expr_in_atom710 = new BitSet(new long[]{0x0000000001000000L});
   1812     public static final BitSet FOLLOW_24_in_atom712 = new BitSet(new long[]{0x0000000000000002L});
   1813 
   1814 }