1/** \file
2 *  This OBJC source file was generated by $ANTLR version ${project.version} ${buildNumber}
3 *
4 *     -  From the grammar source file : SimpleC.g
5 *     -                            On : 2011-05-06 15:09:17
6 *     -                 for the lexer : SimpleCLexerLexer
7 *
8 * Editing it, at least manually, is not wise.
9 *
10 * ObjC language generator and runtime by Alan Condit, acondit|hereisanat|ipns|dotgoeshere|com.
11 *
12 *
13*/
14// $ANTLR ${project.version} ${buildNumber} SimpleC.g 2011-05-06 15:09:17
15
16
17/* -----------------------------------------
18 * Include the ANTLR3 generated header file.
19 */
20#import "SimpleCLexer.h"
21/* ----------------------------------------- */
22
23
24/* ============================================================================= */
25/* =============================================================================
26 * Start of recognizer
27 */
28
29/** As per Terence: No returns for lexer rules! */
30@implementation SimpleCLexer // line 330
31
32+ (void) initialize
33{
34    [ANTLRBaseRecognizer setGrammarFileName:@"SimpleC.g"];
35}
36
37+ (NSString *) tokenNameForType:(NSInteger)aTokenType
38{
39    return [[self getTokenNames] objectAtIndex:aTokenType];
40}
41
42+ (SimpleCLexer *)newSimpleCLexerWithCharStream:(id<ANTLRCharStream>)anInput
43{
44    return [[SimpleCLexer alloc] initWithCharStream:anInput];
45}
46
47- (id) initWithCharStream:(id<ANTLRCharStream>)anInput
48{
49    self = [super initWithCharStream:anInput State:[[ANTLRRecognizerSharedState newANTLRRecognizerSharedStateWithRuleLen:18+1] retain]];
50    if ( self != nil ) {
51    }
52    return self;
53}
54
55- (void) dealloc
56{
57    [super dealloc];
58}
59
60/* ObjC Start of actions.lexer.methods */
61/* ObjC end of actions.lexer.methods */
62/* ObjC start methods() */
63/* ObjC end methods() */
64
65/* Start of Rules */
66// $ANTLR start "K_FOR"
67- (void) mK_FOR
68{
69    //
70    /* my ruleScopeSetUp */
71    /* Terence's stuff */
72
73    @try {
74        NSInteger _type = K_FOR;
75        NSInteger _channel = ANTLRTokenChannelDefault;
76        // SimpleC.g:91:7: ( 'for' ) // ruleBlockSingleAlt
77        // SimpleC.g:91:9: 'for' // alt
78        {
79        [self matchString:@"for"];
80
81
82
83        }
84
85        // token+rule list labels
86
87        state.type = _type;
88        state.channel = _channel;
89    }
90    @finally {
91        //
92        /* Terence's stuff */
93
94    }
95    return;
96}
97/* $ANTLR end "K_FOR" */
98
99// $ANTLR start "K_CHAR"
100- (void) mK_CHAR
101{
102    //
103    /* my ruleScopeSetUp */
104    /* Terence's stuff */
105
106    @try {
107        NSInteger _type = K_CHAR;
108        NSInteger _channel = ANTLRTokenChannelDefault;
109        // SimpleC.g:92:7: ( 'char' ) // ruleBlockSingleAlt
110        // SimpleC.g:92:9: 'char' // alt
111        {
112        [self matchString:@"char"];
113
114
115
116        }
117
118        // token+rule list labels
119
120        state.type = _type;
121        state.channel = _channel;
122    }
123    @finally {
124        //
125        /* Terence's stuff */
126
127    }
128    return;
129}
130/* $ANTLR end "K_CHAR" */
131
132// $ANTLR start "K_INT_TYPE"
133- (void) mK_INT_TYPE
134{
135    //
136    /* my ruleScopeSetUp */
137    /* Terence's stuff */
138
139    @try {
140        NSInteger _type = K_INT_TYPE;
141        NSInteger _channel = ANTLRTokenChannelDefault;
142        // SimpleC.g:93:12: ( 'int' ) // ruleBlockSingleAlt
143        // SimpleC.g:93:14: 'int' // alt
144        {
145        [self matchString:@"int"];
146
147
148
149        }
150
151        // token+rule list labels
152
153        state.type = _type;
154        state.channel = _channel;
155    }
156    @finally {
157        //
158        /* Terence's stuff */
159
160    }
161    return;
162}
163/* $ANTLR end "K_INT_TYPE" */
164
165// $ANTLR start "K_VOID"
166- (void) mK_VOID
167{
168    //
169    /* my ruleScopeSetUp */
170    /* Terence's stuff */
171
172    @try {
173        NSInteger _type = K_VOID;
174        NSInteger _channel = ANTLRTokenChannelDefault;
175        // SimpleC.g:94:7: ( 'void' ) // ruleBlockSingleAlt
176        // SimpleC.g:94:9: 'void' // alt
177        {
178        [self matchString:@"void"];
179
180
181
182        }
183
184        // token+rule list labels
185
186        state.type = _type;
187        state.channel = _channel;
188    }
189    @finally {
190        //
191        /* Terence's stuff */
192
193    }
194    return;
195}
196/* $ANTLR end "K_VOID" */
197
198// $ANTLR start "K_ID"
199- (void) mK_ID
200{
201    //
202    /* my ruleScopeSetUp */
203    /* Terence's stuff */
204
205    @try {
206        NSInteger _type = K_ID;
207        NSInteger _channel = ANTLRTokenChannelDefault;
208        // SimpleC.g:96:7: ( ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* ) // ruleBlockSingleAlt
209        // SimpleC.g:96:11: ( 'a' .. 'z' | 'A' .. 'Z' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '0' .. '9' | '_' )* // alt
210        {
211        if ((([input LA:1] >= 'A') && ([input LA:1] <= 'Z'))||[input LA:1] == '_'||(([input LA:1] >= 'a') && ([input LA:1] <= 'z'))) {
212            [input consume];
213        } else {
214            ANTLRMismatchedSetException *mse = [ANTLRMismatchedSetException newException:nil stream:input];
215            [self recover:mse];
216            @throw mse;
217        }
218
219
220        do {
221            NSInteger alt1=2;
222            NSInteger LA1_0 = [input LA:1];
223            if ( ((LA1_0 >= '0' && LA1_0 <= '9')||(LA1_0 >= 'A' && LA1_0 <= 'Z')||LA1_0=='_'||(LA1_0 >= 'a' && LA1_0 <= 'z')) ) {
224                alt1=1;
225            }
226
227
228            switch (alt1) {
229                case 1 : ;
230                    // SimpleC.g: // alt
231                    {
232                    if ((([input LA:1] >= '0') && ([input LA:1] <= '9'))||(([input LA:1] >= 'A') && ([input LA:1] <= 'Z'))||[input LA:1] == '_'||(([input LA:1] >= 'a') && ([input LA:1] <= 'z'))) {
233                        [input consume];
234                    } else {
235                        ANTLRMismatchedSetException *mse = [ANTLRMismatchedSetException newException:nil stream:input];
236                        [self recover:mse];
237                        @throw mse;
238                    }
239
240
241                    }
242                    break;
243
244                default :
245                    goto loop1;
246            }
247        } while (YES);
248        loop1: ;
249
250
251        }
252
253        // token+rule list labels
254
255        state.type = _type;
256        state.channel = _channel;
257    }
258    @finally {
259        //
260        /* Terence's stuff */
261
262    }
263    return;
264}
265/* $ANTLR end "K_ID" */
266
267// $ANTLR start "K_INT"
268- (void) mK_INT
269{
270    //
271    /* my ruleScopeSetUp */
272    /* Terence's stuff */
273
274    @try {
275        NSInteger _type = K_INT;
276        NSInteger _channel = ANTLRTokenChannelDefault;
277        ANTLRCommonToken *anInt=nil;
278        AMutableArray *list_anInt=nil;
279        // SimpleC.g:99:7: ( (anInt+= ( '0' .. '9' ) )+ ) // ruleBlockSingleAlt
280        // SimpleC.g:99:9: (anInt+= ( '0' .. '9' ) )+ // alt
281        {
282        // SimpleC.g:99:14: (anInt+= ( '0' .. '9' ) )+ // positiveClosureBlock
283        NSInteger cnt2 = 0;
284        do {
285            NSInteger alt2 = 2;
286            NSInteger LA2_0 = [input LA:1];
287            if ( ((LA2_0 >= '0' && LA2_0 <= '9')) ) {
288                alt2=1;
289            }
290
291
292            switch (alt2) {
293                case 1 : ;
294                    // SimpleC.g:99:14: anInt+= ( '0' .. '9' ) // alt
295                    {
296                    anInt = [input LA:1];
297
298                    if ((([input LA:1] >= '0') && ([input LA:1] <= '9'))) {
299                        [input consume];
300                    } else {
301                        ANTLRMismatchedSetException *mse = [ANTLRMismatchedSetException newException:nil stream:input];
302                        mse.c = anInt;
303                        [self recover:mse];
304                        @throw mse;
305                    }
306
307
308                    }
309                    break;
310
311                default :
312                    if ( cnt2 >= 1 )
313                        goto loop2;
314                    ANTLREarlyExitException *eee =
315                        [ANTLREarlyExitException newException:input decisionNumber:2];
316                    @throw eee;
317            }
318            cnt2++;
319        } while (YES);
320        loop2: ;
321
322
323        NSLog(@"%@", list_anInt);
324
325
326        }
327
328        // token+rule list labels
329        [list_anInt release];
330
331        state.type = _type;
332        state.channel = _channel;
333    }
334    @finally {
335        //
336        /* Terence's stuff */
337
338    }
339    return;
340}
341/* $ANTLR end "K_INT" */
342
343// $ANTLR start "K_LCURVE"
344- (void) mK_LCURVE
345{
346    //
347    /* my ruleScopeSetUp */
348    /* Terence's stuff */
349
350    @try {
351        NSInteger _type = K_LCURVE;
352        NSInteger _channel = ANTLRTokenChannelDefault;
353        // SimpleC.g:102:10: ( '(' ) // ruleBlockSingleAlt
354        // SimpleC.g:102:12: '(' // alt
355        {
356        [self matchChar:'('];
357
358
359        }
360
361        // token+rule list labels
362
363        state.type = _type;
364        state.channel = _channel;
365    }
366    @finally {
367        //
368        /* Terence's stuff */
369
370    }
371    return;
372}
373/* $ANTLR end "K_LCURVE" */
374
375// $ANTLR start "K_RCURVE"
376- (void) mK_RCURVE
377{
378    //
379    /* my ruleScopeSetUp */
380    /* Terence's stuff */
381
382    @try {
383        NSInteger _type = K_RCURVE;
384        NSInteger _channel = ANTLRTokenChannelDefault;
385        // SimpleC.g:103:10: ( ')' ) // ruleBlockSingleAlt
386        // SimpleC.g:103:12: ')' // alt
387        {
388        [self matchChar:')'];
389
390
391        }
392
393        // token+rule list labels
394
395        state.type = _type;
396        state.channel = _channel;
397    }
398    @finally {
399        //
400        /* Terence's stuff */
401
402    }
403    return;
404}
405/* $ANTLR end "K_RCURVE" */
406
407// $ANTLR start "K_PLUS"
408- (void) mK_PLUS
409{
410    //
411    /* my ruleScopeSetUp */
412    /* Terence's stuff */
413
414    @try {
415        NSInteger _type = K_PLUS;
416        NSInteger _channel = ANTLRTokenChannelDefault;
417        // SimpleC.g:104:8: ( '+' ) // ruleBlockSingleAlt
418        // SimpleC.g:104:10: '+' // alt
419        {
420        [self matchChar:'+'];
421
422
423        }
424
425        // token+rule list labels
426
427        state.type = _type;
428        state.channel = _channel;
429    }
430    @finally {
431        //
432        /* Terence's stuff */
433
434    }
435    return;
436}
437/* $ANTLR end "K_PLUS" */
438
439// $ANTLR start "K_COMMA"
440- (void) mK_COMMA
441{
442    //
443    /* my ruleScopeSetUp */
444    /* Terence's stuff */
445
446    @try {
447        NSInteger _type = K_COMMA;
448        NSInteger _channel = ANTLRTokenChannelDefault;
449        // SimpleC.g:105:9: ( ',' ) // ruleBlockSingleAlt
450        // SimpleC.g:105:11: ',' // alt
451        {
452        [self matchChar:','];
453
454
455        }
456
457        // token+rule list labels
458
459        state.type = _type;
460        state.channel = _channel;
461    }
462    @finally {
463        //
464        /* Terence's stuff */
465
466    }
467    return;
468}
469/* $ANTLR end "K_COMMA" */
470
471// $ANTLR start "K_SEMICOLON"
472- (void) mK_SEMICOLON
473{
474    //
475    /* my ruleScopeSetUp */
476    /* Terence's stuff */
477
478    @try {
479        NSInteger _type = K_SEMICOLON;
480        NSInteger _channel = ANTLRTokenChannelDefault;
481        // SimpleC.g:106:13: ( ';' ) // ruleBlockSingleAlt
482        // SimpleC.g:106:15: ';' // alt
483        {
484        [self matchChar:';'];
485
486
487        }
488
489        // token+rule list labels
490
491        state.type = _type;
492        state.channel = _channel;
493    }
494    @finally {
495        //
496        /* Terence's stuff */
497
498    }
499    return;
500}
501/* $ANTLR end "K_SEMICOLON" */
502
503// $ANTLR start "K_LT"
504- (void) mK_LT
505{
506    //
507    /* my ruleScopeSetUp */
508    /* Terence's stuff */
509
510    @try {
511        NSInteger _type = K_LT;
512        NSInteger _channel = ANTLRTokenChannelDefault;
513        // SimpleC.g:107:8: ( '<' ) // ruleBlockSingleAlt
514        // SimpleC.g:107:10: '<' // alt
515        {
516        [self matchChar:'<'];
517
518
519        }
520
521        // token+rule list labels
522
523        state.type = _type;
524        state.channel = _channel;
525    }
526    @finally {
527        //
528        /* Terence's stuff */
529
530    }
531    return;
532}
533/* $ANTLR end "K_LT" */
534
535// $ANTLR start "K_EQ"
536- (void) mK_EQ
537{
538    //
539    /* my ruleScopeSetUp */
540    /* Terence's stuff */
541
542    @try {
543        NSInteger _type = K_EQ;
544        NSInteger _channel = ANTLRTokenChannelDefault;
545        // SimpleC.g:108:8: ( '=' ) // ruleBlockSingleAlt
546        // SimpleC.g:108:10: '=' // alt
547        {
548        [self matchChar:'='];
549
550
551        }
552
553        // token+rule list labels
554
555        state.type = _type;
556        state.channel = _channel;
557    }
558    @finally {
559        //
560        /* Terence's stuff */
561
562    }
563    return;
564}
565/* $ANTLR end "K_EQ" */
566
567// $ANTLR start "K_EQEQ"
568- (void) mK_EQEQ
569{
570    //
571    /* my ruleScopeSetUp */
572    /* Terence's stuff */
573
574    @try {
575        NSInteger _type = K_EQEQ;
576        NSInteger _channel = ANTLRTokenChannelDefault;
577        // SimpleC.g:109:8: ( '==' ) // ruleBlockSingleAlt
578        // SimpleC.g:109:10: '==' // alt
579        {
580        [self matchString:@"=="];
581
582
583
584        }
585
586        // token+rule list labels
587
588        state.type = _type;
589        state.channel = _channel;
590    }
591    @finally {
592        //
593        /* Terence's stuff */
594
595    }
596    return;
597}
598/* $ANTLR end "K_EQEQ" */
599
600// $ANTLR start "K_LCURLY"
601- (void) mK_LCURLY
602{
603    //
604    /* my ruleScopeSetUp */
605    /* Terence's stuff */
606
607    @try {
608        NSInteger _type = K_LCURLY;
609        NSInteger _channel = ANTLRTokenChannelDefault;
610        // SimpleC.g:110:10: ( '{' ) // ruleBlockSingleAlt
611        // SimpleC.g:110:12: '{' // alt
612        {
613        [self matchChar:'{'];
614
615
616        }
617
618        // token+rule list labels
619
620        state.type = _type;
621        state.channel = _channel;
622    }
623    @finally {
624        //
625        /* Terence's stuff */
626
627    }
628    return;
629}
630/* $ANTLR end "K_LCURLY" */
631
632// $ANTLR start "K_RCURLY"
633- (void) mK_RCURLY
634{
635    //
636    /* my ruleScopeSetUp */
637    /* Terence's stuff */
638
639    @try {
640        NSInteger _type = K_RCURLY;
641        NSInteger _channel = ANTLRTokenChannelDefault;
642        // SimpleC.g:111:10: ( '}' ) // ruleBlockSingleAlt
643        // SimpleC.g:111:12: '}' // alt
644        {
645        [self matchChar:'}'];
646
647
648        }
649
650        // token+rule list labels
651
652        state.type = _type;
653        state.channel = _channel;
654    }
655    @finally {
656        //
657        /* Terence's stuff */
658
659    }
660    return;
661}
662/* $ANTLR end "K_RCURLY" */
663
664// $ANTLR start "WS"
665- (void) mWS
666{
667    //
668    /* my ruleScopeSetUp */
669    /* Terence's stuff */
670
671    @try {
672        NSInteger _type = WS;
673        NSInteger _channel = ANTLRTokenChannelDefault;
674        // SimpleC.g:113:5: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ ) // ruleBlockSingleAlt
675        // SimpleC.g:113:9: ( ' ' | '\\t' | '\\r' | '\\n' )+ // alt
676        {
677        // SimpleC.g:113:9: ( ' ' | '\\t' | '\\r' | '\\n' )+ // positiveClosureBlock
678        NSInteger cnt3 = 0;
679        do {
680            NSInteger alt3 = 2;
681            NSInteger LA3_0 = [input LA:1];
682            if ( ((LA3_0 >= '\t' && LA3_0 <= '\n')||LA3_0=='\r'||LA3_0==' ') ) {
683                alt3=1;
684            }
685
686
687            switch (alt3) {
688                case 1 : ;
689                    // SimpleC.g: // alt
690                    {
691                    if ((([input LA:1] >= '\t') && ([input LA:1] <= '\n'))||[input LA:1] == '\r'||[input LA:1] == ' ') {
692                        [input consume];
693                    } else {
694                        ANTLRMismatchedSetException *mse = [ANTLRMismatchedSetException newException:nil stream:input];
695                        [self recover:mse];
696                        @throw mse;
697                    }
698
699
700                    }
701                    break;
702
703                default :
704                    if ( cnt3 >= 1 )
705                        goto loop3;
706                    ANTLREarlyExitException *eee =
707                        [ANTLREarlyExitException newException:input decisionNumber:3];
708                    @throw eee;
709            }
710            cnt3++;
711        } while (YES);
712        loop3: ;
713
714
715         _channel=HIDDEN;
716
717
718        }
719
720        // token+rule list labels
721
722        state.type = _type;
723        state.channel = _channel;
724    }
725    @finally {
726        //
727        /* Terence's stuff */
728
729    }
730    return;
731}
732/* $ANTLR end "WS" */
733
734- (void) mTokens
735{
736    // SimpleC.g:1:8: ( K_FOR | K_CHAR | K_INT_TYPE | K_VOID | K_ID | K_INT | K_LCURVE | K_RCURVE | K_PLUS | K_COMMA | K_SEMICOLON | K_LT | K_EQ | K_EQEQ | K_LCURLY | K_RCURLY | WS ) //ruleblock
737    NSInteger alt4=17;
738    unichar charLA4 = [input LA:1];
739    switch (charLA4) {
740        case 'f': ;
741            {
742            NSInteger LA4_1 = [input LA:2];
743
744            if ( (LA4_1=='o') ) {
745                NSInteger LA4_17 = [input LA:3];
746
747                if ( (LA4_17=='r') ) {
748                    NSInteger LA4_23 = [input LA:4];
749
750                    if ( ((LA4_23 >= '0' && LA4_23 <= '9')||(LA4_23 >= 'A' && LA4_23 <= 'Z')||LA4_23=='_'||(LA4_23 >= 'a' && LA4_23 <= 'z')) ) {
751                        alt4=5;
752                    }
753                    else {
754                        alt4 = 1;
755                    }
756                }
757                else {
758                    alt4 = 5;
759                }
760            }
761            else {
762                alt4 = 5;
763            }
764            }
765            break;
766        case 'c': ;
767            {
768            NSInteger LA4_2 = [input LA:2];
769
770            if ( (LA4_2=='h') ) {
771                NSInteger LA4_18 = [input LA:3];
772
773                if ( (LA4_18=='a') ) {
774                    NSInteger LA4_24 = [input LA:4];
775
776                    if ( (LA4_24=='r') ) {
777                        NSInteger LA4_28 = [input LA:5];
778
779                        if ( ((LA4_28 >= '0' && LA4_28 <= '9')||(LA4_28 >= 'A' && LA4_28 <= 'Z')||LA4_28=='_'||(LA4_28 >= 'a' && LA4_28 <= 'z')) ) {
780                            alt4=5;
781                        }
782                        else {
783                            alt4 = 2;
784                        }
785                    }
786                    else {
787                        alt4 = 5;
788                    }
789                }
790                else {
791                    alt4 = 5;
792                }
793            }
794            else {
795                alt4 = 5;
796            }
797            }
798            break;
799        case 'i': ;
800            {
801            NSInteger LA4_3 = [input LA:2];
802
803            if ( (LA4_3=='n') ) {
804                NSInteger LA4_19 = [input LA:3];
805
806                if ( (LA4_19=='t') ) {
807                    NSInteger LA4_25 = [input LA:4];
808
809                    if ( ((LA4_25 >= '0' && LA4_25 <= '9')||(LA4_25 >= 'A' && LA4_25 <= 'Z')||LA4_25=='_'||(LA4_25 >= 'a' && LA4_25 <= 'z')) ) {
810                        alt4=5;
811                    }
812                    else {
813                        alt4 = 3;
814                    }
815                }
816                else {
817                    alt4 = 5;
818                }
819            }
820            else {
821                alt4 = 5;
822            }
823            }
824            break;
825        case 'v': ;
826            {
827            NSInteger LA4_4 = [input LA:2];
828
829            if ( (LA4_4=='o') ) {
830                NSInteger LA4_20 = [input LA:3];
831
832                if ( (LA4_20=='i') ) {
833                    NSInteger LA4_26 = [input LA:4];
834
835                    if ( (LA4_26=='d') ) {
836                        NSInteger LA4_30 = [input LA:5];
837
838                        if ( ((LA4_30 >= '0' && LA4_30 <= '9')||(LA4_30 >= 'A' && LA4_30 <= 'Z')||LA4_30=='_'||(LA4_30 >= 'a' && LA4_30 <= 'z')) ) {
839                            alt4=5;
840                        }
841                        else {
842                            alt4 = 4;
843                        }
844                    }
845                    else {
846                        alt4 = 5;
847                    }
848                }
849                else {
850                    alt4 = 5;
851                }
852            }
853            else {
854                alt4 = 5;
855            }
856            }
857            break;
858        case 'A': ;
859        case 'B': ;
860        case 'C': ;
861        case 'D': ;
862        case 'E': ;
863        case 'F': ;
864        case 'G': ;
865        case 'H': ;
866        case 'I': ;
867        case 'J': ;
868        case 'K': ;
869        case 'L': ;
870        case 'M': ;
871        case 'N': ;
872        case 'O': ;
873        case 'P': ;
874        case 'Q': ;
875        case 'R': ;
876        case 'S': ;
877        case 'T': ;
878        case 'U': ;
879        case 'V': ;
880        case 'W': ;
881        case 'X': ;
882        case 'Y': ;
883        case 'Z': ;
884        case '_': ;
885        case 'a': ;
886        case 'b': ;
887        case 'd': ;
888        case 'e': ;
889        case 'g': ;
890        case 'h': ;
891        case 'j': ;
892        case 'k': ;
893        case 'l': ;
894        case 'm': ;
895        case 'n': ;
896        case 'o': ;
897        case 'p': ;
898        case 'q': ;
899        case 'r': ;
900        case 's': ;
901        case 't': ;
902        case 'u': ;
903        case 'w': ;
904        case 'x': ;
905        case 'y': ;
906        case 'z': ;
907            {
908            alt4=5;
909            }
910            break;
911        case '0': ;
912        case '1': ;
913        case '2': ;
914        case '3': ;
915        case '4': ;
916        case '5': ;
917        case '6': ;
918        case '7': ;
919        case '8': ;
920        case '9': ;
921            {
922            alt4=6;
923            }
924            break;
925        case '(': ;
926            {
927            alt4=7;
928            }
929            break;
930        case ')': ;
931            {
932            alt4=8;
933            }
934            break;
935        case '+': ;
936            {
937            alt4=9;
938            }
939            break;
940        case ',': ;
941            {
942            alt4=10;
943            }
944            break;
945        case ';': ;
946            {
947            alt4=11;
948            }
949            break;
950        case '<': ;
951            {
952            alt4=12;
953            }
954            break;
955        case '=': ;
956            {
957            NSInteger LA4_13 = [input LA:2];
958
959            if ( (LA4_13=='=') ) {
960                alt4=14;
961            }
962            else {
963                alt4 = 13;
964            }
965            }
966            break;
967        case '{': ;
968            {
969            alt4=15;
970            }
971            break;
972        case '}': ;
973            {
974            alt4=16;
975            }
976            break;
977        case '\t': ;
978        case '\n': ;
979        case '\r': ;
980        case ' ': ;
981            {
982            alt4=17;
983            }
984            break;
985
986    default: ;
987        ANTLRNoViableAltException *nvae = [ANTLRNoViableAltException newException:4 state:0 stream:input];
988        nvae.c = charLA4;
989        @throw nvae;
990
991    }
992
993    switch (alt4) {
994        case 1 : ;
995            // SimpleC.g:1:10: K_FOR // alt
996            {
997            [self mK_FOR];
998
999
1000
1001            }
1002            break;
1003        case 2 : ;
1004            // SimpleC.g:1:16: K_CHAR // alt
1005            {
1006            [self mK_CHAR];
1007
1008
1009
1010            }
1011            break;
1012        case 3 : ;
1013            // SimpleC.g:1:23: K_INT_TYPE // alt
1014            {
1015            [self mK_INT_TYPE];
1016
1017
1018
1019            }
1020            break;
1021        case 4 : ;
1022            // SimpleC.g:1:34: K_VOID // alt
1023            {
1024            [self mK_VOID];
1025
1026
1027
1028            }
1029            break;
1030        case 5 : ;
1031            // SimpleC.g:1:41: K_ID // alt
1032            {
1033            [self mK_ID];
1034
1035
1036
1037            }
1038            break;
1039        case 6 : ;
1040            // SimpleC.g:1:46: K_INT // alt
1041            {
1042            [self mK_INT];
1043
1044
1045
1046            }
1047            break;
1048        case 7 : ;
1049            // SimpleC.g:1:52: K_LCURVE // alt
1050            {
1051            [self mK_LCURVE];
1052
1053
1054
1055            }
1056            break;
1057        case 8 : ;
1058            // SimpleC.g:1:61: K_RCURVE // alt
1059            {
1060            [self mK_RCURVE];
1061
1062
1063
1064            }
1065            break;
1066        case 9 : ;
1067            // SimpleC.g:1:70: K_PLUS // alt
1068            {
1069            [self mK_PLUS];
1070
1071
1072
1073            }
1074            break;
1075        case 10 : ;
1076            // SimpleC.g:1:77: K_COMMA // alt
1077            {
1078            [self mK_COMMA];
1079
1080
1081
1082            }
1083            break;
1084        case 11 : ;
1085            // SimpleC.g:1:85: K_SEMICOLON // alt
1086            {
1087            [self mK_SEMICOLON];
1088
1089
1090
1091            }
1092            break;
1093        case 12 : ;
1094            // SimpleC.g:1:97: K_LT // alt
1095            {
1096            [self mK_LT];
1097
1098
1099
1100            }
1101            break;
1102        case 13 : ;
1103            // SimpleC.g:1:102: K_EQ // alt
1104            {
1105            [self mK_EQ];
1106
1107
1108
1109            }
1110            break;
1111        case 14 : ;
1112            // SimpleC.g:1:107: K_EQEQ // alt
1113            {
1114            [self mK_EQEQ];
1115
1116
1117
1118            }
1119            break;
1120        case 15 : ;
1121            // SimpleC.g:1:114: K_LCURLY // alt
1122            {
1123            [self mK_LCURLY];
1124
1125
1126
1127            }
1128            break;
1129        case 16 : ;
1130            // SimpleC.g:1:123: K_RCURLY // alt
1131            {
1132            [self mK_RCURLY];
1133
1134
1135
1136            }
1137            break;
1138        case 17 : ;
1139            // SimpleC.g:1:132: WS // alt
1140            {
1141            [self mWS];
1142
1143
1144
1145            }
1146            break;
1147
1148    }
1149
1150}
1151
1152@end /* end of SimpleCLexer implementation line 397 */