Source/Python/Ecc/CLexer.py

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