ECC: CParser remove \ in string.
[people/mcb30/basetools.git] / Source / Python / Ecc / CLexer.py
1 # $ANTLR 3.0.1 C.g 2008-01-28 16:35:59
2
3 from antlr3 import *
4 from antlr3.compat import set, frozenset
5
6
7 # for convenience in actions
8 HIDDEN = BaseRecognizer.HIDDEN
9
10 # token types
11 T29=29
12 HexDigit=13
13 T70=70
14 T74=74
15 T85=85
16 T102=102
17 T103=103
18 STRING_LITERAL=9
19 T32=32
20 T81=81
21 T41=41
22 FloatTypeSuffix=16
23 T62=62
24 T109=109
25 DECIMAL_LITERAL=7
26 IntegerTypeSuffix=14
27 T68=68
28 T73=73
29 T84=84
30 T33=33
31 UnicodeVocabulary=21
32 T78=78
33 WS=19
34 LINE_COMMAND=24
35 T42=42
36 T96=96
37 T71=71
38 LINE_COMMENT=23
39 T72=72
40 T94=94
41 FLOATING_POINT_LITERAL=10
42 T76=76
43 UnicodeEscape=18
44 T75=75
45 T89=89
46 T67=67
47 T31=31
48 T60=60
49 T82=82
50 T100=100
51 T49=49
52 IDENTIFIER=4
53 T30=30
54 CHARACTER_LITERAL=8
55 T79=79
56 T36=36
57 T58=58
58 T93=93
59 T35=35
60 T107=107
61 OCTAL_LITERAL=6
62 T83=83
63 T61=61
64 HEX_LITERAL=5
65 T45=45
66 T34=34
67 T101=101
68 T64=64
69 T25=25
70 T91=91
71 T105=105
72 T37=37
73 T86=86
74 EscapeSequence=12
75 T26=26
76 T51=51
77 T46=46
78 T77=77
79 T38=38
80 T106=106
81 T69=69
82 T39=39
83 T44=44
84 T55=55
85 LETTER=11
86 Exponent=15
87 T95=95
88 T50=50
89 T108=108
90 BS=20
91 T92=92
92 T43=43
93 T28=28
94 T40=40
95 T66=66
96 COMMENT=22
97 T88=88
98 T63=63
99 T57=57
100 T65=65
101 T98=98
102 T56=56
103 T87=87
104 T80=80
105 T59=59
106 T97=97
107 T48=48
108 T54=54
109 EOF=-1
110 T104=104
111 T47=47
112 Tokens=110
113 T53=53
114 OctalEscape=17
115 T99=99
116 T27=27
117 T52=52
118 T90=90
119
120 class CLexer(Lexer):
121
122     grammarFileName = "C.g"
123
124     def __init__(self, input=None):
125         Lexer.__init__(self, input)
126         self.dfa28 = self.DFA28(
127             self, 28,
128             eot = self.DFA28_eot,
129             eof = self.DFA28_eof,
130             min = self.DFA28_min,
131             max = self.DFA28_max,
132             accept = self.DFA28_accept,
133             special = self.DFA28_special,
134             transition = self.DFA28_transition
135             )
136         self.dfa38 = self.DFA38(
137             self, 38,
138             eot = self.DFA38_eot,
139             eof = self.DFA38_eof,
140             min = self.DFA38_min,
141             max = self.DFA38_max,
142             accept = self.DFA38_accept,
143             special = self.DFA38_special,
144             transition = self.DFA38_transition
145             )
146
147
148
149
150
151
152     # $ANTLR start T25
153     def mT25(self, ):
154
155         try:
156             self.type = T25
157
158             # C.g:7:5: ( ';' )
159             # C.g:7:7: ';'
160             self.match(u';')
161
162
163
164
165
166         finally:
167
168             pass
169
170     # $ANTLR end T25
171
172
173
174     # $ANTLR start T26
175     def mT26(self, ):
176
177         try:
178             self.type = T26
179
180             # C.g:8:5: ( 'typedef' )
181             # C.g:8:7: 'typedef'
182             self.match("typedef")
183
184
185
186
187
188
189         finally:
190
191             pass
192
193     # $ANTLR end T26
194
195
196
197     # $ANTLR start T27
198     def mT27(self, ):
199
200         try:
201             self.type = T27
202
203             # C.g:9:5: ( ',' )
204             # C.g:9:7: ','
205             self.match(u',')
206
207
208
209
210
211         finally:
212
213             pass
214
215     # $ANTLR end T27
216
217
218
219     # $ANTLR start T28
220     def mT28(self, ):
221
222         try:
223             self.type = T28
224
225             # C.g:10:5: ( '=' )
226             # C.g:10:7: '='
227             self.match(u'=')
228
229
230
231
232
233         finally:
234
235             pass
236
237     # $ANTLR end T28
238
239
240
241     # $ANTLR start T29
242     def mT29(self, ):
243
244         try:
245             self.type = T29
246
247             # C.g:11:5: ( 'extern' )
248             # C.g:11:7: 'extern'
249             self.match("extern")
250
251
252
253
254
255
256         finally:
257
258             pass
259
260     # $ANTLR end T29
261
262
263
264     # $ANTLR start T30
265     def mT30(self, ):
266
267         try:
268             self.type = T30
269
270             # C.g:12:5: ( 'static' )
271             # C.g:12:7: 'static'
272             self.match("static")
273
274
275
276
277
278
279         finally:
280
281             pass
282
283     # $ANTLR end T30
284
285
286
287     # $ANTLR start T31
288     def mT31(self, ):
289
290         try:
291             self.type = T31
292
293             # C.g:13:5: ( 'auto' )
294             # C.g:13:7: 'auto'
295             self.match("auto")
296
297
298
299
300
301
302         finally:
303
304             pass
305
306     # $ANTLR end T31
307
308
309
310     # $ANTLR start T32
311     def mT32(self, ):
312
313         try:
314             self.type = T32
315
316             # C.g:14:5: ( 'register' )
317             # C.g:14:7: 'register'
318             self.match("register")
319
320
321
322
323
324
325         finally:
326
327             pass
328
329     # $ANTLR end T32
330
331
332
333     # $ANTLR start T33
334     def mT33(self, ):
335
336         try:
337             self.type = T33
338
339             # C.g:15:5: ( 'STATIC' )
340             # C.g:15:7: 'STATIC'
341             self.match("STATIC")
342
343
344
345
346
347
348         finally:
349
350             pass
351
352     # $ANTLR end T33
353
354
355
356     # $ANTLR start T34
357     def mT34(self, ):
358
359         try:
360             self.type = T34
361
362             # C.g:16:5: ( 'void' )
363             # C.g:16:7: 'void'
364             self.match("void")
365
366
367
368
369
370
371         finally:
372
373             pass
374
375     # $ANTLR end T34
376
377
378
379     # $ANTLR start T35
380     def mT35(self, ):
381
382         try:
383             self.type = T35
384
385             # C.g:17:5: ( 'char' )
386             # C.g:17:7: 'char'
387             self.match("char")
388
389
390
391
392
393
394         finally:
395
396             pass
397
398     # $ANTLR end T35
399
400
401
402     # $ANTLR start T36
403     def mT36(self, ):
404
405         try:
406             self.type = T36
407
408             # C.g:18:5: ( 'short' )
409             # C.g:18:7: 'short'
410             self.match("short")
411
412
413
414
415
416
417         finally:
418
419             pass
420
421     # $ANTLR end T36
422
423
424
425     # $ANTLR start T37
426     def mT37(self, ):
427
428         try:
429             self.type = T37
430
431             # C.g:19:5: ( 'int' )
432             # C.g:19:7: 'int'
433             self.match("int")
434
435
436
437
438
439
440         finally:
441
442             pass
443
444     # $ANTLR end T37
445
446
447
448     # $ANTLR start T38
449     def mT38(self, ):
450
451         try:
452             self.type = T38
453
454             # C.g:20:5: ( 'long' )
455             # C.g:20:7: 'long'
456             self.match("long")
457
458
459
460
461
462
463         finally:
464
465             pass
466
467     # $ANTLR end T38
468
469
470
471     # $ANTLR start T39
472     def mT39(self, ):
473
474         try:
475             self.type = T39
476
477             # C.g:21:5: ( 'float' )
478             # C.g:21:7: 'float'
479             self.match("float")
480
481
482
483
484
485
486         finally:
487
488             pass
489
490     # $ANTLR end T39
491
492
493
494     # $ANTLR start T40
495     def mT40(self, ):
496
497         try:
498             self.type = T40
499
500             # C.g:22:5: ( 'double' )
501             # C.g:22:7: 'double'
502             self.match("double")
503
504
505
506
507
508
509         finally:
510
511             pass
512
513     # $ANTLR end T40
514
515
516
517     # $ANTLR start T41
518     def mT41(self, ):
519
520         try:
521             self.type = T41
522
523             # C.g:23:5: ( 'signed' )
524             # C.g:23:7: 'signed'
525             self.match("signed")
526
527
528
529
530
531
532         finally:
533
534             pass
535
536     # $ANTLR end T41
537
538
539
540     # $ANTLR start T42
541     def mT42(self, ):
542
543         try:
544             self.type = T42
545
546             # C.g:24:5: ( 'unsigned' )
547             # C.g:24:7: 'unsigned'
548             self.match("unsigned")
549
550
551
552
553
554
555         finally:
556
557             pass
558
559     # $ANTLR end T42
560
561
562
563     # $ANTLR start T43
564     def mT43(self, ):
565
566         try:
567             self.type = T43
568
569             # C.g:25:5: ( 'BOOLEAN' )
570             # C.g:25:7: 'BOOLEAN'
571             self.match("BOOLEAN")
572
573
574
575
576
577
578         finally:
579
580             pass
581
582     # $ANTLR end T43
583
584
585
586     # $ANTLR start T44
587     def mT44(self, ):
588
589         try:
590             self.type = T44
591
592             # C.g:26:5: ( '{' )
593             # C.g:26:7: '{'
594             self.match(u'{')
595
596
597
598
599
600         finally:
601
602             pass
603
604     # $ANTLR end T44
605
606
607
608     # $ANTLR start T45
609     def mT45(self, ):
610
611         try:
612             self.type = T45
613
614             # C.g:27:5: ( '}' )
615             # C.g:27:7: '}'
616             self.match(u'}')
617
618
619
620
621
622         finally:
623
624             pass
625
626     # $ANTLR end T45
627
628
629
630     # $ANTLR start T46
631     def mT46(self, ):
632
633         try:
634             self.type = T46
635
636             # C.g:28:5: ( 'struct' )
637             # C.g:28:7: 'struct'
638             self.match("struct")
639
640
641
642
643
644
645         finally:
646
647             pass
648
649     # $ANTLR end T46
650
651
652
653     # $ANTLR start T47
654     def mT47(self, ):
655
656         try:
657             self.type = T47
658
659             # C.g:29:5: ( 'union' )
660             # C.g:29:7: 'union'
661             self.match("union")
662
663
664
665
666
667
668         finally:
669
670             pass
671
672     # $ANTLR end T47
673
674
675
676     # $ANTLR start T48
677     def mT48(self, ):
678
679         try:
680             self.type = T48
681
682             # C.g:30:5: ( ':' )
683             # C.g:30:7: ':'
684             self.match(u':')
685
686
687
688
689
690         finally:
691
692             pass
693
694     # $ANTLR end T48
695
696
697
698     # $ANTLR start T49
699     def mT49(self, ):
700
701         try:
702             self.type = T49
703
704             # C.g:31:5: ( 'enum' )
705             # C.g:31:7: 'enum'
706             self.match("enum")
707
708
709
710
711
712
713         finally:
714
715             pass
716
717     # $ANTLR end T49
718
719
720
721     # $ANTLR start T50
722     def mT50(self, ):
723
724         try:
725             self.type = T50
726
727             # C.g:32:5: ( 'const' )
728             # C.g:32:7: 'const'
729             self.match("const")
730
731
732
733
734
735
736         finally:
737
738             pass
739
740     # $ANTLR end T50
741
742
743
744     # $ANTLR start T51
745     def mT51(self, ):
746
747         try:
748             self.type = T51
749
750             # C.g:33:5: ( 'volatile' )
751             # C.g:33:7: 'volatile'
752             self.match("volatile")
753
754
755
756
757
758
759         finally:
760
761             pass
762
763     # $ANTLR end T51
764
765
766
767     # $ANTLR start T52
768     def mT52(self, ):
769
770         try:
771             self.type = T52
772
773             # C.g:34:5: ( 'IN' )
774             # C.g:34:7: 'IN'
775             self.match("IN")
776
777
778
779
780
781
782         finally:
783
784             pass
785
786     # $ANTLR end T52
787
788
789
790     # $ANTLR start T53
791     def mT53(self, ):
792
793         try:
794             self.type = T53
795
796             # C.g:35:5: ( 'OUT' )
797             # C.g:35:7: 'OUT'
798             self.match("OUT")
799
800
801
802
803
804
805         finally:
806
807             pass
808
809     # $ANTLR end T53
810
811
812
813     # $ANTLR start T54
814     def mT54(self, ):
815
816         try:
817             self.type = T54
818
819             # C.g:36:5: ( 'OPTIONAL' )
820             # C.g:36:7: 'OPTIONAL'
821             self.match("OPTIONAL")
822
823
824
825
826
827
828         finally:
829
830             pass
831
832     # $ANTLR end T54
833
834
835
836     # $ANTLR start T55
837     def mT55(self, ):
838
839         try:
840             self.type = T55
841
842             # C.g:37:5: ( 'CONST' )
843             # C.g:37:7: 'CONST'
844             self.match("CONST")
845
846
847
848
849
850
851         finally:
852
853             pass
854
855     # $ANTLR end T55
856
857
858
859     # $ANTLR start T56
860     def mT56(self, ):
861
862         try:
863             self.type = T56
864
865             # C.g:38:5: ( 'EFIAPI' )
866             # C.g:38:7: 'EFIAPI'
867             self.match("EFIAPI")
868
869
870
871
872
873
874         finally:
875
876             pass
877
878     # $ANTLR end T56
879
880
881
882     # $ANTLR start T57
883     def mT57(self, ):
884
885         try:
886             self.type = T57
887
888             # C.g:39:5: ( '(' )
889             # C.g:39:7: '('
890             self.match(u'(')
891
892
893
894
895
896         finally:
897
898             pass
899
900     # $ANTLR end T57
901
902
903
904     # $ANTLR start T58
905     def mT58(self, ):
906
907         try:
908             self.type = T58
909
910             # C.g:40:5: ( ')' )
911             # C.g:40:7: ')'
912             self.match(u')')
913
914
915
916
917
918         finally:
919
920             pass
921
922     # $ANTLR end T58
923
924
925
926     # $ANTLR start T59
927     def mT59(self, ):
928
929         try:
930             self.type = T59
931
932             # C.g:41:5: ( '[' )
933             # C.g:41:7: '['
934             self.match(u'[')
935
936
937
938
939
940         finally:
941
942             pass
943
944     # $ANTLR end T59
945
946
947
948     # $ANTLR start T60
949     def mT60(self, ):
950
951         try:
952             self.type = T60
953
954             # C.g:42:5: ( ']' )
955             # C.g:42:7: ']'
956             self.match(u']')
957
958
959
960
961
962         finally:
963
964             pass
965
966     # $ANTLR end T60
967
968
969
970     # $ANTLR start T61
971     def mT61(self, ):
972
973         try:
974             self.type = T61
975
976             # C.g:43:5: ( '*' )
977             # C.g:43:7: '*'
978             self.match(u'*')
979
980
981
982
983
984         finally:
985
986             pass
987
988     # $ANTLR end T61
989
990
991
992     # $ANTLR start T62
993     def mT62(self, ):
994
995         try:
996             self.type = T62
997
998             # C.g:44:5: ( '...' )
999             # C.g:44:7: '...'
1000             self.match("...")
1001
1002
1003
1004
1005
1006
1007         finally:
1008
1009             pass
1010
1011     # $ANTLR end T62
1012
1013
1014
1015     # $ANTLR start T63
1016     def mT63(self, ):
1017
1018         try:
1019             self.type = T63
1020
1021             # C.g:45:5: ( '+' )
1022             # C.g:45:7: '+'
1023             self.match(u'+')
1024
1025
1026
1027
1028
1029         finally:
1030
1031             pass
1032
1033     # $ANTLR end T63
1034
1035
1036
1037     # $ANTLR start T64
1038     def mT64(self, ):
1039
1040         try:
1041             self.type = T64
1042
1043             # C.g:46:5: ( '-' )
1044             # C.g:46:7: '-'
1045             self.match(u'-')
1046
1047
1048
1049
1050
1051         finally:
1052
1053             pass
1054
1055     # $ANTLR end T64
1056
1057
1058
1059     # $ANTLR start T65
1060     def mT65(self, ):
1061
1062         try:
1063             self.type = T65
1064
1065             # C.g:47:5: ( '/' )
1066             # C.g:47:7: '/'
1067             self.match(u'/')
1068
1069
1070
1071
1072
1073         finally:
1074
1075             pass
1076
1077     # $ANTLR end T65
1078
1079
1080
1081     # $ANTLR start T66
1082     def mT66(self, ):
1083
1084         try:
1085             self.type = T66
1086
1087             # C.g:48:5: ( '%' )
1088             # C.g:48:7: '%'
1089             self.match(u'%')
1090
1091
1092
1093
1094
1095         finally:
1096
1097             pass
1098
1099     # $ANTLR end T66
1100
1101
1102
1103     # $ANTLR start T67
1104     def mT67(self, ):
1105
1106         try:
1107             self.type = T67
1108
1109             # C.g:49:5: ( '++' )
1110             # C.g:49:7: '++'
1111             self.match("++")
1112
1113
1114
1115
1116
1117
1118         finally:
1119
1120             pass
1121
1122     # $ANTLR end T67
1123
1124
1125
1126     # $ANTLR start T68
1127     def mT68(self, ):
1128
1129         try:
1130             self.type = T68
1131
1132             # C.g:50:5: ( '--' )
1133             # C.g:50:7: '--'
1134             self.match("--")
1135
1136
1137
1138
1139
1140
1141         finally:
1142
1143             pass
1144
1145     # $ANTLR end T68
1146
1147
1148
1149     # $ANTLR start T69
1150     def mT69(self, ):
1151
1152         try:
1153             self.type = T69
1154
1155             # C.g:51:5: ( 'sizeof' )
1156             # C.g:51:7: 'sizeof'
1157             self.match("sizeof")
1158
1159
1160
1161
1162
1163
1164         finally:
1165
1166             pass
1167
1168     # $ANTLR end T69
1169
1170
1171
1172     # $ANTLR start T70
1173     def mT70(self, ):
1174
1175         try:
1176             self.type = T70
1177
1178             # C.g:52:5: ( '.' )
1179             # C.g:52:7: '.'
1180             self.match(u'.')
1181
1182
1183
1184
1185
1186         finally:
1187
1188             pass
1189
1190     # $ANTLR end T70
1191
1192
1193
1194     # $ANTLR start T71
1195     def mT71(self, ):
1196
1197         try:
1198             self.type = T71
1199
1200             # C.g:53:5: ( '->' )
1201             # C.g:53:7: '->'
1202             self.match("->")
1203
1204
1205
1206
1207
1208
1209         finally:
1210
1211             pass
1212
1213     # $ANTLR end T71
1214
1215
1216
1217     # $ANTLR start T72
1218     def mT72(self, ):
1219
1220         try:
1221             self.type = T72
1222
1223             # C.g:54:5: ( '&' )
1224             # C.g:54:7: '&'
1225             self.match(u'&')
1226
1227
1228
1229
1230
1231         finally:
1232
1233             pass
1234
1235     # $ANTLR end T72
1236
1237
1238
1239     # $ANTLR start T73
1240     def mT73(self, ):
1241
1242         try:
1243             self.type = T73
1244
1245             # C.g:55:5: ( '~' )
1246             # C.g:55:7: '~'
1247             self.match(u'~')
1248
1249
1250
1251
1252
1253         finally:
1254
1255             pass
1256
1257     # $ANTLR end T73
1258
1259
1260
1261     # $ANTLR start T74
1262     def mT74(self, ):
1263
1264         try:
1265             self.type = T74
1266
1267             # C.g:56:5: ( '!' )
1268             # C.g:56:7: '!'
1269             self.match(u'!')
1270
1271
1272
1273
1274
1275         finally:
1276
1277             pass
1278
1279     # $ANTLR end T74
1280
1281
1282
1283     # $ANTLR start T75
1284     def mT75(self, ):
1285
1286         try:
1287             self.type = T75
1288
1289             # C.g:57:5: ( '*=' )
1290             # C.g:57:7: '*='
1291             self.match("*=")
1292
1293
1294
1295
1296
1297
1298         finally:
1299
1300             pass
1301
1302     # $ANTLR end T75
1303
1304
1305
1306     # $ANTLR start T76
1307     def mT76(self, ):
1308
1309         try:
1310             self.type = T76
1311
1312             # C.g:58:5: ( '/=' )
1313             # C.g:58:7: '/='
1314             self.match("/=")
1315
1316
1317
1318
1319
1320
1321         finally:
1322
1323             pass
1324
1325     # $ANTLR end T76
1326
1327
1328
1329     # $ANTLR start T77
1330     def mT77(self, ):
1331
1332         try:
1333             self.type = T77
1334
1335             # C.g:59:5: ( '%=' )
1336             # C.g:59:7: '%='
1337             self.match("%=")
1338
1339
1340
1341
1342
1343
1344         finally:
1345
1346             pass
1347
1348     # $ANTLR end T77
1349
1350
1351
1352     # $ANTLR start T78
1353     def mT78(self, ):
1354
1355         try:
1356             self.type = T78
1357
1358             # C.g:60:5: ( '+=' )
1359             # C.g:60:7: '+='
1360             self.match("+=")
1361
1362
1363
1364
1365
1366
1367         finally:
1368
1369             pass
1370
1371     # $ANTLR end T78
1372
1373
1374
1375     # $ANTLR start T79
1376     def mT79(self, ):
1377
1378         try:
1379             self.type = T79
1380
1381             # C.g:61:5: ( '-=' )
1382             # C.g:61:7: '-='
1383             self.match("-=")
1384
1385
1386
1387
1388
1389
1390         finally:
1391
1392             pass
1393
1394     # $ANTLR end T79
1395
1396
1397
1398     # $ANTLR start T80
1399     def mT80(self, ):
1400
1401         try:
1402             self.type = T80
1403
1404             # C.g:62:5: ( '<<=' )
1405             # C.g:62:7: '<<='
1406             self.match("<<=")
1407
1408
1409
1410
1411
1412
1413         finally:
1414
1415             pass
1416
1417     # $ANTLR end T80
1418
1419
1420
1421     # $ANTLR start T81
1422     def mT81(self, ):
1423
1424         try:
1425             self.type = T81
1426
1427             # C.g:63:5: ( '>>=' )
1428             # C.g:63:7: '>>='
1429             self.match(">>=")
1430
1431
1432
1433
1434
1435
1436         finally:
1437
1438             pass
1439
1440     # $ANTLR end T81
1441
1442
1443
1444     # $ANTLR start T82
1445     def mT82(self, ):
1446
1447         try:
1448             self.type = T82
1449
1450             # C.g:64:5: ( '&=' )
1451             # C.g:64:7: '&='
1452             self.match("&=")
1453
1454
1455
1456
1457
1458
1459         finally:
1460
1461             pass
1462
1463     # $ANTLR end T82
1464
1465
1466
1467     # $ANTLR start T83
1468     def mT83(self, ):
1469
1470         try:
1471             self.type = T83
1472
1473             # C.g:65:5: ( '^=' )
1474             # C.g:65:7: '^='
1475             self.match("^=")
1476
1477
1478
1479
1480
1481
1482         finally:
1483
1484             pass
1485
1486     # $ANTLR end T83
1487
1488
1489
1490     # $ANTLR start T84
1491     def mT84(self, ):
1492
1493         try:
1494             self.type = T84
1495
1496             # C.g:66:5: ( '|=' )
1497             # C.g:66:7: '|='
1498             self.match("|=")
1499
1500
1501
1502
1503
1504
1505         finally:
1506
1507             pass
1508
1509     # $ANTLR end T84
1510
1511
1512
1513     # $ANTLR start T85
1514     def mT85(self, ):
1515
1516         try:
1517             self.type = T85
1518
1519             # C.g:67:5: ( '?' )
1520             # C.g:67:7: '?'
1521             self.match(u'?')
1522
1523
1524
1525
1526
1527         finally:
1528
1529             pass
1530
1531     # $ANTLR end T85
1532
1533
1534
1535     # $ANTLR start T86
1536     def mT86(self, ):
1537
1538         try:
1539             self.type = T86
1540
1541             # C.g:68:5: ( '||' )
1542             # C.g:68:7: '||'
1543             self.match("||")
1544
1545
1546
1547
1548
1549
1550         finally:
1551
1552             pass
1553
1554     # $ANTLR end T86
1555
1556
1557
1558     # $ANTLR start T87
1559     def mT87(self, ):
1560
1561         try:
1562             self.type = T87
1563
1564             # C.g:69:5: ( '&&' )
1565             # C.g:69:7: '&&'
1566             self.match("&&")
1567
1568
1569
1570
1571
1572
1573         finally:
1574
1575             pass
1576
1577     # $ANTLR end T87
1578
1579
1580
1581     # $ANTLR start T88
1582     def mT88(self, ):
1583
1584         try:
1585             self.type = T88
1586
1587             # C.g:70:5: ( '|' )
1588             # C.g:70:7: '|'
1589             self.match(u'|')
1590
1591
1592
1593
1594
1595         finally:
1596
1597             pass
1598
1599     # $ANTLR end T88
1600
1601
1602
1603     # $ANTLR start T89
1604     def mT89(self, ):
1605
1606         try:
1607             self.type = T89
1608
1609             # C.g:71:5: ( '^' )
1610             # C.g:71:7: '^'
1611             self.match(u'^')
1612
1613
1614
1615
1616
1617         finally:
1618
1619             pass
1620
1621     # $ANTLR end T89
1622
1623
1624
1625     # $ANTLR start T90
1626     def mT90(self, ):
1627
1628         try:
1629             self.type = T90
1630
1631             # C.g:72:5: ( '==' )
1632             # C.g:72:7: '=='
1633             self.match("==")
1634
1635
1636
1637
1638
1639
1640         finally:
1641
1642             pass
1643
1644     # $ANTLR end T90
1645
1646
1647
1648     # $ANTLR start T91
1649     def mT91(self, ):
1650
1651         try:
1652             self.type = T91
1653
1654             # C.g:73:5: ( '!=' )
1655             # C.g:73:7: '!='
1656             self.match("!=")
1657
1658
1659
1660
1661
1662
1663         finally:
1664
1665             pass
1666
1667     # $ANTLR end T91
1668
1669
1670
1671     # $ANTLR start T92
1672     def mT92(self, ):
1673
1674         try:
1675             self.type = T92
1676
1677             # C.g:74:5: ( '<' )
1678             # C.g:74:7: '<'
1679             self.match(u'<')
1680
1681
1682
1683
1684
1685         finally:
1686
1687             pass
1688
1689     # $ANTLR end T92
1690
1691
1692
1693     # $ANTLR start T93
1694     def mT93(self, ):
1695
1696         try:
1697             self.type = T93
1698
1699             # C.g:75:5: ( '>' )
1700             # C.g:75:7: '>'
1701             self.match(u'>')
1702
1703
1704
1705
1706
1707         finally:
1708
1709             pass
1710
1711     # $ANTLR end T93
1712
1713
1714
1715     # $ANTLR start T94
1716     def mT94(self, ):
1717
1718         try:
1719             self.type = T94
1720
1721             # C.g:76:5: ( '<=' )
1722             # C.g:76:7: '<='
1723             self.match("<=")
1724
1725
1726
1727
1728
1729
1730         finally:
1731
1732             pass
1733
1734     # $ANTLR end T94
1735
1736
1737
1738     # $ANTLR start T95
1739     def mT95(self, ):
1740
1741         try:
1742             self.type = T95
1743
1744             # C.g:77:5: ( '>=' )
1745             # C.g:77:7: '>='
1746             self.match(">=")
1747
1748
1749
1750
1751
1752
1753         finally:
1754
1755             pass
1756
1757     # $ANTLR end T95
1758
1759
1760
1761     # $ANTLR start T96
1762     def mT96(self, ):
1763
1764         try:
1765             self.type = T96
1766
1767             # C.g:78:5: ( '<<' )
1768             # C.g:78:7: '<<'
1769             self.match("<<")
1770
1771
1772
1773
1774
1775
1776         finally:
1777
1778             pass
1779
1780     # $ANTLR end T96
1781
1782
1783
1784     # $ANTLR start T97
1785     def mT97(self, ):
1786
1787         try:
1788             self.type = T97
1789
1790             # C.g:79:5: ( '>>' )
1791             # C.g:79:7: '>>'
1792             self.match(">>")
1793
1794
1795
1796
1797
1798
1799         finally:
1800
1801             pass
1802
1803     # $ANTLR end T97
1804
1805
1806
1807     # $ANTLR start T98
1808     def mT98(self, ):
1809
1810         try:
1811             self.type = T98
1812
1813             # C.g:80:5: ( 'case' )
1814             # C.g:80:7: 'case'
1815             self.match("case")
1816
1817
1818
1819
1820
1821
1822         finally:
1823
1824             pass
1825
1826     # $ANTLR end T98
1827
1828
1829
1830     # $ANTLR start T99
1831     def mT99(self, ):
1832
1833         try:
1834             self.type = T99
1835
1836             # C.g:81:5: ( 'default' )
1837             # C.g:81:7: 'default'
1838             self.match("default")
1839
1840
1841
1842
1843
1844
1845         finally:
1846
1847             pass
1848
1849     # $ANTLR end T99
1850
1851
1852
1853     # $ANTLR start T100
1854     def mT100(self, ):
1855
1856         try:
1857             self.type = T100
1858
1859             # C.g:82:6: ( 'if' )
1860             # C.g:82:8: 'if'
1861             self.match("if")
1862
1863
1864
1865
1866
1867
1868         finally:
1869
1870             pass
1871
1872     # $ANTLR end T100
1873
1874
1875
1876     # $ANTLR start T101
1877     def mT101(self, ):
1878
1879         try:
1880             self.type = T101
1881
1882             # C.g:83:6: ( 'else' )
1883             # C.g:83:8: 'else'
1884             self.match("else")
1885
1886
1887
1888
1889
1890
1891         finally:
1892
1893             pass
1894
1895     # $ANTLR end T101
1896
1897
1898
1899     # $ANTLR start T102
1900     def mT102(self, ):
1901
1902         try:
1903             self.type = T102
1904
1905             # C.g:84:6: ( 'switch' )
1906             # C.g:84:8: 'switch'
1907             self.match("switch")
1908
1909
1910
1911
1912
1913
1914         finally:
1915
1916             pass
1917
1918     # $ANTLR end T102
1919
1920
1921
1922     # $ANTLR start T103
1923     def mT103(self, ):
1924
1925         try:
1926             self.type = T103
1927
1928             # C.g:85:6: ( 'while' )
1929             # C.g:85:8: 'while'
1930             self.match("while")
1931
1932
1933
1934
1935
1936
1937         finally:
1938
1939             pass
1940
1941     # $ANTLR end T103
1942
1943
1944
1945     # $ANTLR start T104
1946     def mT104(self, ):
1947
1948         try:
1949             self.type = T104
1950
1951             # C.g:86:6: ( 'do' )
1952             # C.g:86:8: 'do'
1953             self.match("do")
1954
1955
1956
1957
1958
1959
1960         finally:
1961
1962             pass
1963
1964     # $ANTLR end T104
1965
1966
1967
1968     # $ANTLR start T105
1969     def mT105(self, ):
1970
1971         try:
1972             self.type = T105
1973
1974             # C.g:87:6: ( 'for' )
1975             # C.g:87:8: 'for'
1976             self.match("for")
1977
1978
1979
1980
1981
1982
1983         finally:
1984
1985             pass
1986
1987     # $ANTLR end T105
1988
1989
1990
1991     # $ANTLR start T106
1992     def mT106(self, ):
1993
1994         try:
1995             self.type = T106
1996
1997             # C.g:88:6: ( 'goto' )
1998             # C.g:88:8: 'goto'
1999             self.match("goto")
2000
2001
2002
2003
2004
2005
2006         finally:
2007
2008             pass
2009
2010     # $ANTLR end T106
2011
2012
2013
2014     # $ANTLR start T107
2015     def mT107(self, ):
2016
2017         try:
2018             self.type = T107
2019
2020             # C.g:89:6: ( 'continue' )
2021             # C.g:89:8: 'continue'
2022             self.match("continue")
2023
2024
2025
2026
2027
2028
2029         finally:
2030
2031             pass
2032
2033     # $ANTLR end T107
2034
2035
2036
2037     # $ANTLR start T108
2038     def mT108(self, ):
2039
2040         try:
2041             self.type = T108
2042
2043             # C.g:90:6: ( 'break' )
2044             # C.g:90:8: 'break'
2045             self.match("break")
2046
2047
2048
2049
2050
2051
2052         finally:
2053
2054             pass
2055
2056     # $ANTLR end T108
2057
2058
2059
2060     # $ANTLR start T109
2061     def mT109(self, ):
2062
2063         try:
2064             self.type = T109
2065
2066             # C.g:91:6: ( 'return' )
2067             # C.g:91:8: 'return'
2068             self.match("return")
2069
2070
2071
2072
2073
2074
2075         finally:
2076
2077             pass
2078
2079     # $ANTLR end T109
2080
2081
2082
2083     # $ANTLR start IDENTIFIER
2084     def mIDENTIFIER(self, ):
2085
2086         try:
2087             self.type = IDENTIFIER
2088
2089             # C.g:493:2: ( LETTER ( LETTER | '0' .. '9' )* )
2090             # C.g:493:4: LETTER ( LETTER | '0' .. '9' )*
2091             self.mLETTER()
2092
2093             # C.g:493:11: ( LETTER | '0' .. '9' )*
2094             while True: #loop1
2095                 alt1 = 2
2096                 LA1_0 = self.input.LA(1)
2097
2098                 if (LA1_0 == u'$' or (u'0' <= LA1_0 <= u'9') or (u'A' <= LA1_0 <= u'Z') or LA1_0 == u'_' or (u'a' <= LA1_0 <= u'z')) :
2099                     alt1 = 1
2100
2101
2102                 if alt1 == 1:
2103                     # C.g:
2104                     if self.input.LA(1) == u'$' or (u'0' <= self.input.LA(1) <= u'9') or (u'A' <= self.input.LA(1) <= u'Z') or self.input.LA(1) == u'_' or (u'a' <= self.input.LA(1) <= u'z'):
2105                         self.input.consume();
2106
2107                     else:
2108                         mse = MismatchedSetException(None, self.input)
2109                         self.recover(mse)
2110                         raise mse
2111
2112
2113
2114
2115                 else:
2116                     break #loop1
2117
2118
2119
2120
2121
2122
2123         finally:
2124
2125             pass
2126
2127     # $ANTLR end IDENTIFIER
2128
2129
2130
2131     # $ANTLR start LETTER
2132     def mLETTER(self, ):
2133
2134         try:
2135             # C.g:498:2: ( '$' | 'A' .. 'Z' | 'a' .. 'z' | '_' )
2136             # C.g:
2137             if self.input.LA(1) == u'$' or (u'A' <= self.input.LA(1) <= u'Z') or self.input.LA(1) == u'_' or (u'a' <= self.input.LA(1) <= u'z'):
2138                 self.input.consume();
2139
2140             else:
2141                 mse = MismatchedSetException(None, self.input)
2142                 self.recover(mse)
2143                 raise mse
2144
2145
2146
2147
2148
2149
2150         finally:
2151
2152             pass
2153
2154     # $ANTLR end LETTER
2155
2156
2157
2158     # $ANTLR start CHARACTER_LITERAL
2159     def mCHARACTER_LITERAL(self, ):
2160
2161         try:
2162             self.type = CHARACTER_LITERAL
2163
2164             # C.g:505:5: ( ( 'L' )? '\\'' ( EscapeSequence | ~ ( '\\'' | '\\\\' ) ) '\\'' )
2165             # C.g:505:9: ( 'L' )? '\\'' ( EscapeSequence | ~ ( '\\'' | '\\\\' ) ) '\\''
2166             # C.g:505:9: ( 'L' )?
2167             alt2 = 2
2168             LA2_0 = self.input.LA(1)
2169
2170             if (LA2_0 == u'L') :
2171                 alt2 = 1
2172             if alt2 == 1:
2173                 # C.g:505:10: 'L'
2174                 self.match(u'L')
2175
2176
2177
2178
2179             self.match(u'\'')
2180
2181             # C.g:505:21: ( EscapeSequence | ~ ( '\\'' | '\\\\' ) )
2182             alt3 = 2
2183             LA3_0 = self.input.LA(1)
2184
2185             if (LA3_0 == u'\\') :
2186                 alt3 = 1
2187             elif ((u'\u0000' <= LA3_0 <= u'&') or (u'(' <= LA3_0 <= u'[') or (u']' <= LA3_0 <= u'\uFFFE')) :
2188                 alt3 = 2
2189             else:
2190                 nvae = NoViableAltException("505:21: ( EscapeSequence | ~ ( '\\'' | '\\\\' ) )", 3, 0, self.input)
2191
2192                 raise nvae
2193
2194             if alt3 == 1:
2195                 # C.g:505:23: EscapeSequence
2196                 self.mEscapeSequence()
2197
2198
2199
2200             elif alt3 == 2:
2201                 # C.g:505:40: ~ ( '\\'' | '\\\\' )
2202                 if (u'\u0000' <= self.input.LA(1) <= u'&') or (u'(' <= self.input.LA(1) <= u'[') or (u']' <= self.input.LA(1) <= u'\uFFFE'):
2203                     self.input.consume();
2204
2205                 else:
2206                     mse = MismatchedSetException(None, self.input)
2207                     self.recover(mse)
2208                     raise mse
2209
2210
2211
2212
2213
2214             self.match(u'\'')
2215
2216
2217
2218
2219
2220         finally:
2221
2222             pass
2223
2224     # $ANTLR end CHARACTER_LITERAL
2225
2226
2227
2228     # $ANTLR start STRING_LITERAL
2229     def mSTRING_LITERAL(self, ):
2230
2231         try:
2232             self.type = STRING_LITERAL
2233
2234             # C.g:509:5: ( ( 'L' )? '\"' ( EscapeSequence | ~ ( '\\\\' | '\"' ) )* '\"' )
2235             # C.g:509:8: ( 'L' )? '\"' ( EscapeSequence | ~ ( '\\\\' | '\"' ) )* '\"'
2236             # C.g:509:8: ( 'L' )?
2237             alt4 = 2
2238             LA4_0 = self.input.LA(1)
2239
2240             if (LA4_0 == u'L') :
2241                 alt4 = 1
2242             if alt4 == 1:
2243                 # C.g:509:9: 'L'
2244                 self.match(u'L')
2245
2246
2247
2248
2249             self.match(u'"')
2250
2251             # C.g:509:19: ( EscapeSequence | ~ ( '\\\\' | '\"' ) )*
2252             while True: #loop5
2253                 alt5 = 3
2254                 LA5_0 = self.input.LA(1)
2255
2256                 if (LA5_0 == u'\\') :
2257                     alt5 = 1
2258                 elif ((u'\u0000' <= LA5_0 <= u'!') or (u'#' <= LA5_0 <= u'[') or (u']' <= LA5_0 <= u'\uFFFE')) :
2259                     alt5 = 2
2260
2261
2262                 if alt5 == 1:
2263                     # C.g:509:21: EscapeSequence
2264                     self.mEscapeSequence()
2265
2266
2267
2268                 elif alt5 == 2:
2269                     # C.g:509:38: ~ ( '\\\\' | '\"' )
2270                     if (u'\u0000' <= self.input.LA(1) <= u'!') or (u'#' <= self.input.LA(1) <= u'[') or (u']' <= self.input.LA(1) <= u'\uFFFE'):
2271                         self.input.consume();
2272
2273                     else:
2274                         mse = MismatchedSetException(None, self.input)
2275                         self.recover(mse)
2276                         raise mse
2277
2278
2279
2280
2281                 else:
2282                     break #loop5
2283
2284
2285             self.match(u'"')
2286
2287
2288
2289
2290
2291         finally:
2292
2293             pass
2294
2295     # $ANTLR end STRING_LITERAL
2296
2297
2298
2299     # $ANTLR start HEX_LITERAL
2300     def mHEX_LITERAL(self, ):
2301
2302         try:
2303             self.type = HEX_LITERAL
2304
2305             # C.g:512:13: ( '0' ( 'x' | 'X' ) ( HexDigit )+ ( IntegerTypeSuffix )? )
2306             # C.g:512:15: '0' ( 'x' | 'X' ) ( HexDigit )+ ( IntegerTypeSuffix )?
2307             self.match(u'0')
2308
2309             if self.input.LA(1) == u'X' or self.input.LA(1) == u'x':
2310                 self.input.consume();
2311
2312             else:
2313                 mse = MismatchedSetException(None, self.input)
2314                 self.recover(mse)
2315                 raise mse
2316
2317
2318             # C.g:512:29: ( HexDigit )+
2319             cnt6 = 0
2320             while True: #loop6
2321                 alt6 = 2
2322                 LA6_0 = self.input.LA(1)
2323
2324                 if ((u'0' <= LA6_0 <= u'9') or (u'A' <= LA6_0 <= u'F') or (u'a' <= LA6_0 <= u'f')) :
2325                     alt6 = 1
2326
2327
2328                 if alt6 == 1:
2329                     # C.g:512:29: HexDigit
2330                     self.mHexDigit()
2331
2332
2333
2334                 else:
2335                     if cnt6 >= 1:
2336                         break #loop6
2337
2338                     eee = EarlyExitException(6, self.input)
2339                     raise eee
2340
2341                 cnt6 += 1
2342
2343
2344             # C.g:512:39: ( IntegerTypeSuffix )?
2345             alt7 = 2
2346             LA7_0 = self.input.LA(1)
2347
2348             if (LA7_0 == u'L' or LA7_0 == u'U' or LA7_0 == u'l' or LA7_0 == u'u') :
2349                 alt7 = 1
2350             if alt7 == 1:
2351                 # C.g:512:39: IntegerTypeSuffix
2352                 self.mIntegerTypeSuffix()
2353
2354
2355
2356
2357
2358
2359
2360
2361         finally:
2362
2363             pass
2364
2365     # $ANTLR end HEX_LITERAL
2366
2367
2368
2369     # $ANTLR start DECIMAL_LITERAL
2370     def mDECIMAL_LITERAL(self, ):
2371
2372         try:
2373             self.type = DECIMAL_LITERAL
2374
2375             # C.g:514:17: ( ( '0' | '1' .. '9' ( '0' .. '9' )* ) ( IntegerTypeSuffix )? )
2376             # C.g:514:19: ( '0' | '1' .. '9' ( '0' .. '9' )* ) ( IntegerTypeSuffix )?
2377             # C.g:514:19: ( '0' | '1' .. '9' ( '0' .. '9' )* )
2378             alt9 = 2
2379             LA9_0 = self.input.LA(1)
2380
2381             if (LA9_0 == u'0') :
2382                 alt9 = 1
2383             elif ((u'1' <= LA9_0 <= u'9')) :
2384                 alt9 = 2
2385             else:
2386                 nvae = NoViableAltException("514:19: ( '0' | '1' .. '9' ( '0' .. '9' )* )", 9, 0, self.input)
2387
2388                 raise nvae
2389
2390             if alt9 == 1:
2391                 # C.g:514:20: '0'
2392                 self.match(u'0')
2393
2394
2395
2396             elif alt9 == 2:
2397                 # C.g:514:26: '1' .. '9' ( '0' .. '9' )*
2398                 self.matchRange(u'1', u'9')
2399
2400                 # C.g:514:35: ( '0' .. '9' )*
2401                 while True: #loop8
2402                     alt8 = 2
2403                     LA8_0 = self.input.LA(1)
2404
2405                     if ((u'0' <= LA8_0 <= u'9')) :
2406                         alt8 = 1
2407
2408
2409                     if alt8 == 1:
2410                         # C.g:514:35: '0' .. '9'
2411                         self.matchRange(u'0', u'9')
2412
2413
2414
2415                     else:
2416                         break #loop8
2417
2418
2419
2420
2421
2422             # C.g:514:46: ( IntegerTypeSuffix )?
2423             alt10 = 2
2424             LA10_0 = self.input.LA(1)
2425
2426             if (LA10_0 == u'L' or LA10_0 == u'U' or LA10_0 == u'l' or LA10_0 == u'u') :
2427                 alt10 = 1
2428             if alt10 == 1:
2429                 # C.g:514:46: IntegerTypeSuffix
2430                 self.mIntegerTypeSuffix()
2431
2432
2433
2434
2435
2436
2437
2438
2439         finally:
2440
2441             pass
2442
2443     # $ANTLR end DECIMAL_LITERAL
2444
2445
2446
2447     # $ANTLR start OCTAL_LITERAL
2448     def mOCTAL_LITERAL(self, ):
2449
2450         try:
2451             self.type = OCTAL_LITERAL
2452
2453             # C.g:516:15: ( '0' ( '0' .. '7' )+ ( IntegerTypeSuffix )? )
2454             # C.g:516:17: '0' ( '0' .. '7' )+ ( IntegerTypeSuffix )?
2455             self.match(u'0')
2456
2457             # C.g:516:21: ( '0' .. '7' )+
2458             cnt11 = 0
2459             while True: #loop11
2460                 alt11 = 2
2461                 LA11_0 = self.input.LA(1)
2462
2463                 if ((u'0' <= LA11_0 <= u'7')) :
2464                     alt11 = 1
2465
2466
2467                 if alt11 == 1:
2468                     # C.g:516:22: '0' .. '7'
2469                     self.matchRange(u'0', u'7')
2470
2471
2472
2473                 else:
2474                     if cnt11 >= 1:
2475                         break #loop11
2476
2477                     eee = EarlyExitException(11, self.input)
2478                     raise eee
2479
2480                 cnt11 += 1
2481
2482
2483             # C.g:516:33: ( IntegerTypeSuffix )?
2484             alt12 = 2
2485             LA12_0 = self.input.LA(1)
2486
2487             if (LA12_0 == u'L' or LA12_0 == u'U' or LA12_0 == u'l' or LA12_0 == u'u') :
2488                 alt12 = 1
2489             if alt12 == 1:
2490                 # C.g:516:33: IntegerTypeSuffix
2491                 self.mIntegerTypeSuffix()
2492
2493
2494
2495
2496
2497
2498
2499
2500         finally:
2501
2502             pass
2503
2504     # $ANTLR end OCTAL_LITERAL
2505
2506
2507
2508     # $ANTLR start HexDigit
2509     def mHexDigit(self, ):
2510
2511         try:
2512             # C.g:519:10: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )
2513             # C.g:519:12: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )
2514             if (u'0' <= self.input.LA(1) <= u'9') or (u'A' <= self.input.LA(1) <= u'F') or (u'a' <= self.input.LA(1) <= u'f'):
2515                 self.input.consume();
2516
2517             else:
2518                 mse = MismatchedSetException(None, self.input)
2519                 self.recover(mse)
2520                 raise mse
2521
2522
2523
2524
2525
2526
2527         finally:
2528
2529             pass
2530
2531     # $ANTLR end HexDigit
2532
2533
2534
2535     # $ANTLR start IntegerTypeSuffix
2536     def mIntegerTypeSuffix(self, ):
2537
2538         try:
2539             # C.g:523:2: ( ( 'u' | 'U' )? ( 'l' | 'L' ) | ( 'u' | 'U' ) ( 'l' | 'L' )? ( 'l' | 'L' )? )
2540             alt16 = 2
2541             LA16_0 = self.input.LA(1)
2542
2543             if (LA16_0 == u'U' or LA16_0 == u'u') :
2544                 LA16_1 = self.input.LA(2)
2545
2546                 if (LA16_1 == u'L' or LA16_1 == u'l') :
2547                     alt16 = 1
2548                 else:
2549                     alt16 = 2
2550             elif (LA16_0 == u'L' or LA16_0 == u'l') :
2551                 alt16 = 1
2552             else:
2553                 nvae = NoViableAltException("521:1: fragment IntegerTypeSuffix : ( ( 'u' | 'U' )? ( 'l' | 'L' ) | ( 'u' | 'U' ) ( 'l' | 'L' )? ( 'l' | 'L' )? );", 16, 0, self.input)
2554
2555                 raise nvae
2556
2557             if alt16 == 1:
2558                 # C.g:523:4: ( 'u' | 'U' )? ( 'l' | 'L' )
2559                 # C.g:523:4: ( 'u' | 'U' )?
2560                 alt13 = 2
2561                 LA13_0 = self.input.LA(1)
2562
2563                 if (LA13_0 == u'U' or LA13_0 == u'u') :
2564                     alt13 = 1
2565                 if alt13 == 1:
2566                     # C.g:
2567                     if self.input.LA(1) == u'U' or self.input.LA(1) == u'u':
2568                         self.input.consume();
2569
2570                     else:
2571                         mse = MismatchedSetException(None, self.input)
2572                         self.recover(mse)
2573                         raise mse
2574
2575
2576
2577
2578
2579                 if self.input.LA(1) == u'L' or self.input.LA(1) == u'l':
2580                     self.input.consume();
2581
2582                 else:
2583                     mse = MismatchedSetException(None, self.input)
2584                     self.recover(mse)
2585                     raise mse
2586
2587
2588
2589
2590             elif alt16 == 2:
2591                 # C.g:524:4: ( 'u' | 'U' ) ( 'l' | 'L' )? ( 'l' | 'L' )?
2592                 if self.input.LA(1) == u'U' or self.input.LA(1) == u'u':
2593                     self.input.consume();
2594
2595                 else:
2596                     mse = MismatchedSetException(None, self.input)
2597                     self.recover(mse)
2598                     raise mse
2599
2600
2601                 # C.g:524:15: ( 'l' | 'L' )?
2602                 alt14 = 2
2603                 LA14_0 = self.input.LA(1)
2604
2605                 if (LA14_0 == u'L' or LA14_0 == u'l') :
2606                     alt14 = 1
2607                 if alt14 == 1:
2608                     # C.g:
2609                     if self.input.LA(1) == u'L' or self.input.LA(1) == u'l':
2610                         self.input.consume();
2611
2612                     else:
2613                         mse = MismatchedSetException(None, self.input)
2614                         self.recover(mse)
2615                         raise mse
2616
2617
2618
2619
2620
2621                 # C.g:524:26: ( 'l' | 'L' )?
2622                 alt15 = 2
2623                 LA15_0 = self.input.LA(1)
2624
2625                 if (LA15_0 == u'L' or LA15_0 == u'l') :
2626                     alt15 = 1
2627                 if alt15 == 1:
2628                     # C.g:
2629                     if self.input.LA(1) == u'L' or self.input.LA(1) == u'l':
2630                         self.input.consume();
2631
2632                     else:
2633                         mse = MismatchedSetException(None, self.input)
2634                         self.recover(mse)
2635                         raise mse
2636
2637
2638
2639
2640
2641
2642
2643
2644         finally:
2645
2646             pass
2647
2648     # $ANTLR end IntegerTypeSuffix
2649
2650
2651
2652     # $ANTLR start FLOATING_POINT_LITERAL
2653     def mFLOATING_POINT_LITERAL(self, ):
2654
2655         try:
2656             self.type = FLOATING_POINT_LITERAL
2657
2658             # C.g:528:5: ( ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( Exponent )? ( FloatTypeSuffix )? | '.' ( '0' .. '9' )+ ( Exponent )? ( FloatTypeSuffix )? | ( '0' .. '9' )+ Exponent ( FloatTypeSuffix )? | ( '0' .. '9' )+ ( Exponent )? FloatTypeSuffix )
2659             alt28 = 4
2660             alt28 = self.dfa28.predict(self.input)
2661             if alt28 == 1:
2662                 # C.g:528:9: ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( Exponent )? ( FloatTypeSuffix )?
2663                 # C.g:528:9: ( '0' .. '9' )+
2664                 cnt17 = 0
2665                 while True: #loop17
2666                     alt17 = 2
2667                     LA17_0 = self.input.LA(1)
2668
2669                     if ((u'0' <= LA17_0 <= u'9')) :
2670                         alt17 = 1
2671
2672
2673                     if alt17 == 1:
2674                         # C.g:528:10: '0' .. '9'
2675                         self.matchRange(u'0', u'9')
2676
2677
2678
2679                     else:
2680                         if cnt17 >= 1:
2681                             break #loop17
2682
2683                         eee = EarlyExitException(17, self.input)
2684                         raise eee
2685
2686                     cnt17 += 1
2687
2688
2689                 self.match(u'.')
2690
2691                 # C.g:528:25: ( '0' .. '9' )*
2692                 while True: #loop18
2693                     alt18 = 2
2694                     LA18_0 = self.input.LA(1)
2695
2696                     if ((u'0' <= LA18_0 <= u'9')) :
2697                         alt18 = 1
2698
2699
2700                     if alt18 == 1:
2701                         # C.g:528:26: '0' .. '9'
2702                         self.matchRange(u'0', u'9')
2703
2704
2705
2706                     else:
2707                         break #loop18
2708
2709
2710                 # C.g:528:37: ( Exponent )?
2711                 alt19 = 2
2712                 LA19_0 = self.input.LA(1)
2713
2714                 if (LA19_0 == u'E' or LA19_0 == u'e') :
2715                     alt19 = 1
2716                 if alt19 == 1:
2717                     # C.g:528:37: Exponent
2718                     self.mExponent()
2719
2720
2721
2722
2723                 # C.g:528:47: ( FloatTypeSuffix )?
2724                 alt20 = 2
2725                 LA20_0 = self.input.LA(1)
2726
2727                 if (LA20_0 == u'D' or LA20_0 == u'F' or LA20_0 == u'd' or LA20_0 == u'f') :
2728                     alt20 = 1
2729                 if alt20 == 1:
2730                     # C.g:528:47: FloatTypeSuffix
2731                     self.mFloatTypeSuffix()
2732
2733
2734
2735
2736
2737
2738             elif alt28 == 2:
2739                 # C.g:529:9: '.' ( '0' .. '9' )+ ( Exponent )? ( FloatTypeSuffix )?
2740                 self.match(u'.')
2741
2742                 # C.g:529:13: ( '0' .. '9' )+
2743                 cnt21 = 0
2744                 while True: #loop21
2745                     alt21 = 2
2746                     LA21_0 = self.input.LA(1)
2747
2748                     if ((u'0' <= LA21_0 <= u'9')) :
2749                         alt21 = 1
2750
2751
2752                     if alt21 == 1:
2753                         # C.g:529:14: '0' .. '9'
2754                         self.matchRange(u'0', u'9')
2755
2756
2757
2758                     else:
2759                         if cnt21 >= 1:
2760                             break #loop21
2761
2762                         eee = EarlyExitException(21, self.input)
2763                         raise eee
2764
2765                     cnt21 += 1
2766
2767
2768                 # C.g:529:25: ( Exponent )?
2769                 alt22 = 2
2770                 LA22_0 = self.input.LA(1)
2771
2772                 if (LA22_0 == u'E' or LA22_0 == u'e') :
2773                     alt22 = 1
2774                 if alt22 == 1:
2775                     # C.g:529:25: Exponent
2776                     self.mExponent()
2777
2778
2779
2780
2781                 # C.g:529:35: ( FloatTypeSuffix )?
2782                 alt23 = 2
2783                 LA23_0 = self.input.LA(1)
2784
2785                 if (LA23_0 == u'D' or LA23_0 == u'F' or LA23_0 == u'd' or LA23_0 == u'f') :
2786                     alt23 = 1
2787                 if alt23 == 1:
2788                     # C.g:529:35: FloatTypeSuffix
2789                     self.mFloatTypeSuffix()
2790
2791
2792
2793
2794
2795
2796             elif alt28 == 3:
2797                 # C.g:530:9: ( '0' .. '9' )+ Exponent ( FloatTypeSuffix )?
2798                 # C.g:530:9: ( '0' .. '9' )+
2799                 cnt24 = 0
2800                 while True: #loop24
2801                     alt24 = 2
2802                     LA24_0 = self.input.LA(1)
2803
2804                     if ((u'0' <= LA24_0 <= u'9')) :
2805                         alt24 = 1
2806
2807
2808                     if alt24 == 1:
2809                         # C.g:530:10: '0' .. '9'
2810                         self.matchRange(u'0', u'9')
2811
2812
2813
2814                     else:
2815                         if cnt24 >= 1:
2816                             break #loop24
2817
2818                         eee = EarlyExitException(24, self.input)
2819                         raise eee
2820
2821                     cnt24 += 1
2822
2823
2824                 self.mExponent()
2825
2826                 # C.g:530:30: ( FloatTypeSuffix )?
2827                 alt25 = 2
2828                 LA25_0 = self.input.LA(1)
2829
2830                 if (LA25_0 == u'D' or LA25_0 == u'F' or LA25_0 == u'd' or LA25_0 == u'f') :
2831                     alt25 = 1
2832                 if alt25 == 1:
2833                     # C.g:530:30: FloatTypeSuffix
2834                     self.mFloatTypeSuffix()
2835
2836
2837
2838
2839
2840
2841             elif alt28 == 4:
2842                 # C.g:531:9: ( '0' .. '9' )+ ( Exponent )? FloatTypeSuffix
2843                 # C.g:531:9: ( '0' .. '9' )+
2844                 cnt26 = 0
2845                 while True: #loop26
2846                     alt26 = 2
2847                     LA26_0 = self.input.LA(1)
2848
2849                     if ((u'0' <= LA26_0 <= u'9')) :
2850                         alt26 = 1
2851
2852
2853                     if alt26 == 1:
2854                         # C.g:531:10: '0' .. '9'
2855                         self.matchRange(u'0', u'9')
2856
2857
2858
2859                     else:
2860                         if cnt26 >= 1:
2861                             break #loop26
2862
2863                         eee = EarlyExitException(26, self.input)
2864                         raise eee
2865
2866                     cnt26 += 1
2867
2868
2869                 # C.g:531:21: ( Exponent )?
2870                 alt27 = 2
2871                 LA27_0 = self.input.LA(1)
2872
2873                 if (LA27_0 == u'E' or LA27_0 == u'e') :
2874                     alt27 = 1
2875                 if alt27 == 1:
2876                     # C.g:531:21: Exponent
2877                     self.mExponent()
2878
2879
2880
2881
2882                 self.mFloatTypeSuffix()
2883
2884
2885
2886
2887         finally:
2888
2889             pass
2890
2891     # $ANTLR end FLOATING_POINT_LITERAL
2892
2893
2894
2895     # $ANTLR start Exponent
2896     def mExponent(self, ):
2897
2898         try:
2899             # C.g:535:10: ( ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+ )
2900             # C.g:535:12: ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+
2901             if self.input.LA(1) == u'E' or self.input.LA(1) == u'e':
2902                 self.input.consume();
2903
2904             else:
2905                 mse = MismatchedSetException(None, self.input)
2906                 self.recover(mse)
2907                 raise mse
2908
2909
2910             # C.g:535:22: ( '+' | '-' )?
2911             alt29 = 2
2912             LA29_0 = self.input.LA(1)
2913
2914             if (LA29_0 == u'+' or LA29_0 == u'-') :
2915                 alt29 = 1
2916             if alt29 == 1:
2917                 # C.g:
2918                 if self.input.LA(1) == u'+' or self.input.LA(1) == u'-':
2919                     self.input.consume();
2920
2921                 else:
2922                     mse = MismatchedSetException(None, self.input)
2923                     self.recover(mse)
2924                     raise mse
2925
2926
2927
2928
2929
2930             # C.g:535:33: ( '0' .. '9' )+
2931             cnt30 = 0
2932             while True: #loop30
2933                 alt30 = 2
2934                 LA30_0 = self.input.LA(1)
2935
2936                 if ((u'0' <= LA30_0 <= u'9')) :
2937                     alt30 = 1
2938
2939
2940                 if alt30 == 1:
2941                     # C.g:535:34: '0' .. '9'
2942                     self.matchRange(u'0', u'9')
2943
2944
2945
2946                 else:
2947                     if cnt30 >= 1:
2948                         break #loop30
2949
2950                     eee = EarlyExitException(30, self.input)
2951                     raise eee
2952
2953                 cnt30 += 1
2954
2955
2956
2957
2958
2959
2960         finally:
2961
2962             pass
2963
2964     # $ANTLR end Exponent
2965
2966
2967
2968     # $ANTLR start FloatTypeSuffix
2969     def mFloatTypeSuffix(self, ):
2970
2971         try:
2972             # C.g:538:17: ( ( 'f' | 'F' | 'd' | 'D' ) )
2973             # C.g:538:19: ( 'f' | 'F' | 'd' | 'D' )
2974             if self.input.LA(1) == u'D' or self.input.LA(1) == u'F' or self.input.LA(1) == u'd' or self.input.LA(1) == u'f':
2975                 self.input.consume();
2976
2977             else:
2978                 mse = MismatchedSetException(None, self.input)
2979                 self.recover(mse)
2980                 raise mse
2981
2982
2983
2984
2985
2986
2987         finally:
2988
2989             pass
2990
2991     # $ANTLR end FloatTypeSuffix
2992
2993
2994
2995     # $ANTLR start EscapeSequence
2996     def mEscapeSequence(self, ):
2997
2998         try:
2999             # C.g:542:5: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | OctalEscape )
3000             alt31 = 2
3001             LA31_0 = self.input.LA(1)
3002
3003             if (LA31_0 == u'\\') :
3004                 LA31_1 = self.input.LA(2)
3005
3006                 if (LA31_1 == u'"' or LA31_1 == u'\'' or LA31_1 == u'\\' or LA31_1 == u'b' or LA31_1 == u'f' or LA31_1 == u'n' or LA31_1 == u'r' or LA31_1 == u't') :
3007                     alt31 = 1
3008                 elif ((u'0' <= LA31_1 <= u'7')) :
3009                     alt31 = 2
3010                 else:
3011                     nvae = NoViableAltException("540:1: fragment EscapeSequence : ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | OctalEscape );", 31, 1, self.input)
3012
3013                     raise nvae
3014
3015             else:
3016                 nvae = NoViableAltException("540:1: fragment EscapeSequence : ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | OctalEscape );", 31, 0, self.input)
3017
3018                 raise nvae
3019
3020             if alt31 == 1:
3021                 # C.g:542:8: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' )
3022                 self.match(u'\\')
3023
3024                 if self.input.LA(1) == u'"' or self.input.LA(1) == u'\'' or self.input.LA(1) == u'\\' or self.input.LA(1) == u'b' or self.input.LA(1) == u'f' or self.input.LA(1) == u'n' or self.input.LA(1) == u'r' or self.input.LA(1) == u't':
3025                     self.input.consume();
3026
3027                 else:
3028                     mse = MismatchedSetException(None, self.input)
3029                     self.recover(mse)
3030                     raise mse
3031
3032
3033
3034
3035             elif alt31 == 2:
3036                 # C.g:543:9: OctalEscape
3037                 self.mOctalEscape()
3038
3039
3040
3041
3042         finally:
3043
3044             pass
3045
3046     # $ANTLR end EscapeSequence
3047
3048
3049
3050     # $ANTLR start OctalEscape
3051     def mOctalEscape(self, ):
3052
3053         try:
3054             # C.g:548:5: ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) )
3055             alt32 = 3
3056             LA32_0 = self.input.LA(1)
3057
3058             if (LA32_0 == u'\\') :
3059                 LA32_1 = self.input.LA(2)
3060
3061                 if ((u'0' <= LA32_1 <= u'3')) :
3062                     LA32_2 = self.input.LA(3)
3063
3064                     if ((u'0' <= LA32_2 <= u'7')) :
3065                         LA32_5 = self.input.LA(4)
3066
3067                         if ((u'0' <= LA32_5 <= u'7')) :
3068                             alt32 = 1
3069                         else:
3070                             alt32 = 2
3071                     else:
3072                         alt32 = 3
3073                 elif ((u'4' <= LA32_1 <= u'7')) :
3074                     LA32_3 = self.input.LA(3)
3075
3076                     if ((u'0' <= LA32_3 <= u'7')) :
3077                         alt32 = 2
3078                     else:
3079                         alt32 = 3
3080                 else:
3081                     nvae = NoViableAltException("546:1: fragment OctalEscape : ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) );", 32, 1, self.input)
3082
3083                     raise nvae
3084
3085             else:
3086                 nvae = NoViableAltException("546:1: fragment OctalEscape : ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) );", 32, 0, self.input)
3087
3088                 raise nvae
3089
3090             if alt32 == 1:
3091                 # C.g:548:9: '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' )
3092                 self.match(u'\\')
3093
3094                 # C.g:548:14: ( '0' .. '3' )
3095                 # C.g:548:15: '0' .. '3'
3096                 self.matchRange(u'0', u'3')
3097
3098
3099
3100
3101                 # C.g:548:25: ( '0' .. '7' )
3102                 # C.g:548:26: '0' .. '7'
3103                 self.matchRange(u'0', u'7')
3104
3105
3106
3107
3108                 # C.g:548:36: ( '0' .. '7' )
3109                 # C.g:548:37: '0' .. '7'
3110                 self.matchRange(u'0', u'7')
3111
3112
3113
3114
3115
3116
3117             elif alt32 == 2:
3118                 # C.g:549:9: '\\\\' ( '0' .. '7' ) ( '0' .. '7' )
3119                 self.match(u'\\')
3120
3121                 # C.g:549:14: ( '0' .. '7' )
3122                 # C.g:549:15: '0' .. '7'
3123                 self.matchRange(u'0', u'7')
3124
3125
3126
3127
3128                 # C.g:549:25: ( '0' .. '7' )
3129                 # C.g:549:26: '0' .. '7'
3130                 self.matchRange(u'0', u'7')
3131
3132
3133
3134
3135
3136
3137             elif alt32 == 3:
3138                 # C.g:550:9: '\\\\' ( '0' .. '7' )
3139                 self.match(u'\\')
3140
3141                 # C.g:550:14: ( '0' .. '7' )
3142                 # C.g:550:15: '0' .. '7'
3143                 self.matchRange(u'0', u'7')
3144
3145
3146
3147
3148
3149
3150
3151         finally:
3152
3153             pass
3154
3155     # $ANTLR end OctalEscape
3156
3157
3158
3159     # $ANTLR start UnicodeEscape
3160     def mUnicodeEscape(self, ):
3161
3162         try:
3163             # C.g:555:5: ( '\\\\' 'u' HexDigit HexDigit HexDigit HexDigit )
3164             # C.g:555:9: '\\\\' 'u' HexDigit HexDigit HexDigit HexDigit
3165             self.match(u'\\')
3166
3167             self.match(u'u')
3168
3169             self.mHexDigit()
3170
3171             self.mHexDigit()
3172
3173             self.mHexDigit()
3174
3175             self.mHexDigit()
3176
3177
3178
3179
3180
3181         finally:
3182
3183             pass
3184
3185     # $ANTLR end UnicodeEscape
3186
3187
3188
3189     # $ANTLR start WS
3190     def mWS(self, ):
3191
3192         try:
3193             self.type = WS
3194
3195             # C.g:558:5: ( ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' ) )
3196             # C.g:558:8: ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' )
3197             if (u'\t' <= self.input.LA(1) <= u'\n') or (u'\f' <= self.input.LA(1) <= u'\r') or self.input.LA(1) == u' ':
3198                 self.input.consume();
3199
3200             else:
3201                 mse = MismatchedSetException(None, self.input)
3202                 self.recover(mse)
3203                 raise mse
3204
3205
3206             #action start
3207             self.channel=HIDDEN;
3208             #action end
3209
3210
3211
3212
3213         finally:
3214
3215             pass
3216
3217     # $ANTLR end WS
3218
3219
3220
3221     # $ANTLR start BS
3222     def mBS(self, ):
3223
3224         try:
3225             self.type = BS
3226
3227             # C.g:562:5: ( ( '\\\\' ) )
3228             # C.g:562:7: ( '\\\\' )
3229             # C.g:562:7: ( '\\\\' )
3230             # C.g:562:8: '\\\\'
3231             self.match(u'\\')
3232
3233
3234
3235
3236             #action start
3237             self.channel=HIDDEN;
3238             #action end
3239
3240
3241
3242
3243         finally:
3244
3245             pass
3246
3247     # $ANTLR end BS
3248
3249
3250
3251     # $ANTLR start UnicodeVocabulary
3252     def mUnicodeVocabulary(self, ):
3253
3254         try:
3255             self.type = UnicodeVocabulary
3256
3257             # C.g:570:5: ( '\\u0003' .. '\\uFFFE' )
3258             # C.g:570:7: '\\u0003' .. '\\uFFFE'
3259             self.matchRange(u'\u0003', u'\uFFFE')
3260
3261
3262
3263
3264
3265         finally:
3266
3267             pass
3268
3269     # $ANTLR end UnicodeVocabulary
3270
3271
3272
3273     # $ANTLR start COMMENT
3274     def mCOMMENT(self, ):
3275
3276         try:
3277             self.type = COMMENT
3278
3279             # C.g:573:5: ( '/*' ( options {greedy=false; } : . )* '*/' )
3280             # C.g:573:9: '/*' ( options {greedy=false; } : . )* '*/'
3281             self.match("/*")
3282
3283
3284             # C.g:573:14: ( options {greedy=false; } : . )*
3285             while True: #loop33
3286                 alt33 = 2
3287                 LA33_0 = self.input.LA(1)
3288
3289                 if (LA33_0 == u'*') :
3290                     LA33_1 = self.input.LA(2)
3291
3292                     if (LA33_1 == u'/') :
3293                         alt33 = 2
3294                     elif ((u'\u0000' <= LA33_1 <= u'.') or (u'0' <= LA33_1 <= u'\uFFFE')) :
3295                         alt33 = 1
3296
3297
3298                 elif ((u'\u0000' <= LA33_0 <= u')') or (u'+' <= LA33_0 <= u'\uFFFE')) :
3299                     alt33 = 1
3300
3301
3302                 if alt33 == 1:
3303                     # C.g:573:42: .
3304                     self.matchAny()
3305
3306
3307
3308                 else:
3309                     break #loop33
3310
3311
3312             self.match("*/")
3313
3314
3315             #action start
3316             self.channel=HIDDEN;
3317             #action end
3318
3319
3320
3321
3322         finally:
3323
3324             pass
3325
3326     # $ANTLR end COMMENT
3327
3328
3329
3330     # $ANTLR start LINE_COMMENT
3331     def mLINE_COMMENT(self, ):
3332
3333         try:
3334             self.type = LINE_COMMENT
3335
3336             # C.g:578:5: ( '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' )
3337             # C.g:578:7: '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'
3338             self.match("//")
3339
3340
3341             # C.g:578:12: (~ ( '\\n' | '\\r' ) )*
3342             while True: #loop34
3343                 alt34 = 2
3344                 LA34_0 = self.input.LA(1)
3345
3346                 if ((u'\u0000' <= LA34_0 <= u'\t') or (u'\u000B' <= LA34_0 <= u'\f') or (u'\u000E' <= LA34_0 <= u'\uFFFE')) :
3347                     alt34 = 1
3348
3349
3350                 if alt34 == 1:
3351                     # C.g:578:12: ~ ( '\\n' | '\\r' )
3352                     if (u'\u0000' <= self.input.LA(1) <= u'\t') or (u'\u000B' <= self.input.LA(1) <= u'\f') or (u'\u000E' <= self.input.LA(1) <= u'\uFFFE'):
3353                         self.input.consume();
3354
3355                     else:
3356                         mse = MismatchedSetException(None, self.input)
3357                         self.recover(mse)
3358                         raise mse
3359
3360
3361
3362
3363                 else:
3364                     break #loop34
3365
3366
3367             # C.g:578:26: ( '\\r' )?
3368             alt35 = 2
3369             LA35_0 = self.input.LA(1)
3370
3371             if (LA35_0 == u'\r') :
3372                 alt35 = 1
3373             if alt35 == 1:
3374                 # C.g:578:26: '\\r'
3375                 self.match(u'\r')
3376
3377
3378
3379
3380             self.match(u'\n')
3381
3382             #action start
3383             self.channel=HIDDEN;
3384             #action end
3385
3386
3387
3388
3389         finally:
3390
3391             pass
3392
3393     # $ANTLR end LINE_COMMENT
3394
3395
3396
3397     # $ANTLR start LINE_COMMAND
3398     def mLINE_COMMAND(self, ):
3399
3400         try:
3401             self.type = LINE_COMMAND
3402
3403             # C.g:583:5: ( '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' )
3404             # C.g:583:7: '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'
3405             self.match(u'#')
3406
3407             # C.g:583:11: (~ ( '\\n' | '\\r' ) )*
3408             while True: #loop36
3409                 alt36 = 2
3410                 LA36_0 = self.input.LA(1)
3411
3412                 if ((u'\u0000' <= LA36_0 <= u'\t') or (u'\u000B' <= LA36_0 <= u'\f') or (u'\u000E' <= LA36_0 <= u'\uFFFE')) :
3413                     alt36 = 1
3414
3415
3416                 if alt36 == 1:
3417                     # C.g:583:11: ~ ( '\\n' | '\\r' )
3418                     if (u'\u0000' <= self.input.LA(1) <= u'\t') or (u'\u000B' <= self.input.LA(1) <= u'\f') or (u'\u000E' <= self.input.LA(1) <= u'\uFFFE'):
3419                         self.input.consume();
3420
3421                     else:
3422                         mse = MismatchedSetException(None, self.input)
3423                         self.recover(mse)
3424                         raise mse
3425
3426
3427
3428
3429                 else:
3430                     break #loop36
3431
3432
3433             # C.g:583:25: ( '\\r' )?
3434             alt37 = 2
3435             LA37_0 = self.input.LA(1)
3436
3437             if (LA37_0 == u'\r') :
3438                 alt37 = 1
3439             if alt37 == 1:
3440                 # C.g:583:25: '\\r'
3441                 self.match(u'\r')
3442
3443
3444
3445
3446             self.match(u'\n')
3447
3448             #action start
3449             self.channel=HIDDEN;
3450             #action end
3451
3452
3453
3454
3455         finally:
3456
3457             pass
3458
3459     # $ANTLR end LINE_COMMAND
3460
3461
3462
3463     def mTokens(self):
3464         # C.g:1:8: ( T25 | T26 | T27 | T28 | T29 | T30 | T31 | T32 | T33 | T34 | T35 | T36 | T37 | T38 | T39 | T40 | T41 | T42 | T43 | T44 | T45 | T46 | T47 | T48 | T49 | T50 | T51 | T52 | T53 | T54 | T55 | T56 | T57 | T58 | T59 | T60 | T61 | T62 | T63 | T64 | T65 | T66 | T67 | T68 | T69 | T70 | T71 | T72 | T73 | T74 | T75 | T76 | T77 | T78 | T79 | T80 | T81 | T82 | T83 | T84 | T85 | T86 | T87 | T88 | T89 | T90 | T91 | T92 | T93 | T94 | T95 | T96 | T97 | T98 | T99 | T100 | T101 | T102 | T103 | T104 | T105 | T106 | T107 | T108 | T109 | IDENTIFIER | CHARACTER_LITERAL | STRING_LITERAL | HEX_LITERAL | DECIMAL_LITERAL | OCTAL_LITERAL | FLOATING_POINT_LITERAL | WS | BS | UnicodeVocabulary | COMMENT | LINE_COMMENT | LINE_COMMAND )
3465         alt38 = 98
3466         alt38 = self.dfa38.predict(self.input)
3467         if alt38 == 1:
3468             # C.g:1:10: T25
3469             self.mT25()
3470
3471
3472
3473         elif alt38 == 2:
3474             # C.g:1:14: T26
3475             self.mT26()
3476
3477
3478
3479         elif alt38 == 3:
3480             # C.g:1:18: T27
3481             self.mT27()
3482
3483
3484
3485         elif alt38 == 4:
3486             # C.g:1:22: T28
3487             self.mT28()
3488
3489
3490
3491         elif alt38 == 5:
3492             # C.g:1:26: T29
3493             self.mT29()
3494
3495
3496
3497         elif alt38 == 6:
3498             # C.g:1:30: T30
3499             self.mT30()
3500
3501
3502
3503         elif alt38 == 7:
3504             # C.g:1:34: T31
3505             self.mT31()
3506
3507
3508
3509         elif alt38 == 8:
3510             # C.g:1:38: T32
3511             self.mT32()
3512
3513
3514
3515         elif alt38 == 9:
3516             # C.g:1:42: T33
3517             self.mT33()
3518
3519
3520
3521         elif alt38 == 10:
3522             # C.g:1:46: T34
3523             self.mT34()
3524
3525
3526
3527         elif alt38 == 11:
3528             # C.g:1:50: T35
3529             self.mT35()
3530
3531
3532
3533         elif alt38 == 12:
3534             # C.g:1:54: T36
3535             self.mT36()
3536
3537
3538
3539         elif alt38 == 13:
3540             # C.g:1:58: T37
3541             self.mT37()
3542
3543
3544
3545         elif alt38 == 14:
3546             # C.g:1:62: T38
3547             self.mT38()
3548
3549
3550
3551         elif alt38 == 15:
3552             # C.g:1:66: T39
3553             self.mT39()
3554
3555
3556
3557         elif alt38 == 16:
3558             # C.g:1:70: T40
3559             self.mT40()
3560
3561
3562
3563         elif alt38 == 17:
3564             # C.g:1:74: T41
3565             self.mT41()
3566
3567
3568
3569         elif alt38 == 18:
3570             # C.g:1:78: T42
3571             self.mT42()
3572
3573
3574
3575         elif alt38 == 19:
3576             # C.g:1:82: T43
3577             self.mT43()
3578
3579
3580
3581         elif alt38 == 20:
3582             # C.g:1:86: T44
3583             self.mT44()
3584
3585
3586
3587         elif alt38 == 21:
3588             # C.g:1:90: T45
3589             self.mT45()
3590
3591
3592
3593         elif alt38 == 22:
3594             # C.g:1:94: T46
3595             self.mT46()
3596
3597
3598
3599         elif alt38 == 23:
3600             # C.g:1:98: T47
3601             self.mT47()
3602
3603
3604
3605         elif alt38 == 24:
3606             # C.g:1:102: T48
3607             self.mT48()
3608
3609
3610
3611         elif alt38 == 25:
3612             # C.g:1:106: T49
3613             self.mT49()
3614
3615
3616
3617         elif alt38 == 26:
3618             # C.g:1:110: T50
3619             self.mT50()
3620
3621
3622
3623         elif alt38 == 27:
3624             # C.g:1:114: T51
3625             self.mT51()
3626
3627
3628
3629         elif alt38 == 28:
3630             # C.g:1:118: T52
3631             self.mT52()
3632
3633
3634
3635         elif alt38 == 29:
3636             # C.g:1:122: T53
3637             self.mT53()
3638
3639
3640
3641         elif alt38 == 30:
3642             # C.g:1:126: T54
3643             self.mT54()
3644
3645
3646
3647         elif alt38 == 31:
3648             # C.g:1:130: T55
3649             self.mT55()
3650
3651
3652
3653         elif alt38 == 32:
3654             # C.g:1:134: T56
3655             self.mT56()
3656
3657
3658
3659         elif alt38 == 33:
3660             # C.g:1:138: T57
3661             self.mT57()
3662
3663
3664
3665         elif alt38 == 34:
3666             # C.g:1:142: T58
3667             self.mT58()
3668
3669
3670
3671         elif alt38 == 35:
3672             # C.g:1:146: T59
3673             self.mT59()
3674
3675
3676
3677         elif alt38 == 36:
3678             # C.g:1:150: T60
3679             self.mT60()
3680
3681
3682
3683         elif alt38 == 37:
3684             # C.g:1:154: T61
3685             self.mT61()
3686
3687
3688
3689         elif alt38 == 38:
3690             # C.g:1:158: T62
3691             self.mT62()
3692
3693
3694
3695         elif alt38 == 39:
3696             # C.g:1:162: T63
3697             self.mT63()
3698
3699
3700
3701         elif alt38 == 40:
3702             # C.g:1:166: T64
3703             self.mT64()
3704
3705
3706
3707         elif alt38 == 41:
3708             # C.g:1:170: T65
3709             self.mT65()
3710
3711
3712
3713         elif alt38 == 42:
3714             # C.g:1:174: T66
3715             self.mT66()
3716
3717
3718
3719         elif alt38 == 43:
3720             # C.g:1:178: T67
3721             self.mT67()
3722
3723
3724
3725         elif alt38 == 44:
3726             # C.g:1:182: T68
3727             self.mT68()
3728
3729
3730
3731         elif alt38 == 45:
3732             # C.g:1:186: T69
3733             self.mT69()
3734
3735
3736
3737         elif alt38 == 46:
3738             # C.g:1:190: T70
3739             self.mT70()
3740
3741
3742
3743         elif alt38 == 47:
3744             # C.g:1:194: T71
3745             self.mT71()
3746
3747
3748
3749         elif alt38 == 48:
3750             # C.g:1:198: T72
3751             self.mT72()
3752
3753
3754
3755         elif alt38 == 49:
3756             # C.g:1:202: T73
3757             self.mT73()
3758
3759
3760
3761         elif alt38 == 50:
3762             # C.g:1:206: T74
3763             self.mT74()
3764
3765
3766
3767         elif alt38 == 51:
3768             # C.g:1:210: T75
3769             self.mT75()
3770
3771
3772
3773         elif alt38 == 52:
3774             # C.g:1:214: T76
3775             self.mT76()
3776
3777
3778
3779         elif alt38 == 53:
3780             # C.g:1:218: T77
3781             self.mT77()
3782
3783
3784
3785         elif alt38 == 54:
3786             # C.g:1:222: T78
3787             self.mT78()
3788
3789
3790
3791         elif alt38 == 55:
3792             # C.g:1:226: T79
3793             self.mT79()
3794
3795
3796
3797         elif alt38 == 56:
3798             # C.g:1:230: T80
3799             self.mT80()
3800
3801
3802
3803         elif alt38 == 57:
3804             # C.g:1:234: T81
3805             self.mT81()
3806
3807
3808
3809         elif alt38 == 58:
3810             # C.g:1:238: T82
3811             self.mT82()
3812
3813
3814
3815         elif alt38 == 59:
3816             # C.g:1:242: T83
3817             self.mT83()
3818
3819
3820
3821         elif alt38 == 60:
3822             # C.g:1:246: T84
3823             self.mT84()
3824
3825
3826
3827         elif alt38 == 61:
3828             # C.g:1:250: T85
3829             self.mT85()
3830
3831
3832
3833         elif alt38 == 62:
3834             # C.g:1:254: T86
3835             self.mT86()
3836
3837
3838
3839         elif alt38 == 63:
3840             # C.g:1:258: T87
3841             self.mT87()
3842
3843
3844
3845         elif alt38 == 64:
3846             # C.g:1:262: T88
3847             self.mT88()
3848
3849
3850
3851         elif alt38 == 65:
3852             # C.g:1:266: T89
3853             self.mT89()
3854
3855
3856
3857         elif alt38 == 66:
3858             # C.g:1:270: T90
3859             self.mT90()
3860
3861
3862
3863         elif alt38 == 67:
3864             # C.g:1:274: T91
3865             self.mT91()
3866
3867
3868
3869         elif alt38 == 68:
3870             # C.g:1:278: T92
3871             self.mT92()
3872
3873
3874
3875         elif alt38 == 69:
3876             # C.g:1:282: T93
3877             self.mT93()
3878
3879
3880
3881         elif alt38 == 70:
3882             # C.g:1:286: T94
3883             self.mT94()
3884
3885
3886
3887         elif alt38 == 71:
3888             # C.g:1:290: T95
3889             self.mT95()
3890
3891
3892
3893         elif alt38 == 72:
3894             # C.g:1:294: T96
3895             self.mT96()
3896
3897
3898
3899         elif alt38 == 73:
3900             # C.g:1:298: T97
3901             self.mT97()
3902
3903
3904
3905         elif alt38 == 74:
3906             # C.g:1:302: T98
3907             self.mT98()
3908
3909
3910
3911         elif alt38 == 75:
3912             # C.g:1:306: T99
3913             self.mT99()
3914
3915
3916
3917         elif alt38 == 76:
3918             # C.g:1:310: T100
3919             self.mT100()
3920
3921
3922
3923         elif alt38 == 77:
3924             # C.g:1:315: T101
3925             self.mT101()
3926
3927
3928
3929         elif alt38 == 78:
3930             # C.g:1:320: T102
3931             self.mT102()
3932
3933
3934
3935         elif alt38 == 79:
3936             # C.g:1:325: T103
3937             self.mT103()
3938
3939
3940
3941         elif alt38 == 80:
3942             # C.g:1:330: T104
3943             self.mT104()
3944
3945
3946
3947         elif alt38 == 81:
3948             # C.g:1:335: T105
3949             self.mT105()
3950
3951
3952
3953         elif alt38 == 82:
3954             # C.g:1:340: T106
3955             self.mT106()
3956
3957
3958
3959         elif alt38 == 83:
3960             # C.g:1:345: T107
3961             self.mT107()
3962
3963
3964
3965         elif alt38 == 84:
3966             # C.g:1:350: T108
3967             self.mT108()
3968
3969
3970
3971         elif alt38 == 85:
3972             # C.g:1:355: T109
3973             self.mT109()
3974
3975
3976
3977         elif alt38 == 86:
3978             # C.g:1:360: IDENTIFIER
3979             self.mIDENTIFIER()
3980
3981
3982
3983         elif alt38 == 87:
3984             # C.g:1:371: CHARACTER_LITERAL
3985             self.mCHARACTER_LITERAL()
3986
3987
3988
3989         elif alt38 == 88:
3990             # C.g:1:389: STRING_LITERAL
3991             self.mSTRING_LITERAL()
3992
3993
3994
3995         elif alt38 == 89:
3996             # C.g:1:404: HEX_LITERAL
3997             self.mHEX_LITERAL()
3998
3999
4000
4001         elif alt38 == 90:
4002             # C.g:1:416: DECIMAL_LITERAL
4003             self.mDECIMAL_LITERAL()
4004
4005
4006
4007         elif alt38 == 91:
4008             # C.g:1:432: OCTAL_LITERAL
4009             self.mOCTAL_LITERAL()
4010
4011
4012
4013         elif alt38 == 92:
4014             # C.g:1:446: FLOATING_POINT_LITERAL
4015             self.mFLOATING_POINT_LITERAL()
4016
4017
4018
4019         elif alt38 == 93:
4020             # C.g:1:469: WS
4021             self.mWS()
4022
4023
4024
4025         elif alt38 == 94:
4026             # C.g:1:472: BS
4027             self.mBS()
4028
4029
4030
4031         elif alt38 == 95:
4032             # C.g:1:475: UnicodeVocabulary
4033             self.mUnicodeVocabulary()
4034
4035
4036
4037         elif alt38 == 96:
4038             # C.g:1:493: COMMENT
4039             self.mCOMMENT()
4040
4041
4042
4043         elif alt38 == 97:
4044             # C.g:1:501: LINE_COMMENT
4045             self.mLINE_COMMENT()
4046
4047
4048
4049         elif alt38 == 98:
4050             # C.g:1:514: LINE_COMMAND
4051             self.mLINE_COMMAND()
4052
4053
4054
4055
4056
4057
4058
4059
4060     # lookup tables for DFA #28
4061
4062     DFA28_eot = DFA.unpack(
4063         u"\7\uffff\1\10\2\uffff"
4064         )
4065
4066     DFA28_eof = DFA.unpack(
4067         u"\12\uffff"
4068         )
4069
4070     DFA28_min = DFA.unpack(
4071         u"\2\56\1\uffff\1\53\2\uffff\2\60\2\uffff"
4072         )
4073
4074     DFA28_max = DFA.unpack(
4075         u"\1\71\1\146\1\uffff\1\71\2\uffff\1\71\1\146\2\uffff"
4076         )
4077
4078     DFA28_accept = DFA.unpack(
4079         u"\2\uffff\1\2\1\uffff\1\4\1\1\2\uffff\2\3"
4080         )
4081
4082     DFA28_special = DFA.unpack(
4083         u"\12\uffff"
4084         )
4085
4086             
4087     DFA28_transition = [
4088         DFA.unpack(u"\1\2\1\uffff\12\1"),
4089         DFA.unpack(u"\1\5\1\uffff\12\1\12\uffff\1\4\1\3\1\4\35\uffff\1\4"
4090         u"\1\3\1\4"),
4091         DFA.unpack(u""),
4092         DFA.unpack(u"\1\6\1\uffff\1\6\2\uffff\12\7"),
4093         DFA.unpack(u""),
4094         DFA.unpack(u""),
4095         DFA.unpack(u"\12\7"),
4096         DFA.unpack(u"\12\7\12\uffff\1\11\1\uffff\1\11\35\uffff\1\11\1\uffff"
4097         u"\1\11"),
4098         DFA.unpack(u""),
4099         DFA.unpack(u"")
4100     ]
4101
4102     # class definition for DFA #28
4103
4104     DFA28 = DFA
4105     # lookup tables for DFA #38
4106
4107     DFA38_eot = DFA.unpack(
4108         u"\2\uffff\1\72\1\uffff\1\75\15\72\3\uffff\4\72\4\uffff\1\142\1\145"
4109         u"\1\150\1\154\1\160\1\162\1\165\1\uffff\1\170\1\173\1\176\1\u0080"
4110         u"\1\u0083\1\uffff\4\72\1\uffff\2\67\2\u008c\2\uffff\1\67\2\uffff"
4111         u"\1\72\4\uffff\16\72\1\u00a4\4\72\1\u00aa\3\72\3\uffff\1\u00af\4"
4112         u"\72\34\uffff\1\u00b5\3\uffff\1\u00b7\7\uffff\3\72\3\uffff\1\u00bb"
4113         u"\1\uffff\1\u008c\3\uffff\23\72\1\uffff\1\u00d0\2\72\1\u00d3\1\72"
4114         u"\1\uffff\4\72\1\uffff\1\u00d9\3\72\4\uffff\3\72\1\uffff\1\72\1"
4115         u"\u00e1\1\u00e2\7\72\1\u00ea\4\72\1\u00ef\2\72\1\u00f2\1\u00f3\1"
4116         u"\uffff\1\u00f4\1\72\1\uffff\5\72\1\uffff\4\72\1\u00ff\2\72\2\uffff"
4117         u"\5\72\1\u0107\1\72\1\uffff\4\72\1\uffff\1\u010d\1\72\3\uffff\1"
4118         u"\u010f\2\72\1\u0112\3\72\1\u0116\1\72\1\u0118\1\uffff\1\u0119\1"
4119         u"\72\1\u011b\1\u011c\1\u011d\1\u011e\1\u011f\1\uffff\1\u0120\1\72"
4120         u"\1\u0122\1\u0123\1\72\1\uffff\1\72\1\uffff\1\u0126\1\72\1\uffff"
4121         u"\3\72\1\uffff\1\u012b\2\uffff\1\u012c\6\uffff\1\72\2\uffff\2\72"
4122         u"\1\uffff\1\u0130\1\72\1\u0132\1\72\2\uffff\1\u0134\1\u0135\1\u0136"
4123         u"\1\uffff\1\u0137\1\uffff\1\u0138\5\uffff"
4124         )