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