1// $ANTLR 3.2 Aug 13, 2010 14:19:31 SimpleC.g 2010-08-13 14:29:19
2
3import org.antlr.runtime.*;
4import java.util.Stack;
5import java.util.List;
6import java.util.ArrayList;
7
8
9import org.antlr.runtime.tree.*;
10
11public 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 "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    // 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            // SimpleC.g:17:5: ( ( declaration )+ )
84            // SimpleC.g:17:9: ( declaration )+
85            {
86            root_0 = (Object)adaptor.nil();
87
88            // 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            	    // 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    // 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            // 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                    // 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                    // 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                        // 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                    // 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: block, functionHeader
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                        // 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    // 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            // SimpleC.g:27:5: ( type declarator ';' -> ^( VAR_DEF type declarator ) )
323            // 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: declarator, type
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                // 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    // 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            // SimpleC.g:31:5: ( ID )
408            // 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    // 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            // SimpleC.g:35:5: ( type ID '(' ( formalParameter ( ',' formalParameter )* )? ')' -> ^( FUNC_HDR type ID ( formalParameter )+ ) )
473            // 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            // 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                    // 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                    // 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                    	    // 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: ID, formalParameter, 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                // 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    // 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            // SimpleC.g:40:5: ( type declarator -> ^( ARG_DEF type declarator ) )
625            // 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                // 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    // 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            // SimpleC.g:44:5: ( 'int' | 'char' | 'void' | ID )
707            // 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    // 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            // SimpleC.g:51:5: (lc= '{' ( variable )* ( stat )* '}' -> ^( BLOCK[$lc,@\"BLOCK\"] ( variable )* ( stat )* ) )
771            // 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            // 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            	    // 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            // 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            	    // 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: stat, variable
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                // 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                // 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                // 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    // 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            // 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                    // 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                    // 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                    // 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                    // 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                    // 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    // 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            // SimpleC.g:66:5: ( 'for' '(' start= assignStat ';' expr ';' next= assignStat ')' block -> ^( 'for' $start expr $next block ) )
1115            // 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: next, start, FOR, block, expr
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                // 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    // 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            // SimpleC.g:71:5: ( ID EQ expr -> ^( EQ ID expr ) )
1234            // 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, ID, expr
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                // 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    // 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            // SimpleC.g:74:5: ( condExpr )
1316            // 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    // 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            // SimpleC.g:78:5: ( aexpr ( ( '==' | '<' ) aexpr )? )
1372            // 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            // 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                    // SimpleC.g:78:17: ( '==' | '<' ) aexpr
1392                    {
1393                    // 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                            // 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                            // 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    // 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            // SimpleC.g:82:5: ( atom ( '+' atom )* )
1489            // 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            // 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            	    // 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    // 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            // 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                    // 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                    // 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                    // 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}