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