BaseTools/Source/Python/Eot/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
   6 ## @file
   7 # The file defines the Lexer for C source files.
   8 #
   9 # THIS FILE IS AUTO-GENENERATED. PLEASE DON NOT MODIFY THIS FILE.
  10 # This file is generated by running:
  11 # java org.antlr.Tool C.g
  12 #
  13 # Copyright (c) 2009 - 2010, Intel Corporation. All rights reserved.<BR>
  14 #
  15 # This program and the accompanying materials are licensed and made available
  16 # under the terms and conditions of the BSD License which accompanies this
  17 # distribution.  The full text of the license may be found at:
  18 #   http://opensource.org/licenses/bsd-license.php
  19 #
  20 # THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  21 # WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  22 #
  23 ##
  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' )