from antlr3 import *

from antlr3.compat import set, frozenset

HIDDEN = BaseRecognizer.HIDDEN

T114=114

T115=115

T116=116

T117=117

FloatTypeSuffix=16

LETTER=11

T29=29

T28=28

T27=27

T26=26

T25=25

EOF=-1

STRING_LITERAL=9

FLOATING_POINT_LITERAL=10

T38=38

T37=37

T39=39

T34=34

COMMENT=22

T33=33

T36=36

T35=35

T30=30

T32=32

T31=31

LINE_COMMENT=23

IntegerTypeSuffix=14

CHARACTER_LITERAL=8

T49=49

T48=48

T100=100

T43=43

T42=42

T102=102

T41=41

T101=101

T40=40

T47=47

T46=46

T45=45

T44=44

T109=109

T107=107

T108=108

T105=105

WS=19

T106=106

T103=103

T104=104

T50=50

LINE_COMMAND=24

T59=59

T113=113

T52=52

T112=112

T51=51

T111=111

T54=54

T110=110

EscapeSequence=12

DECIMAL_LITERAL=7

T53=53

T56=56

T55=55

T58=58

T57=57

T75=75

T76=76

T73=73

T74=74

T79=79

T77=77

T78=78

Exponent=15

HexDigit=13

T72=72

T71=71

T70=70

T62=62

T63=63

T64=64

T65=65

T66=66

T67=67

T68=68

T69=69

IDENTIFIER=4

UnicodeVocabulary=21

HEX_LITERAL=5

T61=61

T60=60

T99=99

T97=97

BS=20

T98=98

T95=95

T96=96

OCTAL_LITERAL=6

T94=94

Tokens=118

T93=93

T92=92

T91=91

T90=90

T88=88

T89=89

T84=84

T85=85

T86=86

T87=87

UnicodeEscape=18

T81=81

T80=80

T83=83

OctalEscape=17

T82=82

class CLexer(Lexer):

grammarFileName = "C.g"

def __init__(self, input=None):

Lexer.__init__(self, input)

self.dfa25 = self.DFA25(

self, 25,

eot = self.DFA25_eot,

eof = self.DFA25_eof,

min = self.DFA25_min,

max = self.DFA25_max,

accept = self.DFA25_accept,

special = self.DFA25_special,

transition = self.DFA25_transition

)

self.dfa35 = self.DFA35(

self, 35,

eot = self.DFA35_eot,

eof = self.DFA35_eof,

min = self.DFA35_min,

max = self.DFA35_max,

accept = self.DFA35_accept,

special = self.DFA35_special,

transition = self.DFA35_transition

)

# $ANTLR start T25

def mT25(self, ):

try:

self.type = T25

# C.g:27:5: ( ';' )

# C.g:27:7: ';'

self.match(u';')

finally:

pass

# $ANTLR end T25

# $ANTLR start T26

def mT26(self, ):

try:

self.type = T26

# C.g:28:5: ( 'typedef' )

# C.g:28:7: 'typedef'

self.match("typedef")

finally:

pass

# $ANTLR end T26

# $ANTLR start T27

def mT27(self, ):

try:

self.type = T27

# C.g:29:5: ( ',' )

# C.g:29:7: ','

self.match(u',')

finally:

pass

# $ANTLR end T27

# $ANTLR start T28

def mT28(self, ):

try:

self.type = T28

# C.g:30:5: ( '=' )

# C.g:30:7: '='

self.match(u'=')

finally:

pass

# $ANTLR end T28

# $ANTLR start T29

def mT29(self, ):

try:

self.type = T29

# C.g:31:5: ( 'extern' )

# C.g:31:7: 'extern'

self.match("extern")

finally:

pass

# $ANTLR end T29

# $ANTLR start T30

def mT30(self, ):

try:

self.type = T30

# C.g:32:5: ( 'static' )

# C.g:32:7: 'static'

self.match("static")

finally:

pass

# $ANTLR end T30

# $ANTLR start T31

def mT31(self, ):

try:

self.type = T31

# C.g:33:5: ( 'auto' )

# C.g:33:7: 'auto'

self.match("auto")

finally:

pass

# $ANTLR end T31

# $ANTLR start T32

def mT32(self, ):

try:

self.type = T32

# C.g:34:5: ( 'register' )

# C.g:34:7: 'register'

self.match("register")

finally:

pass

# $ANTLR end T32

# $ANTLR start T33

def mT33(self, ):

try:

self.type = T33

# C.g:35:5: ( 'STATIC' )

# C.g:35:7: 'STATIC'

self.match("STATIC")

finally:

pass

# $ANTLR end T33

# $ANTLR start T34

def mT34(self, ):

try:

self.type = T34

# C.g:36:5: ( 'void' )

# C.g:36:7: 'void'

self.match("void")

finally:

pass

# $ANTLR end T34

# $ANTLR start T35

def mT35(self, ):

try:

self.type = T35

# C.g:37:5: ( 'char' )

# C.g:37:7: 'char'

self.match("char")

finally:

pass

# $ANTLR end T35

# $ANTLR start T36

def mT36(self, ):

try:

self.type = T36

# C.g:38:5: ( 'short' )

# C.g:38:7: 'short'

self.match("short")

finally:

pass

# $ANTLR end T36

# $ANTLR start T37

def mT37(self, ):

try:

self.type = T37

# C.g:39:5: ( 'int' )

# C.g:39:7: 'int'

self.match("int")

finally:

pass

# $ANTLR end T37

# $ANTLR start T38

def mT38(self, ):

try:

self.type = T38

# C.g:40:5: ( 'long' )

# C.g:40:7: 'long'

self.match("long")

finally:

pass

# $ANTLR end T38

# $ANTLR start T39

def mT39(self, ):

try:

self.type = T39

# C.g:41:5: ( 'float' )

# C.g:41:7: 'float'

self.match("float")

finally:

pass

# $ANTLR end T39

# $ANTLR start T40

def mT40(self, ):

try:

self.type = T40

# C.g:42:5: ( 'double' )

# C.g:42:7: 'double'

self.match("double")

finally:

pass

# $ANTLR end T40

# $ANTLR start T41

def mT41(self, ):

try:

self.type = T41

# C.g:43:5: ( 'signed' )

# C.g:43:7: 'signed'

self.match("signed")

finally:

pass

# $ANTLR end T41

# $ANTLR start T42

def mT42(self, ):

try:

self.type = T42

# C.g:44:5: ( 'unsigned' )

# C.g:44:7: 'unsigned'

self.match("unsigned")

finally:

pass

# $ANTLR end T42

# $ANTLR start T43

def mT43(self, ):

try:

self.type = T43

# C.g:45:5: ( '{' )

# C.g:45:7: '{'

self.match(u'{')

finally:

pass

# $ANTLR end T43

# $ANTLR start T44

def mT44(self, ):

try:

self.type = T44

# C.g:46:5: ( '}' )

# C.g:46:7: '}'

self.match(u'}')

finally:

pass

# $ANTLR end T44

# $ANTLR start T45

def mT45(self, ):

try:

self.type = T45

# C.g:47:5: ( 'struct' )

# C.g:47:7: 'struct'

self.match("struct")

finally:

pass

# $ANTLR end T45

# $ANTLR start T46

def mT46(self, ):

try:

self.type = T46

# C.g:48:5: ( 'union' )

# C.g:48:7: 'union'

self.match("union")

finally:

pass

# $ANTLR end T46

# $ANTLR start T47

def mT47(self, ):

try:

self.type = T47

# C.g:49:5: ( ':' )

# C.g:49:7: ':'

self.match(u':')

finally:

pass

# $ANTLR end T47

# $ANTLR start T48

def mT48(self, ):

try:

self.type = T48

# C.g:50:5: ( 'enum' )

# C.g:50:7: 'enum'

self.match("enum")

finally:

pass

# $ANTLR end T48

# $ANTLR start T49

def mT49(self, ):

try:

self.type = T49

# C.g:51:5: ( 'const' )

# C.g:51:7: 'const'

self.match("const")

finally:

pass

# $ANTLR end T49

# $ANTLR start T50

def mT50(self, ):

try:

self.type = T50

# C.g:52:5: ( 'volatile' )

# C.g:52:7: 'volatile'

self.match("volatile")

finally:

pass

# $ANTLR end T50

# $ANTLR start T51

def mT51(self, ):

try:

self.type = T51

# C.g:53:5: ( 'IN' )

# C.g:53:7: 'IN'

self.match("IN")

finally:

pass

# $ANTLR end T51

# $ANTLR start T52

def mT52(self, ):

try:

self.type = T52

# C.g:54:5: ( 'OUT' )

# C.g:54:7: 'OUT'

self.match("OUT")

finally:

pass

# $ANTLR end T52

# $ANTLR start T53

def mT53(self, ):

try:

self.type = T53

# C.g:55:5: ( 'OPTIONAL' )

# C.g:55:7: 'OPTIONAL'

self.match("OPTIONAL")

finally:

pass

# $ANTLR end T53

# $ANTLR start T54

def mT54(self, ):

try:

self.type = T54

# C.g:56:5: ( 'CONST' )

# C.g:56:7: 'CONST'

self.match("CONST")

finally:

pass

# $ANTLR end T54

# $ANTLR start T55

def mT55(self, ):

try:

self.type = T55

# C.g:57:5: ( 'UNALIGNED' )

# C.g:57:7: 'UNALIGNED'

self.match("UNALIGNED")

finally:

pass

# $ANTLR end T55

# $ANTLR start T56

def mT56(self, ):

try:

self.type = T56

# C.g:58:5: ( 'VOLATILE' )

# C.g:58:7: 'VOLATILE'

self.match("VOLATILE")

finally:

pass

# $ANTLR end T56

# $ANTLR start T57

def mT57(self, ):

try:

self.type = T57

# C.g:59:5: ( 'GLOBAL_REMOVE_IF_UNREFERENCED' )

# C.g:59:7: 'GLOBAL_REMOVE_IF_UNREFERENCED'

self.match("GLOBAL_REMOVE_IF_UNREFERENCED")

finally:

pass

# $ANTLR end T57

# $ANTLR start T58

def mT58(self, ):

try:

self.type = T58

# C.g:60:5: ( 'EFIAPI' )

# C.g:60:7: 'EFIAPI'

self.match("EFIAPI")

finally:

pass

# $ANTLR end T58

# $ANTLR start T59

def mT59(self, ):

try:

self.type = T59

# C.g:61:5: ( 'EFI_BOOTSERVICE' )

# C.g:61:7: 'EFI_BOOTSERVICE'

self.match("EFI_BOOTSERVICE")

finally:

pass

# $ANTLR end T59

# $ANTLR start T60

def mT60(self, ):

try:

self.type = T60

# C.g:62:5: ( 'EFI_RUNTIMESERVICE' )

# C.g:62:7: 'EFI_RUNTIMESERVICE'

self.match("EFI_RUNTIMESERVICE")

finally:

pass

# $ANTLR end T60

# $ANTLR start T61

def mT61(self, ):

try:

self.type = T61

# C.g:63:5: ( 'PACKED' )

# C.g:63:7: 'PACKED'

self.match("PACKED")

finally:

pass

# $ANTLR end T61

# $ANTLR start T62

def mT62(self, ):

try:

self.type = T62

# C.g:64:5: ( '(' )

# C.g:64:7: '('

self.match(u'(')

finally:

pass

# $ANTLR end T62

# $ANTLR start T63

def mT63(self, ):

try:

self.type = T63

# C.g:65:5: ( ')' )

# C.g:65:7: ')'

self.match(u')')

finally:

pass

# $ANTLR end T63

# $ANTLR start T64

def mT64(self, ):

try:

self.type = T64

# C.g:66:5: ( '[' )

# C.g:66:7: '['

self.match(u'[')

finally:

pass

# $ANTLR end T64

# $ANTLR start T65

def mT65(self, ):

try:

self.type = T65

# C.g:67:5: ( ']' )

# C.g:67:7: ']'

self.match(u']')

finally:

pass

# $ANTLR end T65

# $ANTLR start T66

def mT66(self, ):

try:

self.type = T66

# C.g:68:5: ( '*' )

# C.g:68:7: '*'

self.match(u'*')

finally:

pass

# $ANTLR end T66

# $ANTLR start T67

def mT67(self, ):

try:

self.type = T67

# C.g:69:5: ( '...' )

# C.g:69:7: '...'

self.match("...")

finally:

pass

# $ANTLR end T67

# $ANTLR start T68

def mT68(self, ):

try:

self.type = T68

# C.g:70:5: ( '+' )

# C.g:70:7: '+'

self.match(u'+')

finally:

pass

# $ANTLR end T68

# $ANTLR start T69

def mT69(self, ):

try:

self.type = T69

# C.g:71:5: ( '-' )

# C.g:71:7: '-'

self.match(u'-')

finally:

pass

# $ANTLR end T69

# $ANTLR start T70

def mT70(self, ):

try:

self.type = T70

# C.g:72:5: ( '/' )

# C.g:72:7: '/'

self.match(u'/')

finally:

pass

# $ANTLR end T70

# $ANTLR start T71

def mT71(self, ):

try:

self.type = T71

# C.g:73:5: ( '%' )

# C.g:73:7: '%'

self.match(u'%')

finally:

pass

# $ANTLR end T71

# $ANTLR start T72

def mT72(self, ):

try:

self.type = T72

# C.g:74:5: ( '++' )

# C.g:74:7: '++'

self.match("++")

finally:

pass

# $ANTLR end T72

# $ANTLR start T73

def mT73(self, ):

try:

self.type = T73

# C.g:75:5: ( '--' )

# C.g:75:7: '--'

self.match("--")

finally:

pass

# $ANTLR end T73

# $ANTLR start T74

def mT74(self, ):

try:

self.type = T74

# C.g:76:5: ( 'sizeof' )

# C.g:76:7: 'sizeof'

self.match("sizeof")

finally:

pass

# $ANTLR end T74

# $ANTLR start T75

def mT75(self, ):

try:

self.type = T75

# C.g:77:5: ( '.' )

# C.g:77:7: '.'

self.match(u'.')

finally:

pass

# $ANTLR end T75

# $ANTLR start T76

def mT76(self, ):

try:

self.type = T76

# C.g:78:5: ( '->' )

# C.g:78:7: '->'

self.match("->")

finally:

pass

# $ANTLR end T76

# $ANTLR start T77

def mT77(self, ):

try:

self.type = T77

# C.g:79:5: ( '&' )

# C.g:79:7: '&'

self.match(u'&')

finally:

pass

# $ANTLR end T77

# $ANTLR start T78

def mT78(self, ):

try:

self.type = T78

# C.g:80:5: ( '~' )

# C.g:80:7: '~'

self.match(u'~')

finally:

pass

# $ANTLR end T78

# $ANTLR start T79

def mT79(self, ):

try:

self.type = T79

# C.g:81:5: ( '!' )

# C.g:81:7: '!'

self.match(u'!')

finally:

pass

# $ANTLR end T79

# $ANTLR start T80

def mT80(self, ):

try:

self.type = T80

# C.g:82:5: ( '*=' )

# C.g:82:7: '*='

self.match("*=")

finally:

pass

# $ANTLR end T80

# $ANTLR start T81

def mT81(self, ):

try:

self.type = T81

# C.g:83:5: ( '/=' )

# C.g:83:7: '/='

self.match("/=")

finally:

pass

# $ANTLR end T81

# $ANTLR start T82

def mT82(self, ):

try:

self.type = T82

# C.g:84:5: ( '%=' )

# C.g:84:7: '%='

self.match("%=")

finally:

pass

# $ANTLR end T82

# $ANTLR start T83

def mT83(self, ):

try:

self.type = T83

# C.g:85:5: ( '+=' )

# C.g:85:7: '+='

self.match("+=")

finally:

pass

# $ANTLR end T83

# $ANTLR start T84

def mT84(self, ):

try:

self.type = T84

# C.g:86:5: ( '-=' )

# C.g:86:7: '-='

self.match("-=")

finally:

pass

# $ANTLR end T84

# $ANTLR start T85

def mT85(self, ):

try:

self.type = T85

# C.g:87:5: ( '<<=' )

# C.g:87:7: '<<='

self.match("<<=")

finally:

pass

# $ANTLR end T85

# $ANTLR start T86

def mT86(self, ):

try:

self.type = T86

# C.g:88:5: ( '>>=' )

# C.g:88:7: '>>='

self.match(">>=")

finally:

pass

# $ANTLR end T86

# $ANTLR start T87

def mT87(self, ):

try:

self.type = T87

# C.g:89:5: ( '&=' )

# C.g:89:7: '&='

self.match("&=")

finally:

pass

# $ANTLR end T87

# $ANTLR start T88

def mT88(self, ):

try:

self.type = T88

# C.g:90:5: ( '^=' )

# C.g:90:7: '^='

self.match("^=")

finally:

pass

# $ANTLR end T88

# $ANTLR start T89

def mT89(self, ):

try:

self.type = T89

# C.g:91:5: ( '|=' )

# C.g:91:7: '|='

self.match("|=")

finally:

pass

# $ANTLR end T89

# $ANTLR start T90

def mT90(self, ):

try:

self.type = T90

# C.g:92:5: ( '?' )

# C.g:92:7: '?'

self.match(u'?')

finally:

pass

# $ANTLR end T90

# $ANTLR start T91

def mT91(self, ):

try:

self.type = T91

# C.g:93:5: ( '||' )

# C.g:93:7: '||'

self.match("||")

finally:

pass

# $ANTLR end T91

# $ANTLR start T92

def mT92(self, ):

try:

self.type = T92

# C.g:94:5: ( '&&' )

# C.g:94:7: '&&'

self.match("&&")

finally:

pass

# $ANTLR end T92

# $ANTLR start T93

def mT93(self, ):

try:

self.type = T93

# C.g:95:5: ( '|' )

# C.g:95:7: '|'

self.match(u'|')

finally:

pass

# $ANTLR end T93

# $ANTLR start T94

def mT94(self, ):

try:

self.type = T94

# C.g:96:5: ( '^' )

# C.g:96:7: '^'

self.match(u'^')

finally:

pass

# $ANTLR end T94

# $ANTLR start T95

def mT95(self, ):

try:

self.type = T95

# C.g:97:5: ( '==' )

# C.g:97:7: '=='

self.match("==")

finally:

pass

# $ANTLR end T95

# $ANTLR start T96

def mT96(self, ):

try:

self.type = T96

# C.g:98:5: ( '!=' )

# C.g:98:7: '!='

self.match("!=")

finally:

pass

# $ANTLR end T96

# $ANTLR start T97

def mT97(self, ):

try:

self.type = T97

# C.g:99:5: ( '<' )

# C.g:99:7: '<'

self.match(u'<')

finally:

pass

# $ANTLR end T97

# $ANTLR start T98

def mT98(self, ):

try:

self.type = T98

# C.g:100:5: ( '>' )

# C.g:100:7: '>'

self.match(u'>')

finally:

pass

# $ANTLR end T98

# $ANTLR start T99

def mT99(self, ):

try:

self.type = T99

# C.g:101:5: ( '<=' )

# C.g:101:7: '<='

self.match("<=")

finally:

pass

# $ANTLR end T99

# $ANTLR start T100

def mT100(self, ):

try:

self.type = T100

# C.g:102:6: ( '>=' )

# C.g:102:8: '>='

self.match(">=")

finally:

pass

# $ANTLR end T100

# $ANTLR start T101

def mT101(self, ):

try:

self.type = T101

# C.g:103:6: ( '<<' )

# C.g:103:8: '<<'

self.match("<<")

finally:

pass

# $ANTLR end T101

# $ANTLR start T102

def mT102(self, ):

try:

self.type = T102

# C.g:104:6: ( '>>' )

# C.g:104:8: '>>'

self.match(">>")

finally:

pass

# $ANTLR end T102

# $ANTLR start T103

def mT103(self, ):

try:

self.type = T103

# C.g:105:6: ( '__asm__' )

# C.g:105:8: '__asm__'

self.match("__asm__")

finally:

pass

# $ANTLR end T103

# $ANTLR start T104

def mT104(self, ):

try:

self.type = T104

# C.g:106:6: ( '_asm' )

# C.g:106:8: '_asm'

self.match("_asm")

finally:

pass

# $ANTLR end T104

# $ANTLR start T105

def mT105(self, ):

try:

self.type = T105

# C.g:107:6: ( '__asm' )

# C.g:107:8: '__asm'

self.match("__asm")

finally:

pass

# $ANTLR end T105

# $ANTLR start T106

def mT106(self, ):

try:

self.type = T106

# C.g:108:6: ( 'case' )

# C.g:108:8: 'case'

self.match("case")

finally:

pass

# $ANTLR end T106

# $ANTLR start T107

def mT107(self, ):

try:

self.type = T107

# C.g:109:6: ( 'default' )

# C.g:109:8: 'default'

self.match("default")

finally:

pass

# $ANTLR end T107

# $ANTLR start T108

def mT108(self, ):

try:

self.type = T108

# C.g:110:6: ( 'if' )

# C.g:110:8: 'if'

self.match("if")

finally:

pass

# $ANTLR end T108

# $ANTLR start T109

def mT109(self, ):

try:

self.type = T109

# C.g:111:6: ( 'else' )

# C.g:111:8: 'else'

self.match("else")

finally:

pass

# $ANTLR end T109

# $ANTLR start T110

def mT110(self, ):

try:

self.type = T110

# C.g:112:6: ( 'switch' )

# C.g:112:8: 'switch'

self.match("switch")

finally:

pass

# $ANTLR end T110

# $ANTLR start T111

def mT111(self, ):

try:

self.type = T111

# C.g:113:6: ( 'while' )

# C.g:113:8: 'while'

self.match("while")

finally:

pass

# $ANTLR end T111

# $ANTLR start T112

def mT112(self, ):

try:

self.type = T112

# C.g:114:6: ( 'do' )

# C.g:114:8: 'do'

self.match("do")

finally:

pass

# $ANTLR end T112

# $ANTLR start T113

def mT113(self, ):

try:

self.type = T113

# C.g:115:6: ( 'for' )

# C.g:115:8: 'for'

self.match("for")

finally:

pass

# $ANTLR end T113

# $ANTLR start T114

def mT114(self, ):

try:

self.type = T114

# C.g:116:6: ( 'goto' )

# C.g:116:8: 'goto'

self.match("goto")

finally:

pass

# $ANTLR end T114

# $ANTLR start T115

def mT115(self, ):

try:

self.type = T115

# C.g:117:6: ( 'continue' )

# C.g:117:8: 'continue'

self.match("continue")

finally:

pass

# $ANTLR end T115

# $ANTLR start T116

def mT116(self, ):

try:

self.type = T116

# C.g:118:6: ( 'break' )

# C.g:118:8: 'break'

self.match("break")

finally:

pass

# $ANTLR end T116

# $ANTLR start T117

def mT117(self, ):

try:

self.type = T117

# C.g:119:6: ( 'return' )

# C.g:119:8: 'return'

self.match("return")

finally:

pass

# $ANTLR end T117

# $ANTLR start IDENTIFIER

def mIDENTIFIER(self, ):

try:

self.type = IDENTIFIER

# C.g:586:2: ( LETTER ( LETTER | '0' .. '9' )* )

# C.g:586:4: LETTER ( LETTER | '0' .. '9' )*

self.mLETTER()

# C.g:586:11: ( LETTER | '0' .. '9' )*

while True: #loop1

alt1 = 2

LA1_0 = self.input.LA(1)

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')) :

alt1 = 1

if alt1 == 1:

# C.g:

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'):

self.input.consume();

else:

mse = MismatchedSetException(None, self.input)

self.recover(mse)

raise mse

else:

break #loop1

finally:

pass

# $ANTLR end IDENTIFIER

# $ANTLR start LETTER

def mLETTER(self, ):

try:

# C.g:591:2: ( '$' | 'A' .. 'Z' | 'a' .. 'z' | '_' )

# C.g:

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'):

self.input.consume();

else:

mse = MismatchedSetException(None, self.input)

self.recover(mse)

raise mse

finally:

pass

# $ANTLR end LETTER

# $ANTLR start CHARACTER_LITERAL

def mCHARACTER_LITERAL(self, ):

try:

self.type = CHARACTER_LITERAL

# C.g:598:5: ( ( 'L' )? '\\'' ( EscapeSequence | ~ ( '\\'' | '\\\\' ) ) '\\'' )

# C.g:598:9: ( 'L' )? '\\'' ( EscapeSequence | ~ ( '\\'' | '\\\\' ) ) '\\''

# C.g:598:9: ( 'L' )?

alt2 = 2

LA2_0 = self.input.LA(1)

if (LA2_0 == u'L') :

alt2 = 1

if alt2 == 1:

# C.g:598:10: 'L'

self.match(u'L')

self.match(u'\'')

# C.g:598:21: ( EscapeSequence | ~ ( '\\'' | '\\\\' ) )

alt3 = 2

LA3_0 = self.input.LA(1)

if (LA3_0 == u'\\') :

alt3 = 1

elif ((u'\u0000' <= LA3_0 <= u'&') or (u'(' <= LA3_0 <= u'[') or (u']' <= LA3_0 <= u'\uFFFE')) :

alt3 = 2

else:

nvae = NoViableAltException("598:21: ( EscapeSequence | ~ ( '\\'' | '\\\\' ) )", 3, 0, self.input)

raise nvae

if alt3 == 1:

# C.g:598:23: EscapeSequence

self.mEscapeSequence()

elif alt3 == 2:

# C.g:598:40: ~ ( '\\'' | '\\\\' )

if (u'\u0000' <= self.input.LA(1) <= u'&') or (u'(' <= self.input.LA(1) <= u'[') or (u']' <= self.input.LA(1) <= u'\uFFFE'):

self.input.consume();

else:

mse = MismatchedSetException(None, self.input)

self.recover(mse)

raise mse

self.match(u'\'')

finally:

pass

# $ANTLR end CHARACTER_LITERAL

# $ANTLR start STRING_LITERAL

def mSTRING_LITERAL(self, ):

try:

self.type = STRING_LITERAL

# C.g:602:5: ( ( 'L' )? '\"' ( EscapeSequence | ~ ( '\\\\' | '\"' ) )* '\"' )

# C.g:602:8: ( 'L' )? '\"' ( EscapeSequence | ~ ( '\\\\' | '\"' ) )* '\"'

# C.g:602:8: ( 'L' )?

alt4 = 2

LA4_0 = self.input.LA(1)

if (LA4_0 == u'L') :

alt4 = 1

if alt4 == 1:

# C.g:602:9: 'L'

self.match(u'L')

self.match(u'"')

# C.g:602:19: ( EscapeSequence | ~ ( '\\\\' | '\"' ) )*

while True: #loop5

alt5 = 3

LA5_0 = self.input.LA(1)

if (LA5_0 == u'\\') :

alt5 = 1

elif ((u'\u0000' <= LA5_0 <= u'!') or (u'#' <= LA5_0 <= u'[') or (u']' <= LA5_0 <= u'\uFFFE')) :

alt5 = 2

if alt5 == 1:

# C.g:602:21: EscapeSequence

self.mEscapeSequence()

elif alt5 == 2:

# C.g:602:38: ~ ( '\\\\' | '\"' )

if (u'\u0000' <= self.input.LA(1) <= u'!') or (u'#' <= self.input.LA(1) <= u'[') or (u']' <= self.input.LA(1) <= u'\uFFFE'):

self.input.consume();

else:

mse = MismatchedSetException(None, self.input)

self.recover(mse)

raise mse

else:

break #loop5

self.match(u'"')

finally:

pass

# $ANTLR end STRING_LITERAL

# $ANTLR start HEX_LITERAL

def mHEX_LITERAL(self, ):

try:

self.type = HEX_LITERAL

# C.g:605:13: ( '0' ( 'x' | 'X' ) ( HexDigit )+ ( IntegerTypeSuffix )? )

# C.g:605:15: '0' ( 'x' | 'X' ) ( HexDigit )+ ( IntegerTypeSuffix )?

self.match(u'0')

if self.input.LA(1) == u'X' or self.input.LA(1) == u'x':

self.input.consume();

else:

mse = MismatchedSetException(None, self.input)

self.recover(mse)

raise mse

# C.g:605:29: ( HexDigit )+

cnt6 = 0

while True: #loop6

alt6 = 2

LA6_0 = self.input.LA(1)

if ((u'0' <= LA6_0 <= u'9') or (u'A' <= LA6_0 <= u'F') or (u'a' <= LA6_0 <= u'f')) :

alt6 = 1

if alt6 == 1:

# C.g:605:29: HexDigit

self.mHexDigit()

else:

if cnt6 >= 1:

break #loop6

eee = EarlyExitException(6, self.input)

raise eee

cnt6 += 1

# C.g:605:39: ( IntegerTypeSuffix )?

alt7 = 2

LA7_0 = self.input.LA(1)

if (LA7_0 == u'L' or LA7_0 == u'U' or LA7_0 == u'l' or LA7_0 == u'u') :

alt7 = 1

if alt7 == 1:

# C.g:605:39: IntegerTypeSuffix

self.mIntegerTypeSuffix()

finally:

pass

# $ANTLR end HEX_LITERAL

# $ANTLR start DECIMAL_LITERAL

def mDECIMAL_LITERAL(self, ):

try:

self.type = DECIMAL_LITERAL

# C.g:607:17: ( ( '0' | '1' .. '9' ( '0' .. '9' )* ) ( IntegerTypeSuffix )? )

# C.g:607:19: ( '0' | '1' .. '9' ( '0' .. '9' )* ) ( IntegerTypeSuffix )?

# C.g:607:19: ( '0' | '1' .. '9' ( '0' .. '9' )* )

alt9 = 2

LA9_0 = self.input.LA(1)

if (LA9_0 == u'0') :

alt9 = 1

elif ((u'1' <= LA9_0 <= u'9')) :

alt9 = 2

else:

nvae = NoViableAltException("607:19: ( '0' | '1' .. '9' ( '0' .. '9' )* )", 9, 0, self.input)

raise nvae

if alt9 == 1:

# C.g:607:20: '0'

self.match(u'0')

elif alt9 == 2:

# C.g:607:26: '1' .. '9' ( '0' .. '9' )*

self.matchRange(u'1', u'9')

# C.g:607:35: ( '0' .. '9' )*

while True: #loop8

alt8 = 2

LA8_0 = self.input.LA(1)

if ((u'0' <= LA8_0 <= u'9')) :

alt8 = 1

if alt8 == 1:

# C.g:607:35: '0' .. '9'

self.matchRange(u'0', u'9')

else:

break #loop8

# C.g:607:46: ( IntegerTypeSuffix )?

alt10 = 2

LA10_0 = self.input.LA(1)

if (LA10_0 == u'L' or LA10_0 == u'U' or LA10_0 == u'l' or LA10_0 == u'u') :

alt10 = 1

if alt10 == 1:

# C.g:607:46: IntegerTypeSuffix

self.mIntegerTypeSuffix()

finally:

pass

# $ANTLR end DECIMAL_LITERAL

# $ANTLR start OCTAL_LITERAL

def mOCTAL_LITERAL(self, ):

try:

self.type = OCTAL_LITERAL

# C.g:609:15: ( '0' ( '0' .. '7' )+ ( IntegerTypeSuffix )? )

# C.g:609:17: '0' ( '0' .. '7' )+ ( IntegerTypeSuffix )?

self.match(u'0')

# C.g:609:21: ( '0' .. '7' )+

cnt11 = 0

while True: #loop11

alt11 = 2

LA11_0 = self.input.LA(1)

if ((u'0' <= LA11_0 <= u'7')) :

alt11 = 1

if alt11 == 1:

# C.g:609:22: '0' .. '7'

self.matchRange(u'0', u'7')

else:

if cnt11 >= 1:

break #loop11

eee = EarlyExitException(11, self.input)

raise eee

cnt11 += 1

# C.g:609:33: ( IntegerTypeSuffix )?

alt12 = 2

LA12_0 = self.input.LA(1)

if (LA12_0 == u'L' or LA12_0 == u'U' or LA12_0 == u'l' or LA12_0 == u'u') :

alt12 = 1

if alt12 == 1:

# C.g:609:33: IntegerTypeSuffix

self.mIntegerTypeSuffix()

finally:

pass

# $ANTLR end OCTAL_LITERAL

# $ANTLR start HexDigit

def mHexDigit(self, ):

try:

# C.g:612:10: ( ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' ) )

# C.g:612:12: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' )

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'):

self.input.consume();

else:

mse = MismatchedSetException(None, self.input)

self.recover(mse)

raise mse

finally:

pass

# $ANTLR end HexDigit

# $ANTLR start IntegerTypeSuffix

def mIntegerTypeSuffix(self, ):

try:

# C.g:616:2: ( ( 'u' | 'U' ) | ( 'l' | 'L' ) | ( 'u' | 'U' ) ( 'l' | 'L' ) | ( 'u' | 'U' ) ( 'l' | 'L' ) ( 'l' | 'L' ) )

alt13 = 4

LA13_0 = self.input.LA(1)

if (LA13_0 == u'U' or LA13_0 == u'u') :

LA13_1 = self.input.LA(2)

if (LA13_1 == u'L' or LA13_1 == u'l') :

LA13_3 = self.input.LA(3)

if (LA13_3 == u'L' or LA13_3 == u'l') :

alt13 = 4

else:

alt13 = 3

else:

alt13 = 1

elif (LA13_0 == u'L' or LA13_0 == u'l') :

alt13 = 2

else:

nvae = NoViableAltException("614:1: fragment IntegerTypeSuffix : ( ( 'u' | 'U' ) | ( 'l' | 'L' ) | ( 'u' | 'U' ) ( 'l' | 'L' ) | ( 'u' | 'U' ) ( 'l' | 'L' ) ( 'l' | 'L' ) );", 13, 0, self.input)

raise nvae

if alt13 == 1:

# C.g:616:4: ( 'u' | 'U' )

if self.input.LA(1) == u'U' or self.input.LA(1) == u'u':

self.input.consume();

else:

mse = MismatchedSetException(None, self.input)

self.recover(mse)

raise mse

elif alt13 == 2:

# C.g:617:4: ( 'l' | 'L' )

if self.input.LA(1) == u'L' or self.input.LA(1) == u'l':

self.input.consume();

else:

mse = MismatchedSetException(None, self.input)

self.recover(mse)

raise mse

elif alt13 == 3:

# C.g:618:4: ( 'u' | 'U' ) ( 'l' | 'L' )

if self.input.LA(1) == u'U' or self.input.LA(1) == u'u':

self.input.consume();

else:

mse = MismatchedSetException(None, self.input)

self.recover(mse)

raise mse

if self.input.LA(1) == u'L' or self.input.LA(1) == u'l':

self.input.consume();

else:

mse = MismatchedSetException(None, self.input)

self.recover(mse)

raise mse

elif alt13 == 4:

# C.g:619:4: ( 'u' | 'U' ) ( 'l' | 'L' ) ( 'l' | 'L' )

if self.input.LA(1) == u'U' or self.input.LA(1) == u'u':

self.input.consume();

else:

mse = MismatchedSetException(None, self.input)

self.recover(mse)

raise mse

if self.input.LA(1) == u'L' or self.input.LA(1) == u'l':

self.input.consume();

else:

mse = MismatchedSetException(None, self.input)

self.recover(mse)

raise mse

if self.input.LA(1) == u'L' or self.input.LA(1) == u'l':

self.input.consume();

else:

mse = MismatchedSetException(None, self.input)

self.recover(mse)

raise mse

finally:

pass

# $ANTLR end IntegerTypeSuffix

# $ANTLR start FLOATING_POINT_LITERAL

def mFLOATING_POINT_LITERAL(self, ):

try:

self.type = FLOATING_POINT_LITERAL

# C.g:623:5: ( ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( Exponent )? ( FloatTypeSuffix )? | '.' ( '0' .. '9' )+ ( Exponent )? ( FloatTypeSuffix )? | ( '0' .. '9' )+ Exponent ( FloatTypeSuffix )? | ( '0' .. '9' )+ ( Exponent )? FloatTypeSuffix )

alt25 = 4

alt25 = self.dfa25.predict(self.input)

if alt25 == 1:

# C.g:623:9: ( '0' .. '9' )+ '.' ( '0' .. '9' )* ( Exponent )? ( FloatTypeSuffix )?

# C.g:623:9: ( '0' .. '9' )+

cnt14 = 0

while True: #loop14

alt14 = 2

LA14_0 = self.input.LA(1)

if ((u'0' <= LA14_0 <= u'9')) :

alt14 = 1

if alt14 == 1:

# C.g:623:10: '0' .. '9'

self.matchRange(u'0', u'9')

else:

if cnt14 >= 1:

break #loop14

eee = EarlyExitException(14, self.input)

raise eee

cnt14 += 1

self.match(u'.')

# C.g:623:25: ( '0' .. '9' )*

while True: #loop15

alt15 = 2

LA15_0 = self.input.LA(1)

if ((u'0' <= LA15_0 <= u'9')) :

alt15 = 1

if alt15 == 1:

# C.g:623:26: '0' .. '9'

self.matchRange(u'0', u'9')

else:

break #loop15

# C.g:623:37: ( Exponent )?

alt16 = 2

LA16_0 = self.input.LA(1)

if (LA16_0 == u'E' or LA16_0 == u'e') :

alt16 = 1

if alt16 == 1:

# C.g:623:37: Exponent

self.mExponent()

# C.g:623:47: ( FloatTypeSuffix )?

alt17 = 2

LA17_0 = self.input.LA(1)

if (LA17_0 == u'D' or LA17_0 == u'F' or LA17_0 == u'd' or LA17_0 == u'f') :

alt17 = 1

if alt17 == 1:

# C.g:623:47: FloatTypeSuffix

self.mFloatTypeSuffix()

elif alt25 == 2:

# C.g:624:9: '.' ( '0' .. '9' )+ ( Exponent )? ( FloatTypeSuffix )?

self.match(u'.')

# C.g:624:13: ( '0' .. '9' )+

cnt18 = 0

while True: #loop18

alt18 = 2

LA18_0 = self.input.LA(1)

if ((u'0' <= LA18_0 <= u'9')) :

alt18 = 1

if alt18 == 1:

# C.g:624:14: '0' .. '9'

self.matchRange(u'0', u'9')

else:

if cnt18 >= 1:

break #loop18

eee = EarlyExitException(18, self.input)

raise eee

cnt18 += 1

# C.g:624:25: ( Exponent )?

alt19 = 2

LA19_0 = self.input.LA(1)

if (LA19_0 == u'E' or LA19_0 == u'e') :

alt19 = 1

if alt19 == 1:

# C.g:624:25: Exponent

self.mExponent()

# C.g:624:35: ( FloatTypeSuffix )?

alt20 = 2

LA20_0 = self.input.LA(1)

if (LA20_0 == u'D' or LA20_0 == u'F' or LA20_0 == u'd' or LA20_0 == u'f') :

alt20 = 1

if alt20 == 1:

# C.g:624:35: FloatTypeSuffix

self.mFloatTypeSuffix()

elif alt25 == 3:

# C.g:625:9: ( '0' .. '9' )+ Exponent ( FloatTypeSuffix )?

# C.g:625:9: ( '0' .. '9' )+

cnt21 = 0

while True: #loop21

alt21 = 2

LA21_0 = self.input.LA(1)

if ((u'0' <= LA21_0 <= u'9')) :

alt21 = 1

if alt21 == 1:

# C.g:625:10: '0' .. '9'

self.matchRange(u'0', u'9')

else:

if cnt21 >= 1:

break #loop21

eee = EarlyExitException(21, self.input)

raise eee

cnt21 += 1

self.mExponent()

# C.g:625:30: ( FloatTypeSuffix )?

alt22 = 2

LA22_0 = self.input.LA(1)

if (LA22_0 == u'D' or LA22_0 == u'F' or LA22_0 == u'd' or LA22_0 == u'f') :

alt22 = 1

if alt22 == 1:

# C.g:625:30: FloatTypeSuffix

self.mFloatTypeSuffix()

elif alt25 == 4:

# C.g:626:9: ( '0' .. '9' )+ ( Exponent )? FloatTypeSuffix

# C.g:626:9: ( '0' .. '9' )+

cnt23 = 0

while True: #loop23

alt23 = 2

LA23_0 = self.input.LA(1)

if ((u'0' <= LA23_0 <= u'9')) :

alt23 = 1

if alt23 == 1:

# C.g:626:10: '0' .. '9'

self.matchRange(u'0', u'9')

else:

if cnt23 >= 1:

break #loop23

eee = EarlyExitException(23, self.input)

raise eee

cnt23 += 1

# C.g:626:21: ( Exponent )?

alt24 = 2

LA24_0 = self.input.LA(1)

if (LA24_0 == u'E' or LA24_0 == u'e') :

alt24 = 1

if alt24 == 1:

# C.g:626:21: Exponent

self.mExponent()

self.mFloatTypeSuffix()

finally:

pass

# $ANTLR end FLOATING_POINT_LITERAL

# $ANTLR start Exponent

def mExponent(self, ):

try:

# C.g:630:10: ( ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+ )

# C.g:630:12: ( 'e' | 'E' ) ( '+' | '-' )? ( '0' .. '9' )+

if self.input.LA(1) == u'E' or self.input.LA(1) == u'e':

self.input.consume();

else:

mse = MismatchedSetException(None, self.input)

self.recover(mse)

raise mse

# C.g:630:22: ( '+' | '-' )?

alt26 = 2

LA26_0 = self.input.LA(1)

if (LA26_0 == u'+' or LA26_0 == u'-') :

alt26 = 1

if alt26 == 1:

# C.g:

if self.input.LA(1) == u'+' or self.input.LA(1) == u'-':

self.input.consume();

else:

mse = MismatchedSetException(None, self.input)

self.recover(mse)

raise mse

# C.g:630:33: ( '0' .. '9' )+

cnt27 = 0

while True: #loop27

alt27 = 2

LA27_0 = self.input.LA(1)

if ((u'0' <= LA27_0 <= u'9')) :

alt27 = 1

if alt27 == 1:

# C.g:630:34: '0' .. '9'

self.matchRange(u'0', u'9')

else:

if cnt27 >= 1:

break #loop27

eee = EarlyExitException(27, self.input)

raise eee

cnt27 += 1

finally:

pass

# $ANTLR end Exponent

# $ANTLR start FloatTypeSuffix

def mFloatTypeSuffix(self, ):

try:

# C.g:633:17: ( ( 'f' | 'F' | 'd' | 'D' ) )

# C.g:633:19: ( 'f' | 'F' | 'd' | 'D' )

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':

self.input.consume();

else:

mse = MismatchedSetException(None, self.input)

self.recover(mse)

raise mse

finally:

pass

# $ANTLR end FloatTypeSuffix

# $ANTLR start EscapeSequence

def mEscapeSequence(self, ):

try:

# C.g:637:5: ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | OctalEscape )

alt28 = 2

LA28_0 = self.input.LA(1)

if (LA28_0 == u'\\') :

LA28_1 = self.input.LA(2)

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') :

alt28 = 1

elif ((u'0' <= LA28_1 <= u'7')) :

alt28 = 2

else:

nvae = NoViableAltException("635:1: fragment EscapeSequence : ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | OctalEscape );", 28, 1, self.input)

raise nvae

else:

nvae = NoViableAltException("635:1: fragment EscapeSequence : ( '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' ) | OctalEscape );", 28, 0, self.input)

raise nvae

if alt28 == 1:

# C.g:637:8: '\\\\' ( 'b' | 't' | 'n' | 'f' | 'r' | '\\\"' | '\\'' | '\\\\' )

self.match(u'\\')

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':

self.input.consume();

else:

mse = MismatchedSetException(None, self.input)

self.recover(mse)

raise mse

elif alt28 == 2:

# C.g:638:9: OctalEscape

self.mOctalEscape()

finally:

pass

# $ANTLR end EscapeSequence

# $ANTLR start OctalEscape

def mOctalEscape(self, ):

try:

# C.g:643:5: ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) )

alt29 = 3

LA29_0 = self.input.LA(1)

if (LA29_0 == u'\\') :

LA29_1 = self.input.LA(2)

if ((u'0' <= LA29_1 <= u'3')) :

LA29_2 = self.input.LA(3)

if ((u'0' <= LA29_2 <= u'7')) :

LA29_4 = self.input.LA(4)

if ((u'0' <= LA29_4 <= u'7')) :

alt29 = 1

else:

alt29 = 2

else:

alt29 = 3

elif ((u'4' <= LA29_1 <= u'7')) :

LA29_3 = self.input.LA(3)

if ((u'0' <= LA29_3 <= u'7')) :

alt29 = 2

else:

alt29 = 3

else:

nvae = NoViableAltException("641:1: fragment OctalEscape : ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) );", 29, 1, self.input)

raise nvae

else:

nvae = NoViableAltException("641:1: fragment OctalEscape : ( '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) ( '0' .. '7' ) | '\\\\' ( '0' .. '7' ) );", 29, 0, self.input)

raise nvae

if alt29 == 1:

# C.g:643:9: '\\\\' ( '0' .. '3' ) ( '0' .. '7' ) ( '0' .. '7' )

self.match(u'\\')

# C.g:643:14: ( '0' .. '3' )

# C.g:643:15: '0' .. '3'

self.matchRange(u'0', u'3')

# C.g:643:25: ( '0' .. '7' )

# C.g:643:26: '0' .. '7'

self.matchRange(u'0', u'7')

# C.g:643:36: ( '0' .. '7' )

# C.g:643:37: '0' .. '7'

self.matchRange(u'0', u'7')

elif alt29 == 2:

# C.g:644:9: '\\\\' ( '0' .. '7' ) ( '0' .. '7' )

self.match(u'\\')

# C.g:644:14: ( '0' .. '7' )

# C.g:644:15: '0' .. '7'

self.matchRange(u'0', u'7')

# C.g:644:25: ( '0' .. '7' )

# C.g:644:26: '0' .. '7'

self.matchRange(u'0', u'7')

elif alt29 == 3:

# C.g:645:9: '\\\\' ( '0' .. '7' )

self.match(u'\\')

# C.g:645:14: ( '0' .. '7' )

# C.g:645:15: '0' .. '7'

self.matchRange(u'0', u'7')

finally:

pass

# $ANTLR end OctalEscape

# $ANTLR start UnicodeEscape

def mUnicodeEscape(self, ):

try:

# C.g:650:5: ( '\\\\' 'u' HexDigit HexDigit HexDigit HexDigit )

# C.g:650:9: '\\\\' 'u' HexDigit HexDigit HexDigit HexDigit

self.match(u'\\')

self.match(u'u')

self.mHexDigit()

self.mHexDigit()

self.mHexDigit()

self.mHexDigit()

finally:

pass

# $ANTLR end UnicodeEscape

# $ANTLR start WS

def mWS(self, ):

try:

self.type = WS

# C.g:653:5: ( ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' ) )

# C.g:653:8: ( ' ' | '\\r' | '\\t' | '\\u000C' | '\\n' )

if (u'\t' <= self.input.LA(1) <= u'\n') or (u'\f' <= self.input.LA(1) <= u'\r') or self.input.LA(1) == u' ':

self.input.consume();

else:

mse = MismatchedSetException(None, self.input)

self.recover(mse)

raise mse

#action start

self.channel=HIDDEN;

#action end

finally:

pass

# $ANTLR end WS

# $ANTLR start BS

def mBS(self, ):

try:

self.type = BS

# C.g:657:5: ( ( '\\\\' ) )

# C.g:657:7: ( '\\\\' )

# C.g:657:7: ( '\\\\' )

# C.g:657:8: '\\\\'

self.match(u'\\')

#action start

self.channel=HIDDEN;

#action end

finally:

pass

# $ANTLR end BS

# $ANTLR start UnicodeVocabulary

def mUnicodeVocabulary(self, ):

try:

self.type = UnicodeVocabulary

# C.g:665:5: ( '\\u0003' .. '\\uFFFE' )

# C.g:665:7: '\\u0003' .. '\\uFFFE'

self.matchRange(u'\u0003', u'\uFFFE')

finally:

pass

# $ANTLR end UnicodeVocabulary

# $ANTLR start COMMENT

def mCOMMENT(self, ):

try:

self.type = COMMENT

# C.g:668:5: ( '/*' ( options {greedy=false; } : . )* '*/' )

# C.g:668:9: '/*' ( options {greedy=false; } : . )* '*/'

self.match("/*")

# C.g:668:14: ( options {greedy=false; } : . )*

while True: #loop30

alt30 = 2

LA30_0 = self.input.LA(1)

if (LA30_0 == u'*') :

LA30_1 = self.input.LA(2)

if (LA30_1 == u'/') :

alt30 = 2

elif ((u'\u0000' <= LA30_1 <= u'.') or (u'0' <= LA30_1 <= u'\uFFFE')) :

alt30 = 1

elif ((u'\u0000' <= LA30_0 <= u')') or (u'+' <= LA30_0 <= u'\uFFFE')) :

alt30 = 1

if alt30 == 1:

# C.g:668:42: .

self.matchAny()

else:

break #loop30

self.match("*/")

#action start

self.channel=HIDDEN;

#action end

finally:

pass

# $ANTLR end COMMENT

# $ANTLR start LINE_COMMENT

def mLINE_COMMENT(self, ):

try:

self.type = LINE_COMMENT

# C.g:673:5: ( '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' )

# C.g:673:7: '//' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'

self.match("//")

# C.g:673:12: (~ ( '\\n' | '\\r' ) )*

while True: #loop31

alt31 = 2

LA31_0 = self.input.LA(1)

if ((u'\u0000' <= LA31_0 <= u'\t') or (u'\u000B' <= LA31_0 <= u'\f') or (u'\u000E' <= LA31_0 <= u'\uFFFE')) :

alt31 = 1

if alt31 == 1:

# C.g:673:12: ~ ( '\\n' | '\\r' )

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'):

self.input.consume();

else:

mse = MismatchedSetException(None, self.input)

self.recover(mse)

raise mse

else:

break #loop31

# C.g:673:26: ( '\\r' )?

alt32 = 2

LA32_0 = self.input.LA(1)

if (LA32_0 == u'\r') :

alt32 = 1

if alt32 == 1:

# C.g:673:26: '\\r'

self.match(u'\r')

self.match(u'\n')

#action start

self.channel=HIDDEN;

#action end

finally:

pass

# $ANTLR end LINE_COMMENT

# $ANTLR start LINE_COMMAND

def mLINE_COMMAND(self, ):

try:

self.type = LINE_COMMAND

# C.g:678:5: ( '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n' )

# C.g:678:7: '#' (~ ( '\\n' | '\\r' ) )* ( '\\r' )? '\\n'

self.match(u'#')

# C.g:678:11: (~ ( '\\n' | '\\r' ) )*

while True: #loop33

alt33 = 2

LA33_0 = self.input.LA(1)

if ((u'\u0000' <= LA33_0 <= u'\t') or (u'\u000B' <= LA33_0 <= u'\f') or (u'\u000E' <= LA33_0 <= u'\uFFFE')) :

alt33 = 1

if alt33 == 1:

# C.g:678:11: ~ ( '\\n' | '\\r' )

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'):

self.input.consume();

else:

mse = MismatchedSetException(None, self.input)

self.recover(mse)

raise mse

else:

break #loop33

# C.g:678:25: ( '\\r' )?

alt34 = 2

LA34_0 = self.input.LA(1)

if (LA34_0 == u'\r') :

alt34 = 1

if alt34 == 1:

# C.g:678:25: '\\r'

self.match(u'\r')

self.match(u'\n')

#action start

self.channel=HIDDEN;

#action end

finally:

pass

# $ANTLR end LINE_COMMAND

def mTokens(self):

# C.g:1:8: ( T25 | T26 | T27 | T28 | T29 | T30 | T31 | T32 | T33 | T34 | T35 | T36 | T37 | T38 | T39 | T40 | T41 | T42 | T43 | T44 | T45 | T46 | T47 | T48 | T49 | T50 | T51 | T52 | T53 | T54 | T55 | T56 | T57 | T58 | T59 | T60 | T61 | T62 | T63 | T64 | T65 | T66 | T67 | T68 | T69 | T70 | T71 | T72 | T73 | T74 | T75 | T76 | T77 | T78 | T79 | T80 | T81 | T82 | T83 | T84 | T85 | T86 | T87 | T88 | T89 | T90 | T91 | T92 | T93 | T94 | T95 | T96 | T97 | T98 | T99 | T100 | T101 | T102 | T103 | T104 | T105 | T106 | T107 | T108 | T109 | T110 | T111 | T112 | T113 | T114 | T115 | T116 | T117 | IDENTIFIER | CHARACTER_LITERAL | STRING_LITERAL | HEX_LITERAL | DECIMAL_LITERAL | OCTAL_LITERAL | FLOATING_POINT_LITERAL | WS | BS | UnicodeVocabulary | COMMENT | LINE_COMMENT | LINE_COMMAND )

alt35 = 106

alt35 = self.dfa35.predict(self.input)

if alt35 == 1:

# C.g:1:10: T25

self.mT25()

elif alt35 == 2:

# C.g:1:14: T26

self.mT26()

elif alt35 == 3:

# C.g:1:18: T27

self.mT27()

elif alt35 == 4:

# C.g:1:22: T28

self.mT28()

elif alt35 == 5:

# C.g:1:26: T29

self.mT29()

elif alt35 == 6:

# C.g:1:30: T30

self.mT30()

elif alt35 == 7:

# C.g:1:34: T31

self.mT31()

elif alt35 == 8:

# C.g:1:38: T32

self.mT32()

elif alt35 == 9:

# C.g:1:42: T33

self.mT33()

elif alt35 == 10:

# C.g:1:46: T34

self.mT34()

elif alt35 == 11:

# C.g:1:50: T35

self.mT35()

elif alt35 == 12:

# C.g:1:54: T36