Coverage for src/pyensae/languages/CSharpParser.py: 36%

1# Generated from \CSharpParser.g4 by ANTLR 4.10.1

2# encoding: utf-8

3from antlr4 import *

4from io import StringIO

5import sys

6if sys.version_info[1] > 5:

7 from typing import TextIO

8else:

9 from typing.io import TextIO

11if __name__ is not None and "." in __name__:

12 from .CSharpParserBase import CSharpParserBase

13else:

14 from CSharpParserBase import CSharpParserBase

16def serializedATN():

17 return [

18 4,1,198,2644,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,

19 7,6,2,7,7,7,2,8,7,8,2,9,7,9,2,10,7,10,2,11,7,11,2,12,7,12,2,13,7,

20 13,2,14,7,14,2,15,7,15,2,16,7,16,2,17,7,17,2,18,7,18,2,19,7,19,2,

21 20,7,20,2,21,7,21,2,22,7,22,2,23,7,23,2,24,7,24,2,25,7,25,2,26,7,

22 26,2,27,7,27,2,28,7,28,2,29,7,29,2,30,7,30,2,31,7,31,2,32,7,32,2,

23 33,7,33,2,34,7,34,2,35,7,35,2,36,7,36,2,37,7,37,2,38,7,38,2,39,7,

24 39,2,40,7,40,2,41,7,41,2,42,7,42,2,43,7,43,2,44,7,44,2,45,7,45,2,

25 46,7,46,2,47,7,47,2,48,7,48,2,49,7,49,2,50,7,50,2,51,7,51,2,52,7,

26 52,2,53,7,53,2,54,7,54,2,55,7,55,2,56,7,56,2,57,7,57,2,58,7,58,2,

27 59,7,59,2,60,7,60,2,61,7,61,2,62,7,62,2,63,7,63,2,64,7,64,2,65,7,

28 65,2,66,7,66,2,67,7,67,2,68,7,68,2,69,7,69,2,70,7,70,2,71,7,71,2,

29 72,7,72,2,73,7,73,2,74,7,74,2,75,7,75,2,76,7,76,2,77,7,77,2,78,7,

30 78,2,79,7,79,2,80,7,80,2,81,7,81,2,82,7,82,2,83,7,83,2,84,7,84,2,

31 85,7,85,2,86,7,86,2,87,7,87,2,88,7,88,2,89,7,89,2,90,7,90,2,91,7,

32 91,2,92,7,92,2,93,7,93,2,94,7,94,2,95,7,95,2,96,7,96,2,97,7,97,2,

33 98,7,98,2,99,7,99,2,100,7,100,2,101,7,101,2,102,7,102,2,103,7,103,

34 2,104,7,104,2,105,7,105,2,106,7,106,2,107,7,107,2,108,7,108,2,109,

35 7,109,2,110,7,110,2,111,7,111,2,112,7,112,2,113,7,113,2,114,7,114,

36 2,115,7,115,2,116,7,116,2,117,7,117,2,118,7,118,2,119,7,119,2,120,

37 7,120,2,121,7,121,2,122,7,122,2,123,7,123,2,124,7,124,2,125,7,125,

38 2,126,7,126,2,127,7,127,2,128,7,128,2,129,7,129,2,130,7,130,2,131,

39 7,131,2,132,7,132,2,133,7,133,2,134,7,134,2,135,7,135,2,136,7,136,

40 2,137,7,137,2,138,7,138,2,139,7,139,2,140,7,140,2,141,7,141,2,142,

41 7,142,2,143,7,143,2,144,7,144,2,145,7,145,2,146,7,146,2,147,7,147,

42 2,148,7,148,2,149,7,149,2,150,7,150,2,151,7,151,2,152,7,152,2,153,

43 7,153,2,154,7,154,2,155,7,155,2,156,7,156,2,157,7,157,2,158,7,158,

44 2,159,7,159,2,160,7,160,2,161,7,161,2,162,7,162,2,163,7,163,2,164,

45 7,164,2,165,7,165,2,166,7,166,2,167,7,167,2,168,7,168,2,169,7,169,

46 2,170,7,170,2,171,7,171,2,172,7,172,2,173,7,173,2,174,7,174,2,175,

47 7,175,2,176,7,176,2,177,7,177,2,178,7,178,2,179,7,179,2,180,7,180,

48 2,181,7,181,2,182,7,182,2,183,7,183,2,184,7,184,2,185,7,185,2,186,

49 7,186,2,187,7,187,2,188,7,188,2,189,7,189,2,190,7,190,2,191,7,191,

50 2,192,7,192,2,193,7,193,2,194,7,194,2,195,7,195,2,196,7,196,2,197,

51 7,197,2,198,7,198,2,199,7,199,2,200,7,200,2,201,7,201,2,202,7,202,

52 2,203,7,203,2,204,7,204,2,205,7,205,2,206,7,206,2,207,7,207,2,208,

53 7,208,2,209,7,209,2,210,7,210,2,211,7,211,2,212,7,212,2,213,7,213,

54 2,214,7,214,2,215,7,215,2,216,7,216,2,217,7,217,1,0,3,0,438,8,0,

55 1,0,3,0,441,8,0,1,0,3,0,444,8,0,1,0,5,0,447,8,0,10,0,12,0,450,9,

56 0,1,0,3,0,453,8,0,1,0,1,0,1,1,1,1,3,1,459,8,1,1,1,3,1,462,8,1,1,

57 1,1,1,1,1,3,1,467,8,1,5,1,469,8,1,10,1,12,1,472,9,1,1,2,1,2,1,2,

58 1,2,5,2,478,8,2,10,2,12,2,481,9,2,1,3,1,3,1,3,1,3,1,3,3,3,488,8,

59 3,1,4,1,4,1,4,1,4,4,4,494,8,4,11,4,12,4,495,1,4,1,4,1,5,1,5,3,5,

60 502,8,5,1,6,1,6,3,6,506,8,6,1,7,1,7,1,7,3,7,511,8,7,1,8,1,8,1,9,

61 1,9,1,10,1,10,1,10,1,10,3,10,521,8,10,1,11,1,11,1,11,1,11,5,11,527,

62 8,11,10,11,12,11,530,9,11,1,11,1,11,1,12,1,12,1,12,5,12,537,8,12,

63 10,12,12,12,540,9,12,1,13,1,13,1,13,3,13,545,8,13,1,13,3,13,548,

64 8,13,1,13,1,13,3,13,552,8,13,1,13,1,13,1,14,1,14,1,14,1,14,3,14,

65 560,8,14,1,15,1,15,1,15,3,15,565,8,15,1,16,1,16,1,16,1,16,1,16,1,

66 16,1,16,1,16,3,16,575,8,16,1,17,1,17,1,17,1,17,1,17,1,17,1,17,1,

67 17,1,17,1,17,1,17,3,17,588,8,17,1,18,1,18,1,18,1,18,1,18,1,18,3,

68 18,596,8,18,1,19,1,19,1,19,1,19,3,19,602,8,19,3,19,604,8,19,1,20,

69 1,20,1,20,5,20,609,8,20,10,20,12,20,612,9,20,1,21,1,21,1,21,5,21,

70 617,8,21,10,21,12,21,620,9,21,1,22,1,22,1,22,5,22,625,8,22,10,22,

71 12,22,628,9,22,1,23,1,23,1,23,5,23,633,8,23,10,23,12,23,636,9,23,

72 1,24,1,24,1,24,5,24,641,8,24,10,24,12,24,644,9,24,1,25,1,25,1,25,

73 5,25,649,8,25,10,25,12,25,652,9,25,1,26,1,26,1,26,1,26,1,26,1,26,

74 1,26,5,26,661,8,26,10,26,12,26,664,9,26,1,27,1,27,1,27,3,27,669,

75 8,27,1,27,5,27,672,8,27,10,27,12,27,675,9,27,1,28,1,28,1,28,5,28,

76 680,8,28,10,28,12,28,683,9,28,1,29,1,29,1,29,5,29,688,8,29,10,29,

77 12,29,691,9,29,1,30,1,30,1,30,1,30,1,30,3,30,698,8,30,3,30,700,8,

78 30,1,30,3,30,703,8,30,1,31,1,31,1,31,5,31,708,8,31,10,31,12,31,711,

79 9,31,1,32,1,32,3,32,715,8,32,1,32,1,32,1,32,1,33,1,33,3,33,722,8,

80 33,1,33,1,33,3,33,726,8,33,3,33,728,8,33,1,34,1,34,1,34,1,34,1,34,

81 1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,

82 1,34,1,34,1,34,1,34,1,34,1,34,1,34,1,34,3,34,756,8,34,1,35,1,35,

83 3,35,760,8,35,1,35,5,35,763,8,35,10,35,12,35,766,9,35,1,35,3,35,

84 769,8,35,1,35,1,35,1,35,1,35,1,35,1,35,3,35,777,8,35,1,35,3,35,780,

85 8,35,1,35,5,35,783,8,35,10,35,12,35,786,9,35,1,35,3,35,789,8,35,

86 5,35,791,8,35,10,35,12,35,794,9,35,1,36,1,36,1,36,3,36,799,8,36,

87 1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,3,36,

88 813,8,36,1,36,1,36,1,36,1,36,3,36,819,8,36,1,36,1,36,1,36,1,36,1,

89 36,1,36,1,36,1,36,5,36,829,8,36,10,36,12,36,832,9,36,1,36,3,36,835,

90 8,36,1,36,4,36,838,8,36,11,36,12,36,839,1,36,1,36,3,36,844,8,36,

91 1,36,1,36,1,36,1,36,3,36,850,8,36,1,36,1,36,1,36,1,36,4,36,856,8,

92 36,11,36,12,36,857,1,36,1,36,1,36,1,36,1,36,1,36,1,36,3,36,867,8,

93 36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,36,1,

94 36,1,36,1,36,1,36,3,36,885,8,36,1,36,3,36,888,8,36,1,36,1,36,1,36,

95 3,36,893,8,36,1,36,3,36,896,8,36,1,36,1,36,1,36,1,36,1,36,1,36,1,

96 36,1,36,1,36,1,36,1,36,5,36,909,8,36,10,36,12,36,912,9,36,1,36,1,

97 36,1,36,3,36,917,8,36,1,37,1,37,3,37,921,8,37,1,38,1,38,1,38,1,39,

98 3,39,927,8,39,1,39,1,39,1,39,3,39,932,8,39,1,40,3,40,935,8,40,1,

99 40,1,40,1,40,1,40,5,40,941,8,40,10,40,12,40,944,9,40,1,40,1,40,1,

100 41,1,41,1,41,3,41,951,8,41,1,41,1,41,1,42,1,42,1,43,1,43,1,43,5,

101 43,960,8,43,10,43,12,43,963,9,43,1,44,1,44,3,44,967,8,44,1,45,1,

102 45,1,45,3,45,972,8,45,3,45,974,8,45,1,45,1,45,1,46,1,46,1,46,5,46,

103 981,8,46,10,46,12,46,984,9,46,1,47,1,47,1,47,1,47,1,47,3,47,991,

104 8,47,1,47,1,47,1,47,1,48,1,48,3,48,998,8,48,1,49,1,49,1,49,1,49,

105 5,49,1004,8,49,10,49,12,49,1007,9,49,1,49,3,49,1010,8,49,1,49,1,

106 49,1,50,1,50,1,50,1,50,1,50,3,50,1019,8,50,1,51,1,51,1,51,3,51,1024,

107 8,51,3,51,1026,8,51,1,51,1,51,1,52,1,52,1,52,5,52,1033,8,52,10,52,

108 12,52,1036,9,52,1,53,1,53,1,53,1,53,1,53,3,53,1043,8,53,1,54,1,54,

109 3,54,1047,8,54,1,54,1,54,1,54,3,54,1052,8,54,3,54,1054,8,54,1,54,

110 1,54,1,54,3,54,1059,8,54,5,54,1061,8,54,10,54,12,54,1064,9,54,1,

111 55,1,55,5,55,1068,8,55,10,55,12,55,1071,9,55,1,55,1,55,1,56,1,56,

112 1,56,5,56,1078,8,56,10,56,12,56,1081,9,56,1,56,3,56,1084,8,56,1,

113 56,3,56,1087,8,56,1,56,3,56,1090,8,56,1,57,1,57,1,57,1,57,5,57,1096,

114 8,57,10,57,12,57,1099,9,57,1,57,1,57,1,58,1,58,1,58,1,58,1,59,3,

115 59,1108,8,59,1,59,1,59,1,59,1,59,1,60,1,60,1,60,1,60,1,60,1,60,1,

116 60,1,60,1,60,1,60,1,60,3,60,1125,8,60,1,61,1,61,1,61,5,61,1130,8,

117 61,10,61,12,61,1133,9,61,1,62,3,62,1136,8,62,1,62,1,62,1,62,1,63,

118 1,63,1,63,5,63,1144,8,63,10,63,12,63,1147,9,63,1,64,1,64,3,64,1151,

119 8,64,1,65,1,65,1,65,1,66,1,66,3,66,1158,8,66,1,66,1,66,1,66,1,66,

120 1,67,5,67,1165,8,67,10,67,12,67,1168,9,67,1,67,1,67,3,67,1172,8,

121 67,1,68,1,68,1,68,1,68,1,68,3,68,1179,8,68,1,69,1,69,1,69,1,69,1,

122 69,1,70,1,70,1,70,1,71,1,71,3,71,1191,8,71,1,71,1,71,1,71,1,71,1,

123 71,1,71,1,71,1,71,1,71,3,71,1202,8,71,1,72,1,72,1,72,1,72,5,72,1208,

124 8,72,10,72,12,72,1211,9,72,1,73,1,73,3,73,1215,8,73,1,74,1,74,1,

125 74,1,74,1,74,1,74,1,74,3,74,1224,8,74,1,75,1,75,1,75,1,75,1,76,1,

126 76,1,76,3,76,1233,8,76,1,77,1,77,1,77,1,77,1,77,1,77,1,77,3,77,1242,

127 8,77,1,78,1,78,1,78,1,79,3,79,1248,8,79,1,79,1,79,1,79,3,79,1253,

128 8,79,1,79,1,79,3,79,1257,8,79,1,79,1,79,3,79,1261,8,79,1,80,1,80,

129 3,80,1265,8,80,1,80,1,80,3,80,1269,8,80,1,81,1,81,1,81,1,81,1,81,

130 3,81,1276,8,81,1,82,1,82,1,82,1,82,1,83,1,83,3,83,1284,8,83,1,84,

131 1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1297,8,84,

132 1,84,1,84,1,84,1,84,1,84,1,84,5,84,1305,8,84,10,84,12,84,1308,9,

133 84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,

134 84,1,84,1,84,1,84,1,84,1,84,1,84,3,84,1329,8,84,1,84,1,84,3,84,1333,

135 8,84,1,84,1,84,3,84,1337,8,84,1,84,1,84,1,84,3,84,1342,8,84,1,84,

136 1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,

137 1,84,1,84,1,84,1,84,3,84,1362,8,84,1,84,1,84,1,84,3,84,1367,8,84,

138 1,84,1,84,1,84,3,84,1372,8,84,1,84,1,84,1,84,1,84,1,84,3,84,1379,

139 8,84,1,84,3,84,1382,8,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,

140 1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,3,84,

141 1404,8,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,1,84,3,84,

142 1416,8,84,1,85,1,85,3,85,1420,8,85,1,85,1,85,1,86,1,86,1,86,1,86,

143 3,86,1428,8,86,1,86,1,86,1,86,1,86,1,86,1,86,5,86,1436,8,86,10,86,

144 12,86,1439,9,86,1,86,1,86,1,86,1,86,3,86,1445,8,86,1,87,1,87,3,87,

145 1449,8,87,1,88,1,88,1,88,3,88,1454,8,88,1,88,3,88,1457,8,88,1,89,

146 1,89,1,89,3,89,1462,8,89,1,90,1,90,1,90,1,90,1,91,1,91,3,91,1470,

147 8,91,1,92,4,92,1473,8,92,11,92,12,92,1474,1,92,1,92,1,93,1,93,1,

148 93,3,93,1482,8,93,1,93,1,93,1,93,1,93,3,93,1488,8,93,1,94,1,94,1,

149 94,1,95,4,95,1494,8,95,11,95,12,95,1495,1,96,1,96,1,96,1,96,5,96,

150 1502,8,96,10,96,12,96,1505,9,96,3,96,1507,8,96,1,97,1,97,1,97,5,

151 97,1512,8,97,10,97,12,97,1515,9,97,1,98,1,98,5,98,1519,8,98,10,98,

152 12,98,1522,9,98,1,98,3,98,1525,8,98,1,98,3,98,1528,8,98,1,99,1,99,

153 1,99,1,99,3,99,1534,8,99,1,99,1,99,3,99,1538,8,99,1,99,1,99,1,100,

154 1,100,3,100,1544,8,100,1,100,1,100,1,101,1,101,1,101,1,101,1,101,

155 1,102,1,102,1,102,1,103,1,103,3,103,1558,8,103,1,104,1,104,1,104,

156 1,104,3,104,1564,8,104,1,105,1,105,1,105,5,105,1569,8,105,10,105,

157 12,105,1572,9,105,1,106,1,106,3,106,1576,8,106,1,106,3,106,1579,

158 8,106,1,106,3,106,1582,8,106,1,106,1,106,1,107,4,107,1587,8,107,

159 11,107,12,107,1588,1,108,1,108,1,108,1,108,1,108,1,109,4,109,1597,

160 8,109,11,109,12,109,1598,1,110,1,110,1,110,1,110,1,110,1,110,1,110,

161 1,110,1,110,1,110,1,110,1,110,1,110,1,110,1,110,3,110,1616,8,110,

162 1,111,4,111,1619,8,111,11,111,12,111,1620,1,112,1,112,3,112,1625,

163 8,112,1,113,3,113,1628,8,113,1,113,3,113,1631,8,113,1,113,1,113,

164 1,113,1,113,1,113,3,113,1638,8,113,1,114,1,114,1,114,1,114,3,114,

165 1644,8,114,1,115,1,115,1,115,1,115,5,115,1650,8,115,10,115,12,115,

166 1653,9,115,1,115,1,115,1,116,3,116,1658,8,116,1,116,1,116,1,117,

167 1,117,1,117,1,117,5,117,1666,8,117,10,117,12,117,1669,9,117,1,118,

168 1,118,1,118,5,118,1674,8,118,10,118,12,118,1677,9,118,1,119,4,119,

169 1680,8,119,11,119,12,119,1681,1,120,1,120,1,120,1,120,1,120,1,121,

170 1,121,1,121,1,121,3,121,1693,8,121,1,121,1,121,3,121,1697,8,121,

171 3,121,1699,8,121,1,122,1,122,1,122,3,122,1704,8,122,1,122,1,122,

172 3,122,1708,8,122,1,123,1,123,1,123,5,123,1713,8,123,10,123,12,123,

173 1716,9,123,1,124,1,124,1,124,1,124,1,125,1,125,3,125,1724,8,125,

174 1,125,1,125,1,126,4,126,1729,8,126,11,126,12,126,1730,1,127,3,127,

175 1734,8,127,1,127,3,127,1737,8,127,1,127,1,127,3,127,1741,8,127,1,

176 128,4,128,1744,8,128,11,128,12,128,1745,1,129,1,129,1,130,1,130,

177 1,130,1,130,1,130,1,130,1,130,1,130,1,130,3,130,1759,8,130,1,130,

178 1,130,1,130,1,130,1,130,1,130,1,130,1,130,3,130,1769,8,130,1,131,

179 1,131,1,131,1,131,1,131,3,131,1776,8,131,1,131,1,131,1,131,1,131,

180 1,131,1,131,1,131,1,131,1,131,1,131,3,131,1788,8,131,1,132,1,132,

181 1,132,5,132,1793,8,132,10,132,12,132,1796,9,132,1,133,1,133,1,133,

182 1,133,1,134,1,134,1,134,5,134,1805,8,134,10,134,12,134,1808,9,134,

183 1,135,1,135,1,135,3,135,1813,8,135,1,136,1,136,3,136,1817,8,136,

184 1,137,1,137,3,137,1821,8,137,1,138,1,138,1,139,1,139,3,139,1827,

185 8,139,1,140,1,140,1,140,1,140,3,140,1833,8,140,3,140,1835,8,140,

186 1,141,1,141,1,141,5,141,1840,8,141,10,141,12,141,1843,9,141,1,142,

187 3,142,1846,8,142,1,142,3,142,1849,8,142,1,142,1,142,3,142,1853,8,

188 142,1,143,1,143,1,143,1,143,1,143,1,143,1,143,1,143,3,143,1863,8,

189 143,1,144,3,144,1866,8,144,1,144,1,144,1,144,1,144,1,145,3,145,1873,

190 8,145,1,145,3,145,1876,8,145,1,145,1,145,1,145,3,145,1881,8,145,

191 1,145,1,145,1,145,3,145,1886,8,145,3,145,1888,8,145,1,146,3,146,

192 1891,8,146,1,146,3,146,1894,8,146,1,146,1,146,1,146,1,147,3,147,

193 1900,8,147,1,147,3,147,1903,8,147,1,147,1,147,1,147,1,148,1,148,

194 1,148,1,148,1,148,1,148,1,148,3,148,1915,8,148,1,149,1,149,3,149,

195 1919,8,149,1,150,3,150,1922,8,150,1,150,1,150,1,150,1,150,1,150,

196 1,150,1,150,1,150,3,150,1932,8,150,1,151,3,151,1935,8,151,1,151,

197 1,151,1,151,1,152,3,152,1941,8,152,1,152,1,152,1,152,1,153,1,153,

198 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,

199 1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,1,153,3,153,1968,

200 8,153,1,154,1,154,1,154,1,154,1,154,1,154,1,154,1,155,1,155,1,155,

201 1,155,3,155,1981,8,155,1,155,1,155,1,156,1,156,3,156,1987,8,156,

202 1,157,1,157,1,157,1,158,1,158,5,158,1994,8,158,10,158,12,158,1997,

203 9,158,1,158,1,158,1,159,3,159,2002,8,159,1,159,3,159,2005,8,159,

204 1,159,1,159,1,159,1,159,4,159,2011,8,159,11,159,12,159,2012,1,159,

205 1,159,3,159,2017,8,159,1,160,1,160,5,160,2021,8,160,10,160,12,160,

206 2024,9,160,1,160,4,160,2027,8,160,11,160,12,160,2028,1,161,1,161,

207 5,161,2033,8,161,10,161,12,161,2036,9,161,1,161,1,161,1,162,1,162,

208 1,162,1,162,5,162,2044,8,162,10,162,12,162,2047,9,162,1,162,3,162,

209 2050,8,162,3,162,2052,8,162,1,162,1,162,1,163,1,163,1,163,1,163,

210 5,163,2060,8,163,10,163,12,163,2063,9,163,1,163,1,163,1,164,3,164,

211 2068,8,164,1,164,3,164,2071,8,164,1,164,1,164,1,165,1,165,1,166,

212 1,166,1,166,1,167,1,167,5,167,2082,8,167,10,167,12,167,2085,9,167,

213 1,167,1,167,1,168,3,168,2090,8,168,1,168,3,168,2093,8,168,1,168,

214 3,168,2096,8,168,1,168,1,168,1,168,1,168,1,168,3,168,2103,8,168,

215 1,168,1,168,1,168,3,168,2108,8,168,1,168,1,168,3,168,2112,8,168,

216 1,168,1,168,3,168,2116,8,168,1,168,1,168,1,168,1,168,1,168,1,168,

217 1,168,1,168,1,168,1,168,1,168,1,168,1,168,1,168,1,168,3,168,2133,

218 8,168,1,168,3,168,2136,8,168,1,168,1,168,1,168,3,168,2141,8,168,

219 1,168,1,168,3,168,2145,8,168,1,168,1,168,3,168,2149,8,168,1,168,

220 1,168,1,168,1,168,1,168,1,168,1,168,3,168,2158,8,168,1,169,3,169,

221 2161,8,169,1,169,1,169,1,169,3,169,2166,8,169,1,169,1,169,3,169,

222 2170,8,169,1,169,1,169,1,169,3,169,2175,8,169,1,169,1,169,3,169,

223 2179,8,169,3,169,2181,8,169,1,170,1,170,1,170,1,171,1,171,1,171,

224 1,171,5,171,2190,8,171,10,171,12,171,2193,9,171,1,171,3,171,2196,

225 8,171,3,171,2198,8,171,1,171,1,171,1,172,3,172,2203,8,172,1,172,

226 1,172,1,172,3,172,2208,8,172,1,173,1,173,1,173,1,173,1,173,3,173,

227 2215,8,173,1,173,1,173,1,174,1,174,3,174,2221,8,174,1,175,4,175,

228 2224,8,175,11,175,12,175,2225,1,176,1,176,1,176,1,176,3,176,2232,

229 8,176,1,176,1,176,3,176,2236,8,176,1,176,1,176,1,177,1,177,3,177,

230 2242,8,177,1,178,1,178,1,178,5,178,2247,8,178,10,178,12,178,2250,

231 9,178,1,179,1,179,1,179,1,179,1,179,5,179,2257,8,179,10,179,12,179,

232 2260,9,179,3,179,2262,8,179,1,179,3,179,2265,8,179,1,180,1,180,1,

233 180,3,180,2270,8,180,1,180,1,180,1,181,1,181,3,181,2276,8,181,1,

234 181,1,181,5,181,2280,8,181,10,181,12,181,2283,9,181,1,181,1,181,

235 1,181,1,181,3,181,2289,8,181,1,182,1,182,1,182,5,182,2294,8,182,

236 10,182,12,182,2297,9,182,1,183,1,183,1,183,1,183,1,184,3,184,2304,

237 8,184,1,184,1,184,3,184,2308,8,184,1,185,1,185,1,185,1,185,1,185,

238 1,186,1,186,1,186,1,186,1,186,1,186,1,186,1,186,3,186,2323,8,186,

239 1,186,1,186,3,186,2327,8,186,1,186,1,186,1,186,1,186,1,186,5,186,

240 2334,8,186,10,186,12,186,2337,9,186,1,186,3,186,2340,8,186,1,186,

241 1,186,3,186,2344,8,186,1,187,1,187,1,187,1,187,1,188,1,188,1,188,

242 1,188,1,189,1,189,1,189,1,189,1,190,1,190,1,190,1,190,1,190,1,190,

243 1,190,1,190,3,190,2366,8,190,1,191,1,191,1,192,1,192,1,192,1,192,

244 3,192,2374,8,192,1,193,1,193,5,193,2378,8,193,10,193,12,193,2381,

245 9,193,1,193,1,193,1,194,1,194,5,194,2387,8,194,10,194,12,194,2390,

246 9,194,1,194,1,194,1,195,1,195,1,195,1,195,3,195,2398,8,195,1,196,

247 1,196,1,196,1,196,3,196,2404,8,196,1,197,1,197,1,197,5,197,2409,

248 8,197,10,197,12,197,2412,9,197,1,197,1,197,4,197,2416,8,197,11,197,

249 12,197,2417,3,197,2420,8,197,1,198,1,198,1,199,1,199,1,199,3,199,

250 2427,8,199,1,199,3,199,2430,8,199,1,199,3,199,2433,8,199,1,199,1,

251 199,3,199,2437,8,199,1,200,3,200,2440,8,200,1,200,1,200,1,200,3,

252 200,2445,8,200,1,200,3,200,2448,8,200,1,200,3,200,2451,8,200,1,200,

253 1,200,3,200,2455,8,200,1,201,1,201,1,201,3,201,2460,8,201,1,201,

254 3,201,2463,8,201,1,201,3,201,2466,8,201,1,201,1,201,3,201,2470,8,

255 201,1,202,1,202,1,202,3,202,2475,8,202,1,202,1,202,3,202,2479,8,

256 202,1,203,1,203,1,203,1,203,3,203,2485,8,203,1,203,1,203,3,203,2489,

257 8,203,1,203,1,203,3,203,2493,8,203,1,203,1,203,1,204,1,204,1,204,

258 1,204,1,204,1,204,1,204,1,204,1,204,1,204,3,204,2507,8,204,1,205,

259 1,205,1,205,1,206,1,206,1,206,1,206,1,206,1,206,1,206,1,206,3,206,

260 2520,8,206,1,206,1,206,1,206,1,206,3,206,2526,8,206,1,207,1,207,

261 1,207,1,207,1,207,1,208,1,208,1,208,1,208,1,208,1,208,1,208,1,208,

262 1,208,1,208,1,208,1,208,3,208,2545,8,208,1,209,1,209,1,209,1,209,

263 1,209,1,209,1,210,1,210,1,210,3,210,2556,8,210,1,210,1,210,3,210,

264 2560,8,210,1,210,1,210,1,211,1,211,3,211,2566,8,211,1,211,1,211,

265 3,211,2570,8,211,1,211,1,211,3,211,2574,8,211,1,211,1,211,1,211,

266 1,211,1,211,3,211,2581,8,211,1,212,1,212,1,212,1,212,1,212,3,212,

267 2588,8,212,1,212,3,212,2591,8,212,1,212,1,212,5,212,2595,8,212,10,

268 212,12,212,2598,9,212,1,213,1,213,1,213,1,213,3,213,2604,8,213,1,

269 213,1,213,1,213,3,213,2609,8,213,1,213,3,213,2612,8,213,1,213,1,

270 213,1,213,1,213,1,213,1,213,3,213,2620,8,213,1,214,1,214,1,214,1,

271 214,3,214,2626,8,214,1,215,1,215,3,215,2630,8,215,1,215,1,215,1,

272 216,1,216,3,216,2636,8,216,1,216,1,216,3,216,2640,8,216,1,217,1,

273 217,1,217,0,0,218,0,2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32,

274 34,36,38,40,42,44,46,48,50,52,54,56,58,60,62,64,66,68,70,72,74,76,

275 78,80,82,84,86,88,90,92,94,96,98,100,102,104,106,108,110,112,114,

276 116,118,120,122,124,126,128,130,132,134,136,138,140,142,144,146,

277 148,150,152,154,156,158,160,162,164,166,168,170,172,174,176,178,

278 180,182,184,186,188,190,192,194,196,198,200,202,204,206,208,210,

279 212,214,216,218,220,222,224,226,228,230,232,234,236,238,240,242,

280 244,246,248,250,252,254,256,258,260,262,264,266,268,270,272,274,

281 276,278,280,282,284,286,288,290,292,294,296,298,300,302,304,306,

282 308,310,312,314,316,318,320,322,324,326,328,330,332,334,336,338,

283 340,342,344,346,348,350,352,354,356,358,360,362,364,366,368,370,

284 372,374,376,378,380,382,384,386,388,390,392,394,396,398,400,402,

285 404,406,408,410,412,414,416,418,420,422,424,426,428,430,432,434,

286 0,19,8,0,21,21,24,24,55,55,63,63,83,83,87,87,99,100,104,104,2,0,

287 34,34,45,45,3,0,54,54,72,72,80,80,1,0,156,157,2,0,146,147,158,159,

288 1,0,135,136,1,0,137,139,14,0,18,18,21,21,24,24,29,29,34,34,45,45,

289 55,55,63,63,68,68,83,83,87,87,91,91,99,100,104,104,2,0,14,14,32,

290 32,2,0,15,15,103,103,12,0,9,9,15,15,41,41,57,57,66,66,73,73,75,79,

291 84,84,90,90,103,103,107,107,109,109,2,0,40,40,53,53,2,0,17,17,94,

292 94,2,0,137,137,148,148,2,0,54,54,72,72,2,0,42,42,96,96,19,0,9,9,

293 13,13,17,19,21,31,33,34,36,37,39,47,50,50,52,57,59,59,62,63,65,68,

294 70,70,72,74,76,80,82,84,87,105,107,109,112,112,1,0,79,80,20,0,10,

295 12,14,16,20,20,32,32,35,35,38,38,48,49,51,51,58,58,60,61,64,64,69,

296 69,71,71,75,75,81,81,85,86,102,102,106,106,110,111,113,114,2914,

297 0,437,1,0,0,0,2,461,1,0,0,0,4,473,1,0,0,0,6,487,1,0,0,0,8,489,1,

298 0,0,0,10,499,1,0,0,0,12,505,1,0,0,0,14,510,1,0,0,0,16,512,1,0,0,

299 0,18,514,1,0,0,0,20,520,1,0,0,0,22,522,1,0,0,0,24,533,1,0,0,0,26,

300 544,1,0,0,0,28,559,1,0,0,0,30,564,1,0,0,0,32,574,1,0,0,0,34,587,

301 1,0,0,0,36,589,1,0,0,0,38,597,1,0,0,0,40,605,1,0,0,0,42,613,1,0,

302 0,0,44,621,1,0,0,0,46,629,1,0,0,0,48,637,1,0,0,0,50,645,1,0,0,0,

303 52,653,1,0,0,0,54,665,1,0,0,0,56,676,1,0,0,0,58,684,1,0,0,0,60,692,

304 1,0,0,0,62,704,1,0,0,0,64,712,1,0,0,0,66,727,1,0,0,0,68,755,1,0,

305 0,0,70,757,1,0,0,0,72,916,1,0,0,0,74,920,1,0,0,0,76,922,1,0,0,0,

306 78,926,1,0,0,0,80,934,1,0,0,0,82,950,1,0,0,0,84,954,1,0,0,0,86,956,

307 1,0,0,0,88,966,1,0,0,0,90,968,1,0,0,0,92,977,1,0,0,0,94,990,1,0,

308 0,0,96,997,1,0,0,0,98,999,1,0,0,0,100,1018,1,0,0,0,102,1020,1,0,

309 0,0,104,1029,1,0,0,0,106,1042,1,0,0,0,108,1044,1,0,0,0,110,1065,

310 1,0,0,0,112,1074,1,0,0,0,114,1091,1,0,0,0,116,1102,1,0,0,0,118,1107,

311 1,0,0,0,120,1124,1,0,0,0,122,1126,1,0,0,0,124,1135,1,0,0,0,126,1140,

312 1,0,0,0,128,1150,1,0,0,0,130,1152,1,0,0,0,132,1155,1,0,0,0,134,1166,

313 1,0,0,0,136,1178,1,0,0,0,138,1180,1,0,0,0,140,1185,1,0,0,0,142,1188,

314 1,0,0,0,144,1203,1,0,0,0,146,1212,1,0,0,0,148,1223,1,0,0,0,150,1225,

315 1,0,0,0,152,1232,1,0,0,0,154,1241,1,0,0,0,156,1243,1,0,0,0,158,1247,

316 1,0,0,0,160,1268,1,0,0,0,162,1275,1,0,0,0,164,1277,1,0,0,0,166,1283,

317 1,0,0,0,168,1415,1,0,0,0,170,1417,1,0,0,0,172,1444,1,0,0,0,174,1448,

318 1,0,0,0,176,1450,1,0,0,0,178,1461,1,0,0,0,180,1463,1,0,0,0,182,1469,

319 1,0,0,0,184,1472,1,0,0,0,186,1487,1,0,0,0,188,1489,1,0,0,0,190,1493,

320 1,0,0,0,192,1506,1,0,0,0,194,1508,1,0,0,0,196,1527,1,0,0,0,198,1529,

321 1,0,0,0,200,1541,1,0,0,0,202,1547,1,0,0,0,204,1552,1,0,0,0,206,1557,

322 1,0,0,0,208,1559,1,0,0,0,210,1565,1,0,0,0,212,1573,1,0,0,0,214,1586,

323 1,0,0,0,216,1590,1,0,0,0,218,1596,1,0,0,0,220,1615,1,0,0,0,222,1618,

324 1,0,0,0,224,1624,1,0,0,0,226,1627,1,0,0,0,228,1639,1,0,0,0,230,1645,

325 1,0,0,0,232,1657,1,0,0,0,234,1661,1,0,0,0,236,1670,1,0,0,0,238,1679,

326 1,0,0,0,240,1683,1,0,0,0,242,1698,1,0,0,0,244,1707,1,0,0,0,246,1709,

327 1,0,0,0,248,1717,1,0,0,0,250,1721,1,0,0,0,252,1728,1,0,0,0,254,1733,

328 1,0,0,0,256,1743,1,0,0,0,258,1747,1,0,0,0,260,1768,1,0,0,0,262,1775,

329 1,0,0,0,264,1789,1,0,0,0,266,1797,1,0,0,0,268,1801,1,0,0,0,270,1809,

330 1,0,0,0,272,1816,1,0,0,0,274,1820,1,0,0,0,276,1822,1,0,0,0,278,1826,

331 1,0,0,0,280,1834,1,0,0,0,282,1836,1,0,0,0,284,1852,1,0,0,0,286,1862,

332 1,0,0,0,288,1865,1,0,0,0,290,1872,1,0,0,0,292,1890,1,0,0,0,294,1899,

333 1,0,0,0,296,1914,1,0,0,0,298,1918,1,0,0,0,300,1921,1,0,0,0,302,1934,

334 1,0,0,0,304,1940,1,0,0,0,306,1967,1,0,0,0,308,1969,1,0,0,0,310,1976,

335 1,0,0,0,312,1986,1,0,0,0,314,1988,1,0,0,0,316,1991,1,0,0,0,318,2001,

336 1,0,0,0,320,2018,1,0,0,0,322,2030,1,0,0,0,324,2039,1,0,0,0,326,2055,

337 1,0,0,0,328,2067,1,0,0,0,330,2074,1,0,0,0,332,2076,1,0,0,0,334,2079,

338 1,0,0,0,336,2089,1,0,0,0,338,2160,1,0,0,0,340,2182,1,0,0,0,342,2185,

339 1,0,0,0,344,2202,1,0,0,0,346,2209,1,0,0,0,348,2220,1,0,0,0,350,2223,

340 1,0,0,0,352,2227,1,0,0,0,354,2241,1,0,0,0,356,2243,1,0,0,0,358,2251,

341 1,0,0,0,360,2269,1,0,0,0,362,2288,1,0,0,0,364,2290,1,0,0,0,366,2298,

342 1,0,0,0,368,2307,1,0,0,0,370,2309,1,0,0,0,372,2343,1,0,0,0,374,2345,

343 1,0,0,0,376,2349,1,0,0,0,378,2353,1,0,0,0,380,2365,1,0,0,0,382,2367,

344 1,0,0,0,384,2373,1,0,0,0,386,2375,1,0,0,0,388,2384,1,0,0,0,390,2397,

345 1,0,0,0,392,2403,1,0,0,0,394,2405,1,0,0,0,396,2421,1,0,0,0,398,2423,

346 1,0,0,0,400,2439,1,0,0,0,402,2456,1,0,0,0,404,2471,1,0,0,0,406,2480,

347 1,0,0,0,408,2496,1,0,0,0,410,2508,1,0,0,0,412,2511,1,0,0,0,414,2527,

348 1,0,0,0,416,2532,1,0,0,0,418,2546,1,0,0,0,420,2552,1,0,0,0,422,2563,

349 1,0,0,0,424,2587,1,0,0,0,426,2599,1,0,0,0,428,2621,1,0,0,0,430,2627,

350 1,0,0,0,432,2633,1,0,0,0,434,2641,1,0,0,0,436,438,5,1,0,0,437,436,

351 1,0,0,0,437,438,1,0,0,0,438,440,1,0,0,0,439,441,3,214,107,0,440,

352 439,1,0,0,0,440,441,1,0,0,0,441,443,1,0,0,0,442,444,3,218,109,0,

353 443,442,1,0,0,0,443,444,1,0,0,0,444,448,1,0,0,0,445,447,3,346,173,

354 0,446,445,1,0,0,0,447,450,1,0,0,0,448,446,1,0,0,0,448,449,1,0,0,

355 0,449,452,1,0,0,0,450,448,1,0,0,0,451,453,3,222,111,0,452,451,1,

356 0,0,0,452,453,1,0,0,0,453,454,1,0,0,0,454,455,5,0,0,1,455,1,1,0,

357 0,0,456,458,3,434,217,0,457,459,3,22,11,0,458,457,1,0,0,0,458,459,

358 1,0,0,0,459,462,1,0,0,0,460,462,3,228,114,0,461,456,1,0,0,0,461,

359 460,1,0,0,0,462,470,1,0,0,0,463,464,5,131,0,0,464,466,3,434,217,

360 0,465,467,3,22,11,0,466,465,1,0,0,0,466,467,1,0,0,0,467,469,1,0,

361 0,0,468,463,1,0,0,0,469,472,1,0,0,0,470,468,1,0,0,0,470,471,1,0,

362 0,0,471,3,1,0,0,0,472,470,1,0,0,0,473,479,3,6,3,0,474,478,5,148,

363 0,0,475,478,3,322,161,0,476,478,5,137,0,0,477,474,1,0,0,0,477,475,

364 1,0,0,0,477,476,1,0,0,0,478,481,1,0,0,0,479,477,1,0,0,0,479,480,

365 1,0,0,0,480,5,1,0,0,0,481,479,1,0,0,0,482,488,3,12,6,0,483,488,3,

366 20,10,0,484,485,5,108,0,0,485,488,5,137,0,0,486,488,3,8,4,0,487,

367 482,1,0,0,0,487,483,1,0,0,0,487,484,1,0,0,0,487,486,1,0,0,0,488,

368 7,1,0,0,0,489,490,5,129,0,0,490,493,3,10,5,0,491,492,5,132,0,0,492,

369 494,3,10,5,0,493,491,1,0,0,0,494,495,1,0,0,0,495,493,1,0,0,0,495,

370 496,1,0,0,0,496,497,1,0,0,0,497,498,5,130,0,0,498,9,1,0,0,0,499,

371 501,3,4,2,0,500,502,3,434,217,0,501,500,1,0,0,0,501,502,1,0,0,0,

372 502,11,1,0,0,0,503,506,3,14,7,0,504,506,5,18,0,0,505,503,1,0,0,0,

373 505,504,1,0,0,0,506,13,1,0,0,0,507,511,3,16,8,0,508,511,3,18,9,0,

374 509,511,5,29,0,0,510,507,1,0,0,0,510,508,1,0,0,0,510,509,1,0,0,0,

375 511,15,1,0,0,0,512,513,7,0,0,0,513,17,1,0,0,0,514,515,7,1,0,0,515,

376 19,1,0,0,0,516,521,3,2,1,0,517,521,5,68,0,0,518,521,5,35,0,0,519,

377 521,5,91,0,0,520,516,1,0,0,0,520,517,1,0,0,0,520,518,1,0,0,0,520,

378 519,1,0,0,0,521,21,1,0,0,0,522,523,5,146,0,0,523,528,3,4,2,0,524,

379 525,5,132,0,0,525,527,3,4,2,0,526,524,1,0,0,0,527,530,1,0,0,0,528,

380 526,1,0,0,0,528,529,1,0,0,0,529,531,1,0,0,0,530,528,1,0,0,0,531,

381 532,5,147,0,0,532,23,1,0,0,0,533,538,3,26,13,0,534,535,5,132,0,0,

382 535,537,3,26,13,0,536,534,1,0,0,0,537,540,1,0,0,0,538,536,1,0,0,

383 0,538,539,1,0,0,0,539,25,1,0,0,0,540,538,1,0,0,0,541,542,3,434,217,

384 0,542,543,5,133,0,0,543,545,1,0,0,0,544,541,1,0,0,0,544,545,1,0,

385 0,0,545,547,1,0,0,0,546,548,7,2,0,0,547,546,1,0,0,0,547,548,1,0,

386 0,0,548,551,1,0,0,0,549,552,5,106,0,0,550,552,3,4,2,0,551,549,1,

387 0,0,0,551,550,1,0,0,0,551,552,1,0,0,0,552,553,1,0,0,0,553,554,3,

388 28,14,0,554,27,1,0,0,0,555,560,3,32,16,0,556,560,3,30,15,0,557,558,

389 5,80,0,0,558,560,3,30,15,0,559,555,1,0,0,0,559,556,1,0,0,0,559,557,

390 1,0,0,0,560,29,1,0,0,0,561,565,3,118,59,0,562,565,3,130,65,0,563,

391 565,3,36,18,0,564,561,1,0,0,0,564,562,1,0,0,0,564,563,1,0,0,0,565,

392 31,1,0,0,0,566,567,3,68,34,0,567,568,3,34,17,0,568,569,3,28,14,0,

393 569,575,1,0,0,0,570,571,3,68,34,0,571,572,5,170,0,0,572,573,3,74,

394 37,0,573,575,1,0,0,0,574,566,1,0,0,0,574,570,1,0,0,0,575,33,1,0,

395 0,0,576,588,5,145,0,0,577,588,5,160,0,0,578,588,5,161,0,0,579,588,

396 5,162,0,0,580,588,5,163,0,0,581,588,5,164,0,0,582,588,5,165,0,0,

397 583,588,5,166,0,0,584,588,5,167,0,0,585,588,5,169,0,0,586,588,3,

398 378,189,0,587,576,1,0,0,0,587,577,1,0,0,0,587,578,1,0,0,0,587,579,

399 1,0,0,0,587,580,1,0,0,0,587,581,1,0,0,0,587,582,1,0,0,0,587,583,

400 1,0,0,0,587,584,1,0,0,0,587,585,1,0,0,0,587,586,1,0,0,0,588,35,1,

401 0,0,0,589,595,3,38,19,0,590,591,5,148,0,0,591,592,3,74,37,0,592,

402 593,5,133,0,0,593,594,3,74,37,0,594,596,1,0,0,0,595,590,1,0,0,0,

403 595,596,1,0,0,0,596,37,1,0,0,0,597,603,3,40,20,0,598,601,5,150,0,

404 0,599,602,3,38,19,0,600,602,3,76,38,0,601,599,1,0,0,0,601,600,1,

405 0,0,0,602,604,1,0,0,0,603,598,1,0,0,0,603,604,1,0,0,0,604,39,1,0,

406 0,0,605,610,3,42,21,0,606,607,5,154,0,0,607,609,3,42,21,0,608,606,

407 1,0,0,0,609,612,1,0,0,0,610,608,1,0,0,0,610,611,1,0,0,0,611,41,1,

408 0,0,0,612,610,1,0,0,0,613,618,3,44,22,0,614,615,5,153,0,0,615,617,

409 3,44,22,0,616,614,1,0,0,0,617,620,1,0,0,0,618,616,1,0,0,0,618,619,

410 1,0,0,0,619,43,1,0,0,0,620,618,1,0,0,0,621,626,3,46,23,0,622,623,

411 5,141,0,0,623,625,3,46,23,0,624,622,1,0,0,0,625,628,1,0,0,0,626,

412 624,1,0,0,0,626,627,1,0,0,0,627,45,1,0,0,0,628,626,1,0,0,0,629,634,

413 3,48,24,0,630,631,5,142,0,0,631,633,3,48,24,0,632,630,1,0,0,0,633,

414 636,1,0,0,0,634,632,1,0,0,0,634,635,1,0,0,0,635,47,1,0,0,0,636,634,

415 1,0,0,0,637,642,3,50,25,0,638,639,5,140,0,0,639,641,3,50,25,0,640,

416 638,1,0,0,0,641,644,1,0,0,0,642,640,1,0,0,0,642,643,1,0,0,0,643,

417 49,1,0,0,0,644,642,1,0,0,0,645,650,3,52,26,0,646,647,7,3,0,0,647,

418 649,3,52,26,0,648,646,1,0,0,0,649,652,1,0,0,0,650,648,1,0,0,0,650,

419 651,1,0,0,0,651,51,1,0,0,0,652,650,1,0,0,0,653,662,3,54,27,0,654,

420 655,7,4,0,0,655,661,3,54,27,0,656,657,5,59,0,0,657,661,3,112,56,

421 0,658,659,5,13,0,0,659,661,3,4,2,0,660,654,1,0,0,0,660,656,1,0,0,

422 0,660,658,1,0,0,0,661,664,1,0,0,0,662,660,1,0,0,0,662,663,1,0,0,

423 0,663,53,1,0,0,0,664,662,1,0,0,0,665,673,3,56,28,0,666,669,5,168,

424 0,0,667,669,3,376,188,0,668,666,1,0,0,0,668,667,1,0,0,0,669,670,

425 1,0,0,0,670,672,3,56,28,0,671,668,1,0,0,0,672,675,1,0,0,0,673,671,

426 1,0,0,0,673,674,1,0,0,0,674,55,1,0,0,0,675,673,1,0,0,0,676,681,3,

427 58,29,0,677,678,7,5,0,0,678,680,3,58,29,0,679,677,1,0,0,0,680,683,

428 1,0,0,0,681,679,1,0,0,0,681,682,1,0,0,0,682,57,1,0,0,0,683,681,1,

429 0,0,0,684,689,3,60,30,0,685,686,7,6,0,0,686,688,3,60,30,0,687,685,

430 1,0,0,0,688,691,1,0,0,0,689,687,1,0,0,0,689,690,1,0,0,0,690,59,1,

431 0,0,0,691,689,1,0,0,0,692,702,3,66,33,0,693,694,5,93,0,0,694,699,

432 5,125,0,0,695,697,3,62,31,0,696,698,5,132,0,0,697,696,1,0,0,0,697,

433 698,1,0,0,0,698,700,1,0,0,0,699,695,1,0,0,0,699,700,1,0,0,0,700,

434 701,1,0,0,0,701,703,5,126,0,0,702,693,1,0,0,0,702,703,1,0,0,0,703,

435 61,1,0,0,0,704,709,3,64,32,0,705,706,5,132,0,0,706,708,3,64,32,0,

436 707,705,1,0,0,0,708,711,1,0,0,0,709,707,1,0,0,0,709,710,1,0,0,0,

437 710,63,1,0,0,0,711,709,1,0,0,0,712,714,3,28,14,0,713,715,3,188,94,

438 0,714,713,1,0,0,0,714,715,1,0,0,0,715,716,1,0,0,0,716,717,3,374,

439 187,0,717,718,3,74,37,0,718,65,1,0,0,0,719,728,3,68,34,0,720,722,

440 3,68,34,0,721,720,1,0,0,0,721,722,1,0,0,0,722,723,1,0,0,0,723,725,

441 5,171,0,0,724,726,3,68,34,0,725,724,1,0,0,0,725,726,1,0,0,0,726,

442 728,1,0,0,0,727,719,1,0,0,0,727,721,1,0,0,0,728,67,1,0,0,0,729,756,

443 3,70,35,0,730,731,5,135,0,0,731,756,3,68,34,0,732,733,5,136,0,0,

444 733,756,3,68,34,0,734,735,5,143,0,0,735,756,3,68,34,0,736,737,5,

445 144,0,0,737,756,3,68,34,0,738,739,5,151,0,0,739,756,3,68,34,0,740,

446 741,5,152,0,0,741,756,3,68,34,0,742,743,5,129,0,0,743,744,3,4,2,

447 0,744,745,5,130,0,0,745,746,3,68,34,0,746,756,1,0,0,0,747,748,5,

448 16,0,0,748,756,3,68,34,0,749,750,5,140,0,0,750,756,3,68,34,0,751,

449 752,5,137,0,0,752,756,3,68,34,0,753,754,5,142,0,0,754,756,3,68,34,

450 0,755,729,1,0,0,0,755,730,1,0,0,0,755,732,1,0,0,0,755,734,1,0,0,

451 0,755,736,1,0,0,0,755,738,1,0,0,0,755,740,1,0,0,0,755,742,1,0,0,

452 0,755,747,1,0,0,0,755,749,1,0,0,0,755,751,1,0,0,0,755,753,1,0,0,

453 0,756,69,1,0,0,0,757,759,3,72,36,0,758,760,5,143,0,0,759,758,1,0,

454 0,0,759,760,1,0,0,0,760,764,1,0,0,0,761,763,3,80,40,0,762,761,1,

455 0,0,0,763,766,1,0,0,0,764,762,1,0,0,0,764,765,1,0,0,0,765,768,1,

456 0,0,0,766,764,1,0,0,0,767,769,5,143,0,0,768,767,1,0,0,0,768,769,

457 1,0,0,0,769,792,1,0,0,0,770,777,3,78,39,0,771,777,3,430,215,0,772,

458 777,5,151,0,0,773,777,5,152,0,0,774,775,5,155,0,0,775,777,3,434,

459 217,0,776,770,1,0,0,0,776,771,1,0,0,0,776,772,1,0,0,0,776,773,1,

460 0,0,0,776,774,1,0,0,0,777,779,1,0,0,0,778,780,5,143,0,0,779,778,

461 1,0,0,0,779,780,1,0,0,0,780,784,1,0,0,0,781,783,3,80,40,0,782,781,

462 1,0,0,0,783,786,1,0,0,0,784,782,1,0,0,0,784,785,1,0,0,0,785,788,

463 1,0,0,0,786,784,1,0,0,0,787,789,5,143,0,0,788,787,1,0,0,0,788,789,

464 1,0,0,0,789,791,1,0,0,0,790,776,1,0,0,0,791,794,1,0,0,0,792,790,

465 1,0,0,0,792,793,1,0,0,0,793,71,1,0,0,0,794,792,1,0,0,0,795,917,3,

466 380,190,0,796,798,3,434,217,0,797,799,3,22,11,0,798,797,1,0,0,0,

467 798,799,1,0,0,0,799,917,1,0,0,0,800,801,5,129,0,0,801,802,3,28,14,

468 0,802,803,5,130,0,0,803,917,1,0,0,0,804,917,3,84,42,0,805,917,3,

469 228,114,0,806,917,5,115,0,0,807,917,5,94,0,0,808,818,5,17,0,0,809,

470 810,5,131,0,0,810,812,3,434,217,0,811,813,3,22,11,0,812,811,1,0,

471 0,0,812,813,1,0,0,0,813,819,1,0,0,0,814,815,5,127,0,0,815,816,3,

472 86,43,0,816,817,5,128,0,0,817,819,1,0,0,0,818,809,1,0,0,0,818,814,

473 1,0,0,0,819,917,1,0,0,0,820,849,5,66,0,0,821,843,3,4,2,0,822,844,

474 3,432,216,0,823,844,3,88,44,0,824,825,5,127,0,0,825,826,3,86,43,

475 0,826,830,5,128,0,0,827,829,3,322,161,0,828,827,1,0,0,0,829,832,

476 1,0,0,0,830,828,1,0,0,0,830,831,1,0,0,0,831,834,1,0,0,0,832,830,

477 1,0,0,0,833,835,3,324,162,0,834,833,1,0,0,0,834,835,1,0,0,0,835,

478 844,1,0,0,0,836,838,3,322,161,0,837,836,1,0,0,0,838,839,1,0,0,0,

479 839,837,1,0,0,0,839,840,1,0,0,0,840,841,1,0,0,0,841,842,3,324,162,

480 0,842,844,1,0,0,0,843,822,1,0,0,0,843,823,1,0,0,0,843,824,1,0,0,

481 0,843,837,1,0,0,0,844,850,1,0,0,0,845,850,3,102,51,0,846,847,3,322,

482 161,0,847,848,3,324,162,0,848,850,1,0,0,0,849,821,1,0,0,0,849,845,

483 1,0,0,0,849,846,1,0,0,0,850,917,1,0,0,0,851,852,5,129,0,0,852,855,

484 3,26,13,0,853,854,5,132,0,0,854,856,3,26,13,0,855,853,1,0,0,0,856,

485 857,1,0,0,0,857,855,1,0,0,0,857,858,1,0,0,0,858,859,1,0,0,0,859,

486 860,5,130,0,0,860,917,1,0,0,0,861,862,5,98,0,0,862,866,5,129,0,0,

487 863,867,3,108,54,0,864,867,3,4,2,0,865,867,5,108,0,0,866,863,1,0,

488 0,0,866,864,1,0,0,0,866,865,1,0,0,0,867,868,1,0,0,0,868,917,5,130,

489 0,0,869,870,5,25,0,0,870,871,5,129,0,0,871,872,3,28,14,0,872,873,

490 5,130,0,0,873,917,1,0,0,0,874,875,5,101,0,0,875,876,5,129,0,0,876,

491 877,3,28,14,0,877,878,5,130,0,0,878,917,1,0,0,0,879,884,5,30,0,0,

492 880,881,5,129,0,0,881,882,3,4,2,0,882,883,5,130,0,0,883,885,1,0,

493 0,0,884,880,1,0,0,0,884,885,1,0,0,0,885,917,1,0,0,0,886,888,5,15,

494 0,0,887,886,1,0,0,0,887,888,1,0,0,0,888,889,1,0,0,0,889,895,5,31,

495 0,0,890,892,5,129,0,0,891,893,3,122,61,0,892,891,1,0,0,0,892,893,

496 1,0,0,0,893,894,1,0,0,0,894,896,5,130,0,0,895,890,1,0,0,0,895,896,

497 1,0,0,0,896,897,1,0,0,0,897,917,3,170,85,0,898,899,5,88,0,0,899,

498 900,5,129,0,0,900,901,3,4,2,0,901,902,5,130,0,0,902,917,1,0,0,0,

499 903,904,5,64,0,0,904,910,5,129,0,0,905,906,3,434,217,0,906,907,5,

500 131,0,0,907,909,1,0,0,0,908,905,1,0,0,0,909,912,1,0,0,0,910,908,

501 1,0,0,0,910,911,1,0,0,0,911,913,1,0,0,0,912,910,1,0,0,0,913,914,

502 3,434,217,0,914,915,5,130,0,0,915,917,1,0,0,0,916,795,1,0,0,0,916,

503 796,1,0,0,0,916,800,1,0,0,0,916,804,1,0,0,0,916,805,1,0,0,0,916,

504 806,1,0,0,0,916,807,1,0,0,0,916,808,1,0,0,0,916,820,1,0,0,0,916,

505 851,1,0,0,0,916,861,1,0,0,0,916,869,1,0,0,0,916,874,1,0,0,0,916,

506 879,1,0,0,0,916,887,1,0,0,0,916,898,1,0,0,0,916,903,1,0,0,0,917,

507 73,1,0,0,0,918,921,3,28,14,0,919,921,3,76,38,0,920,918,1,0,0,0,920,

508 919,1,0,0,0,921,75,1,0,0,0,922,923,5,95,0,0,923,924,3,28,14,0,924,

509 77,1,0,0,0,925,927,5,148,0,0,926,925,1,0,0,0,926,927,1,0,0,0,927,

510 928,1,0,0,0,928,929,5,131,0,0,929,931,3,434,217,0,930,932,3,22,11,

511 0,931,930,1,0,0,0,931,932,1,0,0,0,932,79,1,0,0,0,933,935,5,148,0,

512 0,934,933,1,0,0,0,934,935,1,0,0,0,935,936,1,0,0,0,936,937,5,127,

513 0,0,937,942,3,82,41,0,938,939,5,132,0,0,939,941,3,82,41,0,940,938,

514 1,0,0,0,941,944,1,0,0,0,942,940,1,0,0,0,942,943,1,0,0,0,943,945,

515 1,0,0,0,944,942,1,0,0,0,945,946,5,128,0,0,946,81,1,0,0,0,947,948,

516 3,434,217,0,948,949,5,133,0,0,949,951,1,0,0,0,950,947,1,0,0,0,950,

517 951,1,0,0,0,951,952,1,0,0,0,952,953,3,28,14,0,953,83,1,0,0,0,954,

518 955,7,7,0,0,955,85,1,0,0,0,956,961,3,28,14,0,957,958,5,132,0,0,958,

519 960,3,28,14,0,959,957,1,0,0,0,960,963,1,0,0,0,961,959,1,0,0,0,961,

520 962,1,0,0,0,962,87,1,0,0,0,963,961,1,0,0,0,964,967,3,90,45,0,965,

521 967,3,98,49,0,966,964,1,0,0,0,966,965,1,0,0,0,967,89,1,0,0,0,968,

522 973,5,125,0,0,969,971,3,92,46,0,970,972,5,132,0,0,971,970,1,0,0,

523 0,971,972,1,0,0,0,972,974,1,0,0,0,973,969,1,0,0,0,973,974,1,0,0,

524 0,974,975,1,0,0,0,975,976,5,126,0,0,976,91,1,0,0,0,977,982,3,94,

525 47,0,978,979,5,132,0,0,979,981,3,94,47,0,980,978,1,0,0,0,981,984,

526 1,0,0,0,982,980,1,0,0,0,982,983,1,0,0,0,983,93,1,0,0,0,984,982,1,

527 0,0,0,985,991,3,434,217,0,986,987,5,127,0,0,987,988,3,28,14,0,988,

528 989,5,128,0,0,989,991,1,0,0,0,990,985,1,0,0,0,990,986,1,0,0,0,991,

529 992,1,0,0,0,992,993,5,145,0,0,993,994,3,96,48,0,994,95,1,0,0,0,995,

530 998,3,28,14,0,996,998,3,88,44,0,997,995,1,0,0,0,997,996,1,0,0,0,

531 998,97,1,0,0,0,999,1000,5,125,0,0,1000,1005,3,100,50,0,1001,1002,

532 5,132,0,0,1002,1004,3,100,50,0,1003,1001,1,0,0,0,1004,1007,1,0,0,

533 0,1005,1003,1,0,0,0,1005,1006,1,0,0,0,1006,1009,1,0,0,0,1007,1005,

534 1,0,0,0,1008,1010,5,132,0,0,1009,1008,1,0,0,0,1009,1010,1,0,0,0,

535 1010,1011,1,0,0,0,1011,1012,5,126,0,0,1012,99,1,0,0,0,1013,1019,

536 3,30,15,0,1014,1015,5,125,0,0,1015,1016,3,86,43,0,1016,1017,5,126,

537 0,0,1017,1019,1,0,0,0,1018,1013,1,0,0,0,1018,1014,1,0,0,0,1019,101,

538 1,0,0,0,1020,1025,5,125,0,0,1021,1023,3,104,52,0,1022,1024,5,132,

539 0,0,1023,1022,1,0,0,0,1023,1024,1,0,0,0,1024,1026,1,0,0,0,1025,1021,

540 1,0,0,0,1025,1026,1,0,0,0,1026,1027,1,0,0,0,1027,1028,5,126,0,0,

541 1028,103,1,0,0,0,1029,1034,3,106,53,0,1030,1031,5,132,0,0,1031,1033,

542 3,106,53,0,1032,1030,1,0,0,0,1033,1036,1,0,0,0,1034,1032,1,0,0,0,

543 1034,1035,1,0,0,0,1035,105,1,0,0,0,1036,1034,1,0,0,0,1037,1043,3,

544 70,35,0,1038,1039,3,434,217,0,1039,1040,5,145,0,0,1040,1041,3,28,

545 14,0,1041,1043,1,0,0,0,1042,1037,1,0,0,0,1042,1038,1,0,0,0,1043,

546 107,1,0,0,0,1044,1053,3,434,217,0,1045,1047,3,110,55,0,1046,1045,

547 1,0,0,0,1046,1047,1,0,0,0,1047,1054,1,0,0,0,1048,1049,5,149,0,0,

548 1049,1051,3,434,217,0,1050,1052,3,110,55,0,1051,1050,1,0,0,0,1051,

549 1052,1,0,0,0,1052,1054,1,0,0,0,1053,1046,1,0,0,0,1053,1048,1,0,0,

550 0,1054,1062,1,0,0,0,1055,1056,5,131,0,0,1056,1058,3,434,217,0,1057,

551 1059,3,110,55,0,1058,1057,1,0,0,0,1058,1059,1,0,0,0,1059,1061,1,

552 0,0,0,1060,1055,1,0,0,0,1061,1064,1,0,0,0,1062,1060,1,0,0,0,1062,

553 1063,1,0,0,0,1063,109,1,0,0,0,1064,1062,1,0,0,0,1065,1069,5,146,

554 0,0,1066,1068,5,132,0,0,1067,1066,1,0,0,0,1068,1071,1,0,0,0,1069,

555 1067,1,0,0,0,1069,1070,1,0,0,0,1070,1072,1,0,0,0,1071,1069,1,0,0,

556 0,1072,1073,5,147,0,0,1073,111,1,0,0,0,1074,1079,3,6,3,0,1075,1078,

557 3,322,161,0,1076,1078,5,137,0,0,1077,1075,1,0,0,0,1077,1076,1,0,

558 0,0,1078,1081,1,0,0,0,1079,1077,1,0,0,0,1079,1080,1,0,0,0,1080,1083,

559 1,0,0,0,1081,1079,1,0,0,0,1082,1084,5,148,0,0,1083,1082,1,0,0,0,

560 1083,1084,1,0,0,0,1084,1086,1,0,0,0,1085,1087,3,114,57,0,1086,1085,

561 1,0,0,0,1086,1087,1,0,0,0,1087,1089,1,0,0,0,1088,1090,3,434,217,

562 0,1089,1088,1,0,0,0,1089,1090,1,0,0,0,1090,113,1,0,0,0,1091,1092,

563 5,125,0,0,1092,1097,3,116,58,0,1093,1094,5,132,0,0,1094,1096,3,116,

564 58,0,1095,1093,1,0,0,0,1096,1099,1,0,0,0,1097,1095,1,0,0,0,1097,

565 1098,1,0,0,0,1098,1100,1,0,0,0,1099,1097,1,0,0,0,1100,1101,5,126,

566 0,0,1101,115,1,0,0,0,1102,1103,3,434,217,0,1103,1104,5,133,0,0,1104,

567 1105,3,28,14,0,1105,117,1,0,0,0,1106,1108,5,15,0,0,1107,1106,1,0,

568 0,0,1107,1108,1,0,0,0,1108,1109,1,0,0,0,1109,1110,3,120,60,0,1110,

569 1111,3,374,187,0,1111,1112,3,128,64,0,1112,119,1,0,0,0,1113,1114,

570 5,129,0,0,1114,1125,5,130,0,0,1115,1116,5,129,0,0,1116,1117,3,122,

571 61,0,1117,1118,5,130,0,0,1118,1125,1,0,0,0,1119,1120,5,129,0,0,1120,

572 1121,3,126,63,0,1121,1122,5,130,0,0,1122,1125,1,0,0,0,1123,1125,

573 3,434,217,0,1124,1113,1,0,0,0,1124,1115,1,0,0,0,1124,1119,1,0,0,

574 0,1124,1123,1,0,0,0,1125,121,1,0,0,0,1126,1131,3,124,62,0,1127,1128,

575 5,132,0,0,1128,1130,3,124,62,0,1129,1127,1,0,0,0,1130,1133,1,0,0,

576 0,1131,1129,1,0,0,0,1131,1132,1,0,0,0,1132,123,1,0,0,0,1133,1131,

577 1,0,0,0,1134,1136,7,2,0,0,1135,1134,1,0,0,0,1135,1136,1,0,0,0,1136,

578 1137,1,0,0,0,1137,1138,3,4,2,0,1138,1139,3,434,217,0,1139,125,1,

579 0,0,0,1140,1145,3,434,217,0,1141,1142,5,132,0,0,1142,1144,3,434,

580 217,0,1143,1141,1,0,0,0,1144,1147,1,0,0,0,1145,1143,1,0,0,0,1145,

581 1146,1,0,0,0,1146,127,1,0,0,0,1147,1145,1,0,0,0,1148,1151,3,74,37,

582 0,1149,1151,3,170,85,0,1150,1148,1,0,0,0,1150,1149,1,0,0,0,1151,

583 129,1,0,0,0,1152,1153,3,132,66,0,1153,1154,3,134,67,0,1154,131,1,

584 0,0,0,1155,1157,5,48,0,0,1156,1158,3,4,2,0,1157,1156,1,0,0,0,1157,

585 1158,1,0,0,0,1158,1159,1,0,0,0,1159,1160,3,434,217,0,1160,1161,5,

586 54,0,0,1161,1162,3,28,14,0,1162,133,1,0,0,0,1163,1165,3,136,68,0,

587 1164,1163,1,0,0,0,1165,1168,1,0,0,0,1166,1164,1,0,0,0,1166,1167,

588 1,0,0,0,1167,1169,1,0,0,0,1168,1166,1,0,0,0,1169,1171,3,148,74,0,

589 1170,1172,3,150,75,0,1171,1170,1,0,0,0,1171,1172,1,0,0,0,1172,135,

590 1,0,0,0,1173,1179,3,132,66,0,1174,1179,3,138,69,0,1175,1179,3,140,

591 70,0,1176,1179,3,142,71,0,1177,1179,3,144,72,0,1178,1173,1,0,0,0,

592 1178,1174,1,0,0,0,1178,1175,1,0,0,0,1178,1176,1,0,0,0,1178,1177,

593 1,0,0,0,1179,137,1,0,0,0,1180,1181,5,61,0,0,1181,1182,3,434,217,

594 0,1182,1183,5,145,0,0,1183,1184,3,28,14,0,1184,139,1,0,0,0,1185,

595 1186,5,111,0,0,1186,1187,3,28,14,0,1187,141,1,0,0,0,1188,1190,5,

596 60,0,0,1189,1191,3,4,2,0,1190,1189,1,0,0,0,1190,1191,1,0,0,0,1191,

597 1192,1,0,0,0,1192,1193,3,434,217,0,1193,1194,5,54,0,0,1194,1195,

598 3,28,14,0,1195,1196,5,69,0,0,1196,1197,3,28,14,0,1197,1198,5,38,

599 0,0,1198,1201,3,28,14,0,1199,1200,5,58,0,0,1200,1202,3,434,217,0,

600 1201,1199,1,0,0,0,1201,1202,1,0,0,0,1202,143,1,0,0,0,1203,1204,5,

601 71,0,0,1204,1209,3,146,73,0,1205,1206,5,132,0,0,1206,1208,3,146,

602 73,0,1207,1205,1,0,0,0,1208,1211,1,0,0,0,1209,1207,1,0,0,0,1209,

603 1210,1,0,0,0,1210,145,1,0,0,0,1211,1209,1,0,0,0,1212,1214,3,28,14,

604 0,1213,1215,7,8,0,0,1214,1213,1,0,0,0,1214,1215,1,0,0,0,1215,147,

605 1,0,0,0,1216,1217,5,85,0,0,1217,1224,3,28,14,0,1218,1219,5,51,0,

606 0,1219,1220,3,28,14,0,1220,1221,5,20,0,0,1221,1222,3,28,14,0,1222,

607 1224,1,0,0,0,1223,1216,1,0,0,0,1223,1218,1,0,0,0,1224,149,1,0,0,

608 0,1225,1226,5,58,0,0,1226,1227,3,434,217,0,1227,1228,3,134,67,0,

609 1228,151,1,0,0,0,1229,1233,3,164,82,0,1230,1233,3,154,77,0,1231,

610 1233,3,166,83,0,1232,1229,1,0,0,0,1232,1230,1,0,0,0,1232,1231,1,

611 0,0,0,1233,153,1,0,0,0,1234,1235,3,172,86,0,1235,1236,5,134,0,0,

612 1236,1242,1,0,0,0,1237,1238,3,180,90,0,1238,1239,5,134,0,0,1239,

613 1242,1,0,0,0,1240,1242,3,156,78,0,1241,1234,1,0,0,0,1241,1237,1,

614 0,0,0,1241,1240,1,0,0,0,1242,155,1,0,0,0,1243,1244,3,158,79,0,1244,

615 1245,3,162,81,0,1245,157,1,0,0,0,1246,1248,3,160,80,0,1247,1246,

616 1,0,0,0,1247,1248,1,0,0,0,1248,1249,1,0,0,0,1249,1250,3,274,137,

617 0,1250,1252,3,434,217,0,1251,1253,3,230,115,0,1252,1251,1,0,0,0,

618 1252,1253,1,0,0,0,1253,1254,1,0,0,0,1254,1256,5,129,0,0,1255,1257,

619 3,280,140,0,1256,1255,1,0,0,0,1256,1257,1,0,0,0,1257,1258,1,0,0,

620 0,1258,1260,5,130,0,0,1259,1261,3,238,119,0,1260,1259,1,0,0,0,1260,

621 1261,1,0,0,0,1261,159,1,0,0,0,1262,1264,7,9,0,0,1263,1265,5,90,0,

622 0,1264,1263,1,0,0,0,1264,1265,1,0,0,0,1265,1269,1,0,0,0,1266,1267,

623 5,90,0,0,1267,1269,7,9,0,0,1268,1262,1,0,0,0,1268,1266,1,0,0,0,1269,

624 161,1,0,0,0,1270,1276,3,170,85,0,1271,1272,3,374,187,0,1272,1273,

625 3,74,37,0,1273,1274,5,134,0,0,1274,1276,1,0,0,0,1275,1270,1,0,0,

626 0,1275,1271,1,0,0,0,1276,163,1,0,0,0,1277,1278,3,434,217,0,1278,

627 1279,5,133,0,0,1279,1280,3,152,76,0,1280,165,1,0,0,0,1281,1284,3,

628 170,85,0,1282,1284,3,168,84,0,1283,1281,1,0,0,0,1283,1282,1,0,0,

629 0,1284,167,1,0,0,0,1285,1416,5,134,0,0,1286,1287,3,28,14,0,1287,

630 1288,5,134,0,0,1288,1416,1,0,0,0,1289,1290,5,52,0,0,1290,1291,5,

631 129,0,0,1291,1292,3,28,14,0,1292,1293,5,130,0,0,1293,1296,3,182,

632 91,0,1294,1295,5,36,0,0,1295,1297,3,182,91,0,1296,1294,1,0,0,0,1296,

633 1297,1,0,0,0,1297,1416,1,0,0,0,1298,1299,5,93,0,0,1299,1300,5,129,

634 0,0,1300,1301,3,28,14,0,1301,1302,5,130,0,0,1302,1306,5,125,0,0,

635 1303,1305,3,184,92,0,1304,1303,1,0,0,0,1305,1308,1,0,0,0,1306,1304,

636 1,0,0,0,1306,1307,1,0,0,0,1307,1309,1,0,0,0,1308,1306,1,0,0,0,1309,

637 1310,5,126,0,0,1310,1416,1,0,0,0,1311,1312,5,112,0,0,1312,1313,5,

638 129,0,0,1313,1314,3,28,14,0,1314,1315,5,130,0,0,1315,1316,3,166,

639 83,0,1316,1416,1,0,0,0,1317,1318,5,33,0,0,1318,1319,3,166,83,0,1319,

640 1320,5,112,0,0,1320,1321,5,129,0,0,1321,1322,3,28,14,0,1322,1323,

641 5,130,0,0,1323,1324,5,134,0,0,1324,1416,1,0,0,0,1325,1326,5,46,0,

642 0,1326,1328,5,129,0,0,1327,1329,3,192,96,0,1328,1327,1,0,0,0,1328,

643 1329,1,0,0,0,1329,1330,1,0,0,0,1330,1332,5,134,0,0,1331,1333,3,28,

644 14,0,1332,1331,1,0,0,0,1332,1333,1,0,0,0,1333,1334,1,0,0,0,1334,

645 1336,5,134,0,0,1335,1337,3,194,97,0,1336,1335,1,0,0,0,1336,1337,

646 1,0,0,0,1337,1338,1,0,0,0,1338,1339,5,130,0,0,1339,1416,3,166,83,

647 0,1340,1342,5,16,0,0,1341,1340,1,0,0,0,1341,1342,1,0,0,0,1342,1343,

648 1,0,0,0,1343,1344,5,47,0,0,1344,1345,5,129,0,0,1345,1346,3,174,87,

649 0,1346,1347,3,434,217,0,1347,1348,5,54,0,0,1348,1349,3,28,14,0,1349,

650 1350,5,130,0,0,1350,1351,3,166,83,0,1351,1416,1,0,0,0,1352,1353,

651 5,19,0,0,1353,1416,5,134,0,0,1354,1355,5,28,0,0,1355,1416,5,134,

652 0,0,1356,1361,5,50,0,0,1357,1362,3,434,217,0,1358,1359,5,22,0,0,

653 1359,1362,3,28,14,0,1360,1362,5,30,0,0,1361,1357,1,0,0,0,1361,1358,

654 1,0,0,0,1361,1360,1,0,0,0,1362,1363,1,0,0,0,1363,1416,5,134,0,0,

655 1364,1366,5,82,0,0,1365,1367,3,28,14,0,1366,1365,1,0,0,0,1366,1367,

656 1,0,0,0,1367,1368,1,0,0,0,1368,1416,5,134,0,0,1369,1371,5,95,0,0,

657 1370,1372,3,28,14,0,1371,1370,1,0,0,0,1371,1372,1,0,0,0,1372,1373,

658 1,0,0,0,1373,1416,5,134,0,0,1374,1375,5,97,0,0,1375,1381,3,170,85,

659 0,1376,1378,3,196,98,0,1377,1379,3,204,102,0,1378,1377,1,0,0,0,1378,

660 1379,1,0,0,0,1379,1382,1,0,0,0,1380,1382,3,204,102,0,1381,1376,1,

661 0,0,0,1381,1380,1,0,0,0,1382,1416,1,0,0,0,1383,1384,5,25,0,0,1384,

662 1416,3,170,85,0,1385,1386,5,101,0,0,1386,1416,3,170,85,0,1387,1388,

663 5,62,0,0,1388,1389,5,129,0,0,1389,1390,3,28,14,0,1390,1391,5,130,

664 0,0,1391,1392,3,166,83,0,1392,1416,1,0,0,0,1393,1394,5,105,0,0,1394,

665 1395,5,129,0,0,1395,1396,3,206,103,0,1396,1397,5,130,0,0,1397,1398,

666 3,166,83,0,1398,1416,1,0,0,0,1399,1403,5,113,0,0,1400,1401,5,82,

667 0,0,1401,1404,3,28,14,0,1402,1404,5,19,0,0,1403,1400,1,0,0,0,1403,

668 1402,1,0,0,0,1404,1405,1,0,0,0,1405,1416,5,134,0,0,1406,1407,5,103,

669 0,0,1407,1416,3,170,85,0,1408,1409,5,44,0,0,1409,1410,5,129,0,0,

670 1410,1411,3,362,181,0,1411,1412,3,364,182,0,1412,1413,5,130,0,0,

671 1413,1414,3,166,83,0,1414,1416,1,0,0,0,1415,1285,1,0,0,0,1415,1286,

672 1,0,0,0,1415,1289,1,0,0,0,1415,1298,1,0,0,0,1415,1311,1,0,0,0,1415,

673 1317,1,0,0,0,1415,1325,1,0,0,0,1415,1341,1,0,0,0,1415,1352,1,0,0,

674 0,1415,1354,1,0,0,0,1415,1356,1,0,0,0,1415,1364,1,0,0,0,1415,1369,

675 1,0,0,0,1415,1374,1,0,0,0,1415,1383,1,0,0,0,1415,1385,1,0,0,0,1415,

676 1387,1,0,0,0,1415,1393,1,0,0,0,1415,1399,1,0,0,0,1415,1406,1,0,0,

677 0,1415,1408,1,0,0,0,1416,169,1,0,0,0,1417,1419,5,125,0,0,1418,1420,

678 3,190,95,0,1419,1418,1,0,0,0,1419,1420,1,0,0,0,1420,1421,1,0,0,0,

679 1421,1422,5,126,0,0,1422,171,1,0,0,0,1423,1428,5,105,0,0,1424,1428,

680 5,80,0,0,1425,1426,5,80,0,0,1426,1428,5,79,0,0,1427,1423,1,0,0,0,

681 1427,1424,1,0,0,0,1427,1425,1,0,0,0,1427,1428,1,0,0,0,1428,1429,

682 1,0,0,0,1429,1430,3,174,87,0,1430,1437,3,176,88,0,1431,1432,5,132,

683 0,0,1432,1433,3,176,88,0,1433,1434,4,86,0,0,1434,1436,1,0,0,0,1435,

684 1431,1,0,0,0,1436,1439,1,0,0,0,1437,1435,1,0,0,0,1437,1438,1,0,0,

685 0,1438,1445,1,0,0,0,1439,1437,1,0,0,0,1440,1441,5,44,0,0,1441,1442,

686 3,362,181,0,1442,1443,3,364,182,0,1443,1445,1,0,0,0,1444,1427,1,

687 0,0,0,1444,1440,1,0,0,0,1445,173,1,0,0,0,1446,1449,5,106,0,0,1447,

688 1449,3,4,2,0,1448,1446,1,0,0,0,1448,1447,1,0,0,0,1449,175,1,0,0,

689 0,1450,1456,3,434,217,0,1451,1453,5,145,0,0,1452,1454,5,80,0,0,1453,

690 1452,1,0,0,0,1453,1454,1,0,0,0,1454,1455,1,0,0,0,1455,1457,3,178,

691 89,0,1456,1451,1,0,0,0,1456,1457,1,0,0,0,1457,177,1,0,0,0,1458,1462,

692 3,28,14,0,1459,1462,3,324,162,0,1460,1462,3,372,186,0,1461,1458,

693 1,0,0,0,1461,1459,1,0,0,0,1461,1460,1,0,0,0,1462,179,1,0,0,0,1463,

694 1464,5,27,0,0,1464,1465,3,4,2,0,1465,1466,3,264,132,0,1466,181,1,

695 0,0,0,1467,1470,3,170,85,0,1468,1470,3,168,84,0,1469,1467,1,0,0,

696 0,1469,1468,1,0,0,0,1470,183,1,0,0,0,1471,1473,3,186,93,0,1472,1471,

697 1,0,0,0,1473,1474,1,0,0,0,1474,1472,1,0,0,0,1474,1475,1,0,0,0,1475,

698 1476,1,0,0,0,1476,1477,3,190,95,0,1477,185,1,0,0,0,1478,1479,5,22,

699 0,0,1479,1481,3,28,14,0,1480,1482,3,188,94,0,1481,1480,1,0,0,0,1481,

700 1482,1,0,0,0,1482,1483,1,0,0,0,1483,1484,5,133,0,0,1484,1488,1,0,

701 0,0,1485,1486,5,30,0,0,1486,1488,5,133,0,0,1487,1478,1,0,0,0,1487,

702 1485,1,0,0,0,1488,187,1,0,0,0,1489,1490,5,110,0,0,1490,1491,3,28,

703 14,0,1491,189,1,0,0,0,1492,1494,3,152,76,0,1493,1492,1,0,0,0,1494,

704 1495,1,0,0,0,1495,1493,1,0,0,0,1495,1496,1,0,0,0,1496,191,1,0,0,

705 0,1497,1507,3,172,86,0,1498,1503,3,28,14,0,1499,1500,5,132,0,0,1500,

706 1502,3,28,14,0,1501,1499,1,0,0,0,1502,1505,1,0,0,0,1503,1501,1,0,

707 0,0,1503,1504,1,0,0,0,1504,1507,1,0,0,0,1505,1503,1,0,0,0,1506,1497,

708 1,0,0,0,1506,1498,1,0,0,0,1507,193,1,0,0,0,1508,1513,3,28,14,0,1509,

709 1510,5,132,0,0,1510,1512,3,28,14,0,1511,1509,1,0,0,0,1512,1515,1,

710 0,0,0,1513,1511,1,0,0,0,1513,1514,1,0,0,0,1514,195,1,0,0,0,1515,

711 1513,1,0,0,0,1516,1520,3,198,99,0,1517,1519,3,198,99,0,1518,1517,

712 1,0,0,0,1519,1522,1,0,0,0,1520,1518,1,0,0,0,1520,1521,1,0,0,0,1521,

713 1524,1,0,0,0,1522,1520,1,0,0,0,1523,1525,3,200,100,0,1524,1523,1,

714 0,0,0,1524,1525,1,0,0,0,1525,1528,1,0,0,0,1526,1528,3,200,100,0,

715 1527,1516,1,0,0,0,1527,1526,1,0,0,0,1528,197,1,0,0,0,1529,1530,5,

716 23,0,0,1530,1531,5,129,0,0,1531,1533,3,20,10,0,1532,1534,3,434,217,

717 0,1533,1532,1,0,0,0,1533,1534,1,0,0,0,1534,1535,1,0,0,0,1535,1537,

718 5,130,0,0,1536,1538,3,202,101,0,1537,1536,1,0,0,0,1537,1538,1,0,

719 0,0,1538,1539,1,0,0,0,1539,1540,3,170,85,0,1540,199,1,0,0,0,1541,

720 1543,5,23,0,0,1542,1544,3,202,101,0,1543,1542,1,0,0,0,1543,1544,

721 1,0,0,0,1544,1545,1,0,0,0,1545,1546,3,170,85,0,1546,201,1,0,0,0,

722 1547,1548,5,110,0,0,1548,1549,5,129,0,0,1549,1550,3,28,14,0,1550,

723 1551,5,130,0,0,1551,203,1,0,0,0,1552,1553,5,43,0,0,1553,1554,3,170,

724 85,0,1554,205,1,0,0,0,1555,1558,3,172,86,0,1556,1558,3,28,14,0,1557,

725 1555,1,0,0,0,1557,1556,1,0,0,0,1558,207,1,0,0,0,1559,1560,5,65,0,

726 0,1560,1561,3,210,105,0,1561,1563,3,212,106,0,1562,1564,5,134,0,

727 0,1563,1562,1,0,0,0,1563,1564,1,0,0,0,1564,209,1,0,0,0,1565,1570,

728 3,434,217,0,1566,1567,5,131,0,0,1567,1569,3,434,217,0,1568,1566,

729 1,0,0,0,1569,1572,1,0,0,0,1570,1568,1,0,0,0,1570,1571,1,0,0,0,1571,

730 211,1,0,0,0,1572,1570,1,0,0,0,1573,1575,5,125,0,0,1574,1576,3,214,

731 107,0,1575,1574,1,0,0,0,1575,1576,1,0,0,0,1576,1578,1,0,0,0,1577,

732 1579,3,218,109,0,1578,1577,1,0,0,0,1578,1579,1,0,0,0,1579,1581,1,

733 0,0,0,1580,1582,3,222,111,0,1581,1580,1,0,0,0,1581,1582,1,0,0,0,

734 1582,1583,1,0,0,0,1583,1584,5,126,0,0,1584,213,1,0,0,0,1585,1587,

735 3,216,108,0,1586,1585,1,0,0,0,1587,1588,1,0,0,0,1588,1586,1,0,0,

736 0,1588,1589,1,0,0,0,1589,215,1,0,0,0,1590,1591,5,41,0,0,1591,1592,

737 5,11,0,0,1592,1593,3,434,217,0,1593,1594,5,134,0,0,1594,217,1,0,

738 0,0,1595,1597,3,220,110,0,1596,1595,1,0,0,0,1597,1598,1,0,0,0,1598,

739 1596,1,0,0,0,1598,1599,1,0,0,0,1599,219,1,0,0,0,1600,1601,5,105,

740 0,0,1601,1602,3,434,217,0,1602,1603,5,145,0,0,1603,1604,3,2,1,0,

741 1604,1605,5,134,0,0,1605,1616,1,0,0,0,1606,1607,5,105,0,0,1607,1608,

742 3,2,1,0,1608,1609,5,134,0,0,1609,1616,1,0,0,0,1610,1611,5,105,0,

743 0,1611,1612,5,90,0,0,1612,1613,3,2,1,0,1613,1614,5,134,0,0,1614,

744 1616,1,0,0,0,1615,1600,1,0,0,0,1615,1606,1,0,0,0,1615,1610,1,0,0,

745 0,1616,221,1,0,0,0,1617,1619,3,224,112,0,1618,1617,1,0,0,0,1619,

746 1620,1,0,0,0,1620,1618,1,0,0,0,1620,1621,1,0,0,0,1621,223,1,0,0,

747 0,1622,1625,3,208,104,0,1623,1625,3,226,113,0,1624,1622,1,0,0,0,

748 1624,1623,1,0,0,0,1625,225,1,0,0,0,1626,1628,3,350,175,0,1627,1626,

749 1,0,0,0,1627,1628,1,0,0,0,1628,1630,1,0,0,0,1629,1631,3,256,128,

750 0,1630,1629,1,0,0,0,1630,1631,1,0,0,0,1631,1637,1,0,0,0,1632,1638,

751 3,398,199,0,1633,1638,3,400,200,0,1634,1638,3,402,201,0,1635,1638,

752 3,404,202,0,1636,1638,3,406,203,0,1637,1632,1,0,0,0,1637,1633,1,

753 0,0,0,1637,1634,1,0,0,0,1637,1635,1,0,0,0,1637,1636,1,0,0,0,1638,

754 227,1,0,0,0,1639,1640,3,434,217,0,1640,1641,5,149,0,0,1641,1643,

755 3,434,217,0,1642,1644,3,22,11,0,1643,1642,1,0,0,0,1643,1644,1,0,

756 0,0,1644,229,1,0,0,0,1645,1646,5,146,0,0,1646,1651,3,232,116,0,1647,

757 1648,5,132,0,0,1648,1650,3,232,116,0,1649,1647,1,0,0,0,1650,1653,

758 1,0,0,0,1651,1649,1,0,0,0,1651,1652,1,0,0,0,1652,1654,1,0,0,0,1653,

759 1651,1,0,0,0,1654,1655,5,147,0,0,1655,231,1,0,0,0,1656,1658,3,350,

760 175,0,1657,1656,1,0,0,0,1657,1658,1,0,0,0,1658,1659,1,0,0,0,1659,

761 1660,3,434,217,0,1660,233,1,0,0,0,1661,1662,5,133,0,0,1662,1667,

762 3,20,10,0,1663,1664,5,132,0,0,1664,1666,3,2,1,0,1665,1663,1,0,0,

763 0,1666,1669,1,0,0,0,1667,1665,1,0,0,0,1667,1668,1,0,0,0,1668,235,

764 1,0,0,0,1669,1667,1,0,0,0,1670,1675,3,2,1,0,1671,1672,5,132,0,0,

765 1672,1674,3,2,1,0,1673,1671,1,0,0,0,1674,1677,1,0,0,0,1675,1673,

766 1,0,0,0,1675,1676,1,0,0,0,1676,237,1,0,0,0,1677,1675,1,0,0,0,1678,

767 1680,3,240,120,0,1679,1678,1,0,0,0,1680,1681,1,0,0,0,1681,1679,1,

768 0,0,0,1681,1682,1,0,0,0,1682,239,1,0,0,0,1683,1684,5,111,0,0,1684,

769 1685,3,434,217,0,1685,1686,5,133,0,0,1686,1687,3,242,121,0,1687,

770 241,1,0,0,0,1688,1699,3,248,124,0,1689,1692,3,244,122,0,1690,1691,

771 5,132,0,0,1691,1693,3,246,123,0,1692,1690,1,0,0,0,1692,1693,1,0,

772 0,0,1693,1696,1,0,0,0,1694,1695,5,132,0,0,1695,1697,3,248,124,0,

773 1696,1694,1,0,0,0,1696,1697,1,0,0,0,1697,1699,1,0,0,0,1698,1688,

774 1,0,0,0,1698,1689,1,0,0,0,1699,243,1,0,0,0,1700,1708,3,20,10,0,1701,

775 1703,5,26,0,0,1702,1704,5,148,0,0,1703,1702,1,0,0,0,1703,1704,1,

776 0,0,0,1704,1708,1,0,0,0,1705,1708,5,92,0,0,1706,1708,5,102,0,0,1707,

777 1700,1,0,0,0,1707,1701,1,0,0,0,1707,1705,1,0,0,0,1707,1706,1,0,0,

778 0,1708,245,1,0,0,0,1709,1714,3,2,1,0,1710,1711,5,132,0,0,1711,1713,

779 3,2,1,0,1712,1710,1,0,0,0,1713,1716,1,0,0,0,1714,1712,1,0,0,0,1714,

780 1715,1,0,0,0,1715,247,1,0,0,0,1716,1714,1,0,0,0,1717,1718,5,66,0,

781 0,1718,1719,5,129,0,0,1719,1720,5,130,0,0,1720,249,1,0,0,0,1721,

782 1723,5,125,0,0,1722,1724,3,252,126,0,1723,1722,1,0,0,0,1723,1724,

783 1,0,0,0,1724,1725,1,0,0,0,1725,1726,5,126,0,0,1726,251,1,0,0,0,1727,

784 1729,3,254,127,0,1728,1727,1,0,0,0,1729,1730,1,0,0,0,1730,1728,1,

785 0,0,0,1730,1731,1,0,0,0,1731,253,1,0,0,0,1732,1734,3,350,175,0,1733,

786 1732,1,0,0,0,1733,1734,1,0,0,0,1734,1736,1,0,0,0,1735,1737,3,256,

787 128,0,1736,1735,1,0,0,0,1736,1737,1,0,0,0,1737,1740,1,0,0,0,1738,

788 1741,3,260,130,0,1739,1741,3,418,209,0,1740,1738,1,0,0,0,1740,1739,

789 1,0,0,0,1741,255,1,0,0,0,1742,1744,3,258,129,0,1743,1742,1,0,0,0,

790 1744,1745,1,0,0,0,1745,1743,1,0,0,0,1745,1746,1,0,0,0,1746,257,1,

791 0,0,0,1747,1748,7,10,0,0,1748,259,1,0,0,0,1749,1769,3,414,207,0,

792 1750,1769,3,262,131,0,1751,1769,3,408,204,0,1752,1758,3,308,154,

793 0,1753,1759,3,312,156,0,1754,1755,3,374,187,0,1755,1756,3,74,37,

794 0,1756,1757,5,134,0,0,1757,1759,1,0,0,0,1758,1753,1,0,0,0,1758,1754,

795 1,0,0,0,1759,1769,1,0,0,0,1760,1769,3,420,210,0,1761,1762,5,108,

796 0,0,1762,1769,3,422,211,0,1763,1769,3,398,199,0,1764,1769,3,400,

797 200,0,1765,1769,3,402,201,0,1766,1769,3,404,202,0,1767,1769,3,406,

798 203,0,1768,1749,1,0,0,0,1768,1750,1,0,0,0,1768,1751,1,0,0,0,1768,

799 1752,1,0,0,0,1768,1760,1,0,0,0,1768,1761,1,0,0,0,1768,1763,1,0,0,

800 0,1768,1764,1,0,0,0,1768,1765,1,0,0,0,1768,1766,1,0,0,0,1768,1767,

801 1,0,0,0,1769,261,1,0,0,0,1770,1776,5,80,0,0,1771,1772,5,79,0,0,1772,

802 1776,5,80,0,0,1773,1774,5,80,0,0,1774,1776,5,79,0,0,1775,1770,1,

803 0,0,0,1775,1771,1,0,0,0,1775,1773,1,0,0,0,1775,1776,1,0,0,0,1776,

804 1777,1,0,0,0,1777,1787,3,4,2,0,1778,1779,3,2,1,0,1779,1780,5,131,

805 0,0,1780,1781,3,416,208,0,1781,1788,1,0,0,0,1782,1788,3,422,211,

806 0,1783,1788,3,412,206,0,1784,1788,3,416,208,0,1785,1788,3,426,213,

807 0,1786,1788,3,410,205,0,1787,1778,1,0,0,0,1787,1782,1,0,0,0,1787,

808 1783,1,0,0,0,1787,1784,1,0,0,0,1787,1785,1,0,0,0,1787,1786,1,0,0,

809 0,1788,263,1,0,0,0,1789,1794,3,266,133,0,1790,1791,5,132,0,0,1791,

810 1793,3,266,133,0,1792,1790,1,0,0,0,1793,1796,1,0,0,0,1794,1792,1,

811 0,0,0,1794,1795,1,0,0,0,1795,265,1,0,0,0,1796,1794,1,0,0,0,1797,

812 1798,3,434,217,0,1798,1799,5,145,0,0,1799,1800,3,28,14,0,1800,267,

813 1,0,0,0,1801,1806,3,270,135,0,1802,1803,5,132,0,0,1803,1805,3,270,

814 135,0,1804,1802,1,0,0,0,1805,1808,1,0,0,0,1806,1804,1,0,0,0,1806,

815 1807,1,0,0,0,1807,269,1,0,0,0,1808,1806,1,0,0,0,1809,1812,3,434,

816 217,0,1810,1811,5,145,0,0,1811,1813,3,272,136,0,1812,1810,1,0,0,

817 0,1812,1813,1,0,0,0,1813,271,1,0,0,0,1814,1817,3,28,14,0,1815,1817,

818 3,324,162,0,1816,1814,1,0,0,0,1816,1815,1,0,0,0,1817,273,1,0,0,0,

819 1818,1821,3,4,2,0,1819,1821,5,108,0,0,1820,1818,1,0,0,0,1820,1819,

820 1,0,0,0,1821,275,1,0,0,0,1822,1823,3,2,1,0,1823,277,1,0,0,0,1824,

821 1827,3,170,85,0,1825,1827,5,134,0,0,1826,1824,1,0,0,0,1826,1825,

822 1,0,0,0,1827,279,1,0,0,0,1828,1835,3,288,144,0,1829,1832,3,282,141,

823 0,1830,1831,5,132,0,0,1831,1833,3,288,144,0,1832,1830,1,0,0,0,1832,

824 1833,1,0,0,0,1833,1835,1,0,0,0,1834,1828,1,0,0,0,1834,1829,1,0,0,

825 0,1835,281,1,0,0,0,1836,1841,3,284,142,0,1837,1838,5,132,0,0,1838,

826 1840,3,284,142,0,1839,1837,1,0,0,0,1840,1843,1,0,0,0,1841,1839,1,

827 0,0,0,1841,1842,1,0,0,0,1842,283,1,0,0,0,1843,1841,1,0,0,0,1844,

828 1846,3,350,175,0,1845,1844,1,0,0,0,1845,1846,1,0,0,0,1846,1848,1,

829 0,0,0,1847,1849,3,286,143,0,1848,1847,1,0,0,0,1848,1849,1,0,0,0,

830 1849,1850,1,0,0,0,1850,1853,3,428,214,0,1851,1853,5,12,0,0,1852,

831 1845,1,0,0,0,1852,1851,1,0,0,0,1853,285,1,0,0,0,1854,1863,5,80,0,

832 0,1855,1863,5,72,0,0,1856,1863,5,54,0,0,1857,1858,5,80,0,0,1858,

833 1863,5,94,0,0,1859,1860,5,54,0,0,1860,1863,5,94,0,0,1861,1863,5,

834 94,0,0,1862,1854,1,0,0,0,1862,1855,1,0,0,0,1862,1856,1,0,0,0,1862,

835 1857,1,0,0,0,1862,1859,1,0,0,0,1862,1861,1,0,0,0,1863,287,1,0,0,

836 0,1864,1866,3,350,175,0,1865,1864,1,0,0,0,1865,1866,1,0,0,0,1866,

837 1867,1,0,0,0,1867,1868,5,74,0,0,1868,1869,3,320,160,0,1869,1870,

838 3,434,217,0,1870,289,1,0,0,0,1871,1873,3,350,175,0,1872,1871,1,0,

839 0,0,1872,1873,1,0,0,0,1873,1875,1,0,0,0,1874,1876,3,296,148,0,1875,

840 1874,1,0,0,0,1875,1876,1,0,0,0,1876,1887,1,0,0,0,1877,1878,5,49,

841 0,0,1878,1880,3,298,149,0,1879,1881,3,294,147,0,1880,1879,1,0,0,

842 0,1880,1881,1,0,0,0,1881,1888,1,0,0,0,1882,1883,5,86,0,0,1883,1885,

843 3,298,149,0,1884,1886,3,292,146,0,1885,1884,1,0,0,0,1885,1886,1,

844 0,0,0,1886,1888,1,0,0,0,1887,1877,1,0,0,0,1887,1882,1,0,0,0,1888,

845 291,1,0,0,0,1889,1891,3,350,175,0,1890,1889,1,0,0,0,1890,1891,1,

846 0,0,0,1891,1893,1,0,0,0,1892,1894,3,296,148,0,1893,1892,1,0,0,0,

847 1893,1894,1,0,0,0,1894,1895,1,0,0,0,1895,1896,5,49,0,0,1896,1897,

848 3,298,149,0,1897,293,1,0,0,0,1898,1900,3,350,175,0,1899,1898,1,0,

849 0,0,1899,1900,1,0,0,0,1900,1902,1,0,0,0,1901,1903,3,296,148,0,1902,

850 1901,1,0,0,0,1902,1903,1,0,0,0,1903,1904,1,0,0,0,1904,1905,5,86,

851 0,0,1905,1906,3,298,149,0,1906,295,1,0,0,0,1907,1915,5,77,0,0,1908,

852 1915,5,57,0,0,1909,1915,5,76,0,0,1910,1911,5,77,0,0,1911,1915,5,

853 57,0,0,1912,1913,5,57,0,0,1913,1915,5,77,0,0,1914,1907,1,0,0,0,1914,

854 1908,1,0,0,0,1914,1909,1,0,0,0,1914,1910,1,0,0,0,1914,1912,1,0,0,

855 0,1915,297,1,0,0,0,1916,1919,3,170,85,0,1917,1919,5,134,0,0,1918,

856 1916,1,0,0,0,1918,1917,1,0,0,0,1919,299,1,0,0,0,1920,1922,3,350,

857 175,0,1921,1920,1,0,0,0,1921,1922,1,0,0,0,1922,1931,1,0,0,0,1923,

858 1924,5,10,0,0,1924,1925,3,170,85,0,1925,1926,3,304,152,0,1926,1932,

859 1,0,0,0,1927,1928,5,81,0,0,1928,1929,3,170,85,0,1929,1930,3,302,

860 151,0,1930,1932,1,0,0,0,1931,1923,1,0,0,0,1931,1927,1,0,0,0,1932,

861 301,1,0,0,0,1933,1935,3,350,175,0,1934,1933,1,0,0,0,1934,1935,1,

862 0,0,0,1935,1936,1,0,0,0,1936,1937,5,10,0,0,1937,1938,3,170,85,0,

863 1938,303,1,0,0,0,1939,1941,3,350,175,0,1940,1939,1,0,0,0,1940,1941,

864 1,0,0,0,1941,1942,1,0,0,0,1942,1943,5,81,0,0,1943,1944,3,170,85,

865 0,1944,305,1,0,0,0,1945,1968,5,135,0,0,1946,1968,5,136,0,0,1947,

866 1968,5,143,0,0,1948,1968,5,144,0,0,1949,1968,5,151,0,0,1950,1968,

867 5,152,0,0,1951,1968,5,96,0,0,1952,1968,5,42,0,0,1953,1968,5,137,

868 0,0,1954,1968,5,138,0,0,1955,1968,5,139,0,0,1956,1968,5,140,0,0,

869 1957,1968,5,141,0,0,1958,1968,5,142,0,0,1959,1968,5,168,0,0,1960,

870 1968,3,376,188,0,1961,1968,5,156,0,0,1962,1968,5,157,0,0,1963,1968,

871 5,147,0,0,1964,1968,5,146,0,0,1965,1968,5,159,0,0,1966,1968,5,158,

872 0,0,1967,1945,1,0,0,0,1967,1946,1,0,0,0,1967,1947,1,0,0,0,1967,1948,

873 1,0,0,0,1967,1949,1,0,0,0,1967,1950,1,0,0,0,1967,1951,1,0,0,0,1967,

874 1952,1,0,0,0,1967,1953,1,0,0,0,1967,1954,1,0,0,0,1967,1955,1,0,0,

875 0,1967,1956,1,0,0,0,1967,1957,1,0,0,0,1967,1958,1,0,0,0,1967,1959,

876 1,0,0,0,1967,1960,1,0,0,0,1967,1961,1,0,0,0,1967,1962,1,0,0,0,1967,

877 1963,1,0,0,0,1967,1964,1,0,0,0,1967,1965,1,0,0,0,1967,1966,1,0,0,

878 0,1968,307,1,0,0,0,1969,1970,7,11,0,0,1970,1971,5,70,0,0,1971,1972,

879 3,4,2,0,1972,1973,5,129,0,0,1973,1974,3,428,214,0,1974,1975,5,130,

880 0,0,1975,309,1,0,0,0,1976,1977,5,133,0,0,1977,1978,7,12,0,0,1978,

881 1980,5,129,0,0,1979,1981,3,24,12,0,1980,1979,1,0,0,0,1980,1981,1,

882 0,0,0,1981,1982,1,0,0,0,1982,1983,5,130,0,0,1983,311,1,0,0,0,1984,

883 1987,3,170,85,0,1985,1987,5,134,0,0,1986,1984,1,0,0,0,1986,1985,

884 1,0,0,0,1987,313,1,0,0,0,1988,1989,5,133,0,0,1989,1990,3,236,118,

885 0,1990,315,1,0,0,0,1991,1995,5,125,0,0,1992,1994,3,318,159,0,1993,

886 1992,1,0,0,0,1994,1997,1,0,0,0,1995,1993,1,0,0,0,1995,1996,1,0,0,

887 0,1996,1998,1,0,0,0,1997,1995,1,0,0,0,1998,1999,5,126,0,0,1999,317,

888 1,0,0,0,2000,2002,3,350,175,0,2001,2000,1,0,0,0,2001,2002,1,0,0,

889 0,2002,2004,1,0,0,0,2003,2005,3,256,128,0,2004,2003,1,0,0,0,2004,

890 2005,1,0,0,0,2005,2016,1,0,0,0,2006,2017,3,260,130,0,2007,2008,5,

891 44,0,0,2008,2010,3,4,2,0,2009,2011,3,370,185,0,2010,2009,1,0,0,0,

892 2011,2012,1,0,0,0,2012,2010,1,0,0,0,2012,2013,1,0,0,0,2013,2014,

893 1,0,0,0,2014,2015,5,134,0,0,2015,2017,1,0,0,0,2016,2006,1,0,0,0,

894 2016,2007,1,0,0,0,2017,319,1,0,0,0,2018,2026,3,6,3,0,2019,2021,7,

895 13,0,0,2020,2019,1,0,0,0,2021,2024,1,0,0,0,2022,2020,1,0,0,0,2022,

896 2023,1,0,0,0,2023,2025,1,0,0,0,2024,2022,1,0,0,0,2025,2027,3,322,

897 161,0,2026,2022,1,0,0,0,2027,2028,1,0,0,0,2028,2026,1,0,0,0,2028,

898 2029,1,0,0,0,2029,321,1,0,0,0,2030,2034,5,127,0,0,2031,2033,5,132,

899 0,0,2032,2031,1,0,0,0,2033,2036,1,0,0,0,2034,2032,1,0,0,0,2034,2035,

900 1,0,0,0,2035,2037,1,0,0,0,2036,2034,1,0,0,0,2037,2038,5,128,0,0,

901 2038,323,1,0,0,0,2039,2051,5,125,0,0,2040,2045,3,272,136,0,2041,

902 2042,5,132,0,0,2042,2044,3,272,136,0,2043,2041,1,0,0,0,2044,2047,

903 1,0,0,0,2045,2043,1,0,0,0,2045,2046,1,0,0,0,2046,2049,1,0,0,0,2047,

904 2045,1,0,0,0,2048,2050,5,132,0,0,2049,2048,1,0,0,0,2049,2050,1,0,

905 0,0,2050,2052,1,0,0,0,2051,2040,1,0,0,0,2051,2052,1,0,0,0,2052,2053,

906 1,0,0,0,2053,2054,5,126,0,0,2054,325,1,0,0,0,2055,2056,5,146,0,0,

907 2056,2061,3,328,164,0,2057,2058,5,132,0,0,2058,2060,3,328,164,0,

908 2059,2057,1,0,0,0,2060,2063,1,0,0,0,2061,2059,1,0,0,0,2061,2062,

909 1,0,0,0,2062,2064,1,0,0,0,2063,2061,1,0,0,0,2064,2065,5,147,0,0,

910 2065,327,1,0,0,0,2066,2068,3,350,175,0,2067,2066,1,0,0,0,2067,2068,

911 1,0,0,0,2068,2070,1,0,0,0,2069,2071,3,330,165,0,2070,2069,1,0,0,

912 0,2070,2071,1,0,0,0,2071,2072,1,0,0,0,2072,2073,3,434,217,0,2073,

913 329,1,0,0,0,2074,2075,7,14,0,0,2075,331,1,0,0,0,2076,2077,5,133,

914 0,0,2077,2078,3,236,118,0,2078,333,1,0,0,0,2079,2083,5,125,0,0,2080,

915 2082,3,336,168,0,2081,2080,1,0,0,0,2082,2085,1,0,0,0,2083,2081,1,

916 0,0,0,2083,2084,1,0,0,0,2084,2086,1,0,0,0,2085,2083,1,0,0,0,2086,

917 2087,5,126,0,0,2087,335,1,0,0,0,2088,2090,3,350,175,0,2089,2088,

918 1,0,0,0,2089,2090,1,0,0,0,2090,2092,1,0,0,0,2091,2093,5,66,0,0,2092,

919 2091,1,0,0,0,2092,2093,1,0,0,0,2093,2157,1,0,0,0,2094,2096,5,103,

920 0,0,2095,2094,1,0,0,0,2095,2096,1,0,0,0,2096,2102,1,0,0,0,2097,2103,

921 5,80,0,0,2098,2099,5,80,0,0,2099,2103,5,79,0,0,2100,2101,5,79,0,

922 0,2101,2103,5,80,0,0,2102,2097,1,0,0,0,2102,2098,1,0,0,0,2102,2100,

923 1,0,0,0,2102,2103,1,0,0,0,2103,2104,1,0,0,0,2104,2132,3,4,2,0,2105,

924 2107,3,434,217,0,2106,2108,3,230,115,0,2107,2106,1,0,0,0,2107,2108,

925 1,0,0,0,2108,2109,1,0,0,0,2109,2111,5,129,0,0,2110,2112,3,280,140,

926 0,2111,2110,1,0,0,0,2111,2112,1,0,0,0,2112,2113,1,0,0,0,2113,2115,

927 5,130,0,0,2114,2116,3,238,119,0,2115,2114,1,0,0,0,2115,2116,1,0,

928 0,0,2116,2117,1,0,0,0,2117,2118,5,134,0,0,2118,2133,1,0,0,0,2119,

929 2120,3,434,217,0,2120,2121,5,125,0,0,2121,2122,3,338,169,0,2122,

930 2123,5,126,0,0,2123,2133,1,0,0,0,2124,2125,5,94,0,0,2125,2126,5,

931 127,0,0,2126,2127,3,280,140,0,2127,2128,5,128,0,0,2128,2129,5,125,

932 0,0,2129,2130,3,338,169,0,2130,2131,5,126,0,0,2131,2133,1,0,0,0,

933 2132,2105,1,0,0,0,2132,2119,1,0,0,0,2132,2124,1,0,0,0,2133,2158,

934 1,0,0,0,2134,2136,5,103,0,0,2135,2134,1,0,0,0,2135,2136,1,0,0,0,

935 2136,2137,1,0,0,0,2137,2138,5,108,0,0,2138,2140,3,434,217,0,2139,

936 2141,3,230,115,0,2140,2139,1,0,0,0,2140,2141,1,0,0,0,2141,2142,1,

937 0,0,0,2142,2144,5,129,0,0,2143,2145,3,280,140,0,2144,2143,1,0,0,

938 0,2144,2145,1,0,0,0,2145,2146,1,0,0,0,2146,2148,5,130,0,0,2147,2149,

939 3,238,119,0,2148,2147,1,0,0,0,2148,2149,1,0,0,0,2149,2150,1,0,0,

940 0,2150,2151,5,134,0,0,2151,2158,1,0,0,0,2152,2153,5,39,0,0,2153,

941 2154,3,4,2,0,2154,2155,3,434,217,0,2155,2156,5,134,0,0,2156,2158,

942 1,0,0,0,2157,2095,1,0,0,0,2157,2135,1,0,0,0,2157,2152,1,0,0,0,2158,

943 337,1,0,0,0,2159,2161,3,350,175,0,2160,2159,1,0,0,0,2160,2161,1,

944 0,0,0,2161,2180,1,0,0,0,2162,2163,5,49,0,0,2163,2169,5,134,0,0,2164,

945 2166,3,350,175,0,2165,2164,1,0,0,0,2165,2166,1,0,0,0,2166,2167,1,

946 0,0,0,2167,2168,5,86,0,0,2168,2170,5,134,0,0,2169,2165,1,0,0,0,2169,

947 2170,1,0,0,0,2170,2181,1,0,0,0,2171,2172,5,86,0,0,2172,2178,5,134,

948 0,0,2173,2175,3,350,175,0,2174,2173,1,0,0,0,2174,2175,1,0,0,0,2175,

949 2176,1,0,0,0,2176,2177,5,49,0,0,2177,2179,5,134,0,0,2178,2174,1,

950 0,0,0,2178,2179,1,0,0,0,2179,2181,1,0,0,0,2180,2162,1,0,0,0,2180,

951 2171,1,0,0,0,2181,339,1,0,0,0,2182,2183,5,133,0,0,2183,2184,3,4,

952 2,0,2184,341,1,0,0,0,2185,2197,5,125,0,0,2186,2191,3,344,172,0,2187,

953 2188,5,132,0,0,2188,2190,3,344,172,0,2189,2187,1,0,0,0,2190,2193,

954 1,0,0,0,2191,2189,1,0,0,0,2191,2192,1,0,0,0,2192,2195,1,0,0,0,2193,

955 2191,1,0,0,0,2194,2196,5,132,0,0,2195,2194,1,0,0,0,2195,2196,1,0,

956 0,0,2196,2198,1,0,0,0,2197,2186,1,0,0,0,2197,2198,1,0,0,0,2198,2199,

957 1,0,0,0,2199,2200,5,126,0,0,2200,343,1,0,0,0,2201,2203,3,350,175,

958 0,2202,2201,1,0,0,0,2202,2203,1,0,0,0,2203,2204,1,0,0,0,2204,2207,

959 3,434,217,0,2205,2206,5,145,0,0,2206,2208,3,28,14,0,2207,2205,1,

960 0,0,0,2207,2208,1,0,0,0,2208,345,1,0,0,0,2209,2210,5,127,0,0,2210,

961 2211,3,348,174,0,2211,2212,5,133,0,0,2212,2214,3,356,178,0,2213,

962 2215,5,132,0,0,2214,2213,1,0,0,0,2214,2215,1,0,0,0,2215,2216,1,0,

963 0,0,2216,2217,5,128,0,0,2217,347,1,0,0,0,2218,2221,3,396,198,0,2219,

964 2221,3,434,217,0,2220,2218,1,0,0,0,2220,2219,1,0,0,0,2221,349,1,

965 0,0,0,2222,2224,3,352,176,0,2223,2222,1,0,0,0,2224,2225,1,0,0,0,

966 2225,2223,1,0,0,0,2225,2226,1,0,0,0,2226,351,1,0,0,0,2227,2231,5,

967 127,0,0,2228,2229,3,354,177,0,2229,2230,5,133,0,0,2230,2232,1,0,

968 0,0,2231,2228,1,0,0,0,2231,2232,1,0,0,0,2232,2233,1,0,0,0,2233,2235,

969 3,356,178,0,2234,2236,5,132,0,0,2235,2234,1,0,0,0,2235,2236,1,0,

970 0,0,2236,2237,1,0,0,0,2237,2238,5,128,0,0,2238,353,1,0,0,0,2239,

971 2242,3,396,198,0,2240,2242,3,434,217,0,2241,2239,1,0,0,0,2241,2240,

972 1,0,0,0,2242,355,1,0,0,0,2243,2248,3,358,179,0,2244,2245,5,132,0,

973 0,2245,2247,3,358,179,0,2246,2244,1,0,0,0,2247,2250,1,0,0,0,2248,

974 2246,1,0,0,0,2248,2249,1,0,0,0,2249,357,1,0,0,0,2250,2248,1,0,0,

975 0,2251,2264,3,2,1,0,2252,2261,5,129,0,0,2253,2258,3,360,180,0,2254,

976 2255,5,132,0,0,2255,2257,3,360,180,0,2256,2254,1,0,0,0,2257,2260,

977 1,0,0,0,2258,2256,1,0,0,0,2258,2259,1,0,0,0,2259,2262,1,0,0,0,2260,

978 2258,1,0,0,0,2261,2253,1,0,0,0,2261,2262,1,0,0,0,2262,2263,1,0,0,

979 0,2263,2265,5,130,0,0,2264,2252,1,0,0,0,2264,2265,1,0,0,0,2265,359,

980 1,0,0,0,2266,2267,3,434,217,0,2267,2268,5,133,0,0,2268,2270,1,0,

981 0,0,2269,2266,1,0,0,0,2269,2270,1,0,0,0,2270,2271,1,0,0,0,2271,2272,

982 3,28,14,0,2272,361,1,0,0,0,2273,2276,3,12,6,0,2274,2276,3,20,10,

983 0,2275,2273,1,0,0,0,2275,2274,1,0,0,0,2276,2281,1,0,0,0,2277,2280,

984 3,322,161,0,2278,2280,5,148,0,0,2279,2277,1,0,0,0,2279,2278,1,0,

985 0,0,2280,2283,1,0,0,0,2281,2279,1,0,0,0,2281,2282,1,0,0,0,2282,2284,

986 1,0,0,0,2283,2281,1,0,0,0,2284,2285,5,137,0,0,2285,2289,1,0,0,0,

987 2286,2287,5,108,0,0,2287,2289,5,137,0,0,2288,2275,1,0,0,0,2288,2286,

988 1,0,0,0,2289,363,1,0,0,0,2290,2295,3,366,183,0,2291,2292,5,132,0,

989 0,2292,2294,3,366,183,0,2293,2291,1,0,0,0,2294,2297,1,0,0,0,2295,

990 2293,1,0,0,0,2295,2296,1,0,0,0,2296,365,1,0,0,0,2297,2295,1,0,0,

991 0,2298,2299,3,434,217,0,2299,2300,5,145,0,0,2300,2301,3,368,184,

992 0,2301,367,1,0,0,0,2302,2304,5,140,0,0,2303,2302,1,0,0,0,2303,2304,

993 1,0,0,0,2304,2305,1,0,0,0,2305,2308,3,28,14,0,2306,2308,3,372,186,

994 0,2307,2303,1,0,0,0,2307,2306,1,0,0,0,2308,369,1,0,0,0,2309,2310,

995 3,434,217,0,2310,2311,5,127,0,0,2311,2312,3,28,14,0,2312,2313,5,

996 128,0,0,2313,371,1,0,0,0,2314,2315,5,89,0,0,2315,2316,3,4,2,0,2316,

997 2317,5,127,0,0,2317,2318,3,28,14,0,2318,2319,5,128,0,0,2319,2344,

998 1,0,0,0,2320,2322,5,89,0,0,2321,2323,3,4,2,0,2322,2321,1,0,0,0,2322,

999 2323,1,0,0,0,2323,2324,1,0,0,0,2324,2326,5,127,0,0,2325,2327,3,28,

1000 14,0,2326,2325,1,0,0,0,2326,2327,1,0,0,0,2327,2328,1,0,0,0,2328,

1001 2329,5,128,0,0,2329,2330,5,125,0,0,2330,2335,3,28,14,0,2331,2332,

1002 5,132,0,0,2332,2334,3,28,14,0,2333,2331,1,0,0,0,2334,2337,1,0,0,

1003 0,2335,2333,1,0,0,0,2335,2336,1,0,0,0,2336,2339,1,0,0,0,2337,2335,

1004 1,0,0,0,2338,2340,5,132,0,0,2339,2338,1,0,0,0,2339,2340,1,0,0,0,

1005 2340,2341,1,0,0,0,2341,2342,5,126,0,0,2342,2344,1,0,0,0,2343,2314,

1006 1,0,0,0,2343,2320,1,0,0,0,2344,373,1,0,0,0,2345,2346,5,145,0,0,2346,

1007 2347,5,147,0,0,2347,2348,4,187,1,1,2348,375,1,0,0,0,2349,2350,5,

1008 147,0,0,2350,2351,5,147,0,0,2351,2352,4,188,2,1,2352,377,1,0,0,0,

1009 2353,2354,5,147,0,0,2354,2355,5,159,0,0,2355,2356,4,189,3,1,2356,

1010 379,1,0,0,0,2357,2366,3,382,191,0,2358,2366,3,384,192,0,2359,2366,

1011 5,116,0,0,2360,2366,5,117,0,0,2361,2366,5,118,0,0,2362,2366,5,119,

1012 0,0,2363,2366,5,120,0,0,2364,2366,5,67,0,0,2365,2357,1,0,0,0,2365,

1013 2358,1,0,0,0,2365,2359,1,0,0,0,2365,2360,1,0,0,0,2365,2361,1,0,0,

1014 0,2365,2362,1,0,0,0,2365,2363,1,0,0,0,2365,2364,1,0,0,0,2366,381,

1015 1,0,0,0,2367,2368,7,15,0,0,2368,383,1,0,0,0,2369,2374,3,386,193,

1016 0,2370,2374,3,388,194,0,2371,2374,5,121,0,0,2372,2374,5,122,0,0,

1017 2373,2369,1,0,0,0,2373,2370,1,0,0,0,2373,2371,1,0,0,0,2373,2372,

1018 1,0,0,0,2374,385,1,0,0,0,2375,2379,5,123,0,0,2376,2378,3,390,195,

1019 0,2377,2376,1,0,0,0,2378,2381,1,0,0,0,2379,2377,1,0,0,0,2379,2380,

1020 1,0,0,0,2380,2382,1,0,0,0,2381,2379,1,0,0,0,2382,2383,5,176,0,0,

1021 2383,387,1,0,0,0,2384,2388,5,124,0,0,2385,2387,3,392,196,0,2386,

1022 2385,1,0,0,0,2387,2390,1,0,0,0,2388,2386,1,0,0,0,2388,2389,1,0,0,

1023 0,2389,2391,1,0,0,0,2390,2388,1,0,0,0,2391,2392,5,176,0,0,2392,389,

1024 1,0,0,0,2393,2398,3,394,197,0,2394,2398,5,172,0,0,2395,2398,5,174,

1025 0,0,2396,2398,5,177,0,0,2397,2393,1,0,0,0,2397,2394,1,0,0,0,2397,

1026 2395,1,0,0,0,2397,2396,1,0,0,0,2398,391,1,0,0,0,2399,2404,3,394,

1027 197,0,2400,2404,5,172,0,0,2401,2404,5,175,0,0,2402,2404,5,178,0,

1028 0,2403,2399,1,0,0,0,2403,2400,1,0,0,0,2403,2401,1,0,0,0,2403,2402,

1029 1,0,0,0,2404,393,1,0,0,0,2405,2410,3,28,14,0,2406,2407,5,132,0,0,

1030 2407,2409,3,28,14,0,2408,2406,1,0,0,0,2409,2412,1,0,0,0,2410,2408,

1031 1,0,0,0,2410,2411,1,0,0,0,2411,2419,1,0,0,0,2412,2410,1,0,0,0,2413,

1032 2415,5,133,0,0,2414,2416,5,180,0,0,2415,2414,1,0,0,0,2416,2417,1,

1033 0,0,0,2417,2415,1,0,0,0,2417,2418,1,0,0,0,2418,2420,1,0,0,0,2419,

1034 2413,1,0,0,0,2419,2420,1,0,0,0,2420,395,1,0,0,0,2421,2422,7,16,0,

1035 0,2422,397,1,0,0,0,2423,2424,5,26,0,0,2424,2426,3,434,217,0,2425,

1036 2427,3,230,115,0,2426,2425,1,0,0,0,2426,2427,1,0,0,0,2427,2429,1,

1037 0,0,0,2428,2430,3,234,117,0,2429,2428,1,0,0,0,2429,2430,1,0,0,0,

1038 2430,2432,1,0,0,0,2431,2433,3,238,119,0,2432,2431,1,0,0,0,2432,2433,

1039 1,0,0,0,2433,2434,1,0,0,0,2434,2436,3,250,125,0,2435,2437,5,134,

1040 0,0,2436,2435,1,0,0,0,2436,2437,1,0,0,0,2437,399,1,0,0,0,2438,2440,

1041 7,17,0,0,2439,2438,1,0,0,0,2439,2440,1,0,0,0,2440,2441,1,0,0,0,2441,

1042 2442,5,92,0,0,2442,2444,3,434,217,0,2443,2445,3,230,115,0,2444,2443,

1043 1,0,0,0,2444,2445,1,0,0,0,2445,2447,1,0,0,0,2446,2448,3,314,157,

1044 0,2447,2446,1,0,0,0,2447,2448,1,0,0,0,2448,2450,1,0,0,0,2449,2451,

1045 3,238,119,0,2450,2449,1,0,0,0,2450,2451,1,0,0,0,2451,2452,1,0,0,

1046 0,2452,2454,3,316,158,0,2453,2455,5,134,0,0,2454,2453,1,0,0,0,2454,

1047 2455,1,0,0,0,2455,401,1,0,0,0,2456,2457,5,56,0,0,2457,2459,3,434,

1048 217,0,2458,2460,3,326,163,0,2459,2458,1,0,0,0,2459,2460,1,0,0,0,

1049 2460,2462,1,0,0,0,2461,2463,3,332,166,0,2462,2461,1,0,0,0,2462,2463,

1050 1,0,0,0,2463,2465,1,0,0,0,2464,2466,3,238,119,0,2465,2464,1,0,0,

1051 0,2465,2466,1,0,0,0,2466,2467,1,0,0,0,2467,2469,3,250,125,0,2468,

1052 2470,5,134,0,0,2469,2468,1,0,0,0,2469,2470,1,0,0,0,2470,403,1,0,

1053 0,0,2471,2472,5,37,0,0,2472,2474,3,434,217,0,2473,2475,3,340,170,

1054 0,2474,2473,1,0,0,0,2474,2475,1,0,0,0,2475,2476,1,0,0,0,2476,2478,

1055 3,342,171,0,2477,2479,5,134,0,0,2478,2477,1,0,0,0,2478,2479,1,0,

1056 0,0,2479,405,1,0,0,0,2480,2481,5,31,0,0,2481,2482,3,274,137,0,2482,

1057 2484,3,434,217,0,2483,2485,3,326,163,0,2484,2483,1,0,0,0,2484,2485,

1058 1,0,0,0,2485,2486,1,0,0,0,2486,2488,5,129,0,0,2487,2489,3,280,140,

1059 0,2488,2487,1,0,0,0,2488,2489,1,0,0,0,2489,2490,1,0,0,0,2490,2492,

1060 5,130,0,0,2491,2493,3,238,119,0,2492,2491,1,0,0,0,2492,2493,1,0,

1061 0,0,2493,2494,1,0,0,0,2494,2495,5,134,0,0,2495,407,1,0,0,0,2496,

1062 2497,5,39,0,0,2497,2506,3,4,2,0,2498,2499,3,268,134,0,2499,2500,

1063 5,134,0,0,2500,2507,1,0,0,0,2501,2502,3,276,138,0,2502,2503,5,125,

1064 0,0,2503,2504,3,300,150,0,2504,2505,5,126,0,0,2505,2507,1,0,0,0,

1065 2506,2498,1,0,0,0,2506,2501,1,0,0,0,2507,409,1,0,0,0,2508,2509,3,

1066 268,134,0,2509,2510,5,134,0,0,2510,411,1,0,0,0,2511,2525,3,276,138,

1067 0,2512,2513,5,125,0,0,2513,2514,3,290,145,0,2514,2519,5,126,0,0,

1068 2515,2516,5,145,0,0,2516,2517,3,272,136,0,2517,2518,5,134,0,0,2518,

1069 2520,1,0,0,0,2519,2515,1,0,0,0,2519,2520,1,0,0,0,2520,2526,1,0,0,

1070 0,2521,2522,3,374,187,0,2522,2523,3,74,37,0,2523,2524,5,134,0,0,

1071 2524,2526,1,0,0,0,2525,2512,1,0,0,0,2525,2521,1,0,0,0,2526,413,1,

1072 0,0,0,2527,2528,5,27,0,0,2528,2529,3,4,2,0,2529,2530,3,264,132,0,

1073 2530,2531,5,134,0,0,2531,415,1,0,0,0,2532,2533,5,94,0,0,2533,2534,

1074 5,127,0,0,2534,2535,3,280,140,0,2535,2544,5,128,0,0,2536,2537,5,

1075 125,0,0,2537,2538,3,290,145,0,2538,2539,5,126,0,0,2539,2545,1,0,

1076 0,0,2540,2541,3,374,187,0,2541,2542,3,74,37,0,2542,2543,5,134,0,

1077 0,2543,2545,1,0,0,0,2544,2536,1,0,0,0,2544,2540,1,0,0,0,2545,417,

1078 1,0,0,0,2546,2547,5,144,0,0,2547,2548,3,434,217,0,2548,2549,5,129,

1079 0,0,2549,2550,5,130,0,0,2550,2551,3,312,156,0,2551,419,1,0,0,0,2552,

1080 2553,3,434,217,0,2553,2555,5,129,0,0,2554,2556,3,280,140,0,2555,

1081 2554,1,0,0,0,2555,2556,1,0,0,0,2556,2557,1,0,0,0,2557,2559,5,130,

1082 0,0,2558,2560,3,310,155,0,2559,2558,1,0,0,0,2559,2560,1,0,0,0,2560,

1083 2561,1,0,0,0,2561,2562,3,312,156,0,2562,421,1,0,0,0,2563,2565,3,

1084 424,212,0,2564,2566,3,230,115,0,2565,2564,1,0,0,0,2565,2566,1,0,

1085 0,0,2566,2567,1,0,0,0,2567,2569,5,129,0,0,2568,2570,3,280,140,0,

1086 2569,2568,1,0,0,0,2569,2570,1,0,0,0,2570,2571,1,0,0,0,2571,2573,

1087 5,130,0,0,2572,2574,3,238,119,0,2573,2572,1,0,0,0,2573,2574,1,0,

1088 0,0,2574,2580,1,0,0,0,2575,2581,3,278,139,0,2576,2577,3,374,187,

1089 0,2577,2578,3,74,37,0,2578,2579,5,134,0,0,2579,2581,1,0,0,0,2580,

1090 2575,1,0,0,0,2580,2576,1,0,0,0,2581,423,1,0,0,0,2582,2588,3,434,

1091 217,0,2583,2584,3,434,217,0,2584,2585,5,149,0,0,2585,2586,3,434,

1092 217,0,2586,2588,1,0,0,0,2587,2582,1,0,0,0,2587,2583,1,0,0,0,2588,

1093 2596,1,0,0,0,2589,2591,3,22,11,0,2590,2589,1,0,0,0,2590,2591,1,0,

1094 0,0,2591,2592,1,0,0,0,2592,2593,5,131,0,0,2593,2595,3,434,217,0,

1095 2594,2590,1,0,0,0,2595,2598,1,0,0,0,2596,2594,1,0,0,0,2596,2597,

1096 1,0,0,0,2597,425,1,0,0,0,2598,2596,1,0,0,0,2599,2600,5,70,0,0,2600,

1097 2601,3,306,153,0,2601,2603,5,129,0,0,2602,2604,5,54,0,0,2603,2602,

1098 1,0,0,0,2603,2604,1,0,0,0,2604,2605,1,0,0,0,2605,2611,3,428,214,

1099 0,2606,2608,5,132,0,0,2607,2609,5,54,0,0,2608,2607,1,0,0,0,2608,

1100 2609,1,0,0,0,2609,2610,1,0,0,0,2610,2612,3,428,214,0,2611,2606,1,

1101 0,0,0,2611,2612,1,0,0,0,2612,2613,1,0,0,0,2613,2619,5,130,0,0,2614,

1102 2620,3,312,156,0,2615,2616,3,374,187,0,2616,2617,3,74,37,0,2617,

1103 2618,5,134,0,0,2618,2620,1,0,0,0,2619,2614,1,0,0,0,2619,2615,1,0,

1104 0,0,2620,427,1,0,0,0,2621,2622,3,4,2,0,2622,2625,3,434,217,0,2623,

1105 2624,5,145,0,0,2624,2626,3,28,14,0,2625,2623,1,0,0,0,2625,2626,1,

1106 0,0,0,2626,429,1,0,0,0,2627,2629,5,129,0,0,2628,2630,3,24,12,0,2629,

1107 2628,1,0,0,0,2629,2630,1,0,0,0,2630,2631,1,0,0,0,2631,2632,5,130,

1108 0,0,2632,431,1,0,0,0,2633,2635,5,129,0,0,2634,2636,3,24,12,0,2635,

1109 2634,1,0,0,0,2635,2636,1,0,0,0,2636,2637,1,0,0,0,2637,2639,5,130,

1110 0,0,2638,2640,3,88,44,0,2639,2638,1,0,0,0,2639,2640,1,0,0,0,2640,

1111 433,1,0,0,0,2641,2642,7,18,0,0,2642,435,1,0,0,0,344,437,440,443,

1112 448,452,458,461,466,470,477,479,487,495,501,505,510,520,528,538,

1113 544,547,551,559,564,574,587,595,601,603,610,618,626,634,642,650,

1114 660,662,668,673,681,689,697,699,702,709,714,721,725,727,755,759,

1115 764,768,776,779,784,788,792,798,812,818,830,834,839,843,849,857,

1116 866,884,887,892,895,910,916,920,926,931,934,942,950,961,966,971,

1117 973,982,990,997,1005,1009,1018,1023,1025,1034,1042,1046,1051,1053,

1118 1058,1062,1069,1077,1079,1083,1086,1089,1097,1107,1124,1131,1135,

1119 1145,1150,1157,1166,1171,1178,1190,1201,1209,1214,1223,1232,1241,

1120 1247,1252,1256,1260,1264,1268,1275,1283,1296,1306,1328,1332,1336,

1121 1341,1361,1366,1371,1378,1381,1403,1415,1419,1427,1437,1444,1448,

1122 1453,1456,1461,1469,1474,1481,1487,1495,1503,1506,1513,1520,1524,

1123 1527,1533,1537,1543,1557,1563,1570,1575,1578,1581,1588,1598,1615,

1124 1620,1624,1627,1630,1637,1643,1651,1657,1667,1675,1681,1692,1696,

1125 1698,1703,1707,1714,1723,1730,1733,1736,1740,1745,1758,1768,1775,

1126 1787,1794,1806,1812,1816,1820,1826,1832,1834,1841,1845,1848,1852,

1127 1862,1865,1872,1875,1880,1885,1887,1890,1893,1899,1902,1914,1918,

1128 1921,1931,1934,1940,1967,1980,1986,1995,2001,2004,2012,2016,2022,

1129 2028,2034,2045,2049,2051,2061,2067,2070,2083,2089,2092,2095,2102,

1130 2107,2111,2115,2132,2135,2140,2144,2148,2157,2160,2165,2169,2174,

1131 2178,2180,2191,2195,2197,2202,2207,2214,2220,2225,2231,2235,2241,

1132 2248,2258,2261,2264,2269,2275,2279,2281,2288,2295,2303,2307,2322,

1133 2326,2335,2339,2343,2365,2373,2379,2388,2397,2403,2410,2417,2419,

1134 2426,2429,2432,2436,2439,2444,2447,2450,2454,2459,2462,2465,2469,

1135 2474,2478,2484,2488,2492,2506,2519,2525,2544,2555,2559,2565,2569,

1136 2573,2580,2587,2590,2596,2603,2608,2611,2619,2625,2629,2635,2639

1137 ]

1138

1139class CSharpParser ( CSharpParserBase ):

1140

1141 grammarFileName = "CSharpParser.g4"

1142

1143 atn = ATNDeserializer().deserialize(serializedATN())

1144

1145 decisionsToDFA = [ DFA(ds, i) for i, ds in enumerate(atn.decisionToState) ]

1146

1147 sharedContextCache = PredictionContextCache()

1148

1149 literalNames = [ "<INVALID>", "'\\u00EF\\u00BB\\u00BF'", "<INVALID>",

1150 "'/***/'", "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",

1151 "'#'", "'abstract'", "'add'", "'alias'", "'__arglist'",

1152 "'as'", "'ascending'", "'async'", "'await'", "'base'",

1153 "'bool'", "'break'", "'by'", "'byte'", "'case'", "'catch'",

1154 "'char'", "'checked'", "'class'", "'const'", "'continue'",

1155 "'decimal'", "'default'", "'delegate'", "'descending'",

1156 "'do'", "'double'", "'dynamic'", "'else'", "'enum'",

1157 "'equals'", "'event'", "'explicit'", "'extern'", "'false'",

1158 "'finally'", "'fixed'", "'float'", "'for'", "'foreach'",

1159 "'from'", "'get'", "'goto'", "'group'", "'if'", "'implicit'",

1160 "'in'", "'int'", "'interface'", "'internal'", "'into'",

1161 "'is'", "'join'", "'let'", "'lock'", "'long'", "'nameof'",

1162 "'namespace'", "'new'", "'null'", "'object'", "'on'",

1163 "'operator'", "'orderby'", "'out'", "'override'", "'params'",

1164 "'partial'", "'private'", "'protected'", "'public'",

1165 "'readonly'", "'ref'", "'remove'", "'return'", "'sbyte'",

1166 "'sealed'", "'select'", "'set'", "'short'", "'sizeof'",

1167 "'stackalloc'", "'static'", "'string'", "'struct'",

1168 "'switch'", "'this'", "'throw'", "'true'", "'try'",

1169 "'typeof'", "'uint'", "'ulong'", "'unchecked'", "'unmanaged'",

1170 "'unsafe'", "'ushort'", "'using'", "'var'", "'virtual'",

1171 "'void'", "'volatile'", "'when'", "'where'", "'while'",

1172 "'yield'", "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",

1173 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",

1174 "<INVALID>", "<INVALID>", "<INVALID>", "'{'", "'}'",

1175 "'['", "']'", "'('", "')'", "'.'", "','", "':'", "';'",

1176 "'+'", "'-'", "'*'", "'/'", "'%'", "'&'", "'|'", "'^'",

1177 "'!'", "'~'", "'='", "'<'", "'>'", "'?'", "'::'", "'??'",

1178 "'++'", "'--'", "'&&'", "'||'", "'->'", "'=='", "'!='",

1179 "'<='", "'>='", "'+='", "'-='", "'*='", "'/='", "'%='",

1180 "'&='", "'|='", "'^='", "'<<'", "'<<='", "'??='", "'..'",

1181 "'{{'", "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",

1182 "<INVALID>", "<INVALID>", "<INVALID>", "<INVALID>",

1183 "<INVALID>", "<INVALID>", "'define'", "'undef'", "'elif'",

1184 "'endif'", "'line'", "<INVALID>", "<INVALID>", "<INVALID>",

1185 "<INVALID>", "<INVALID>", "<INVALID>", "'hidden'",

1186 "<INVALID>", "<INVALID>", "<INVALID>", "'}}'" ]

1187

1188 symbolicNames = [ "<INVALID>", "BYTE_ORDER_MARK", "SINGLE_LINE_DOC_COMMENT",

1189 "EMPTY_DELIMITED_DOC_COMMENT", "DELIMITED_DOC_COMMENT",

1190 "SINGLE_LINE_COMMENT", "DELIMITED_COMMENT", "WHITESPACES",

1191 "SHARP", "ABSTRACT", "ADD", "ALIAS", "ARGLIST", "AS",

1192 "ASCENDING", "ASYNC", "AWAIT", "BASE", "BOOL", "BREAK",

1193 "BY", "BYTE", "CASE", "CATCH", "CHAR", "CHECKED",

1194 "CLASS", "CONST", "CONTINUE", "DECIMAL", "DEFAULT",

1195 "DELEGATE", "DESCENDING", "DO", "DOUBLE", "DYNAMIC",

1196 "ELSE", "ENUM", "EQUALS", "EVENT", "EXPLICIT", "EXTERN",

1197 "FALSE", "FINALLY", "FIXED", "FLOAT", "FOR", "FOREACH",

1198 "FROM", "GET", "GOTO", "GROUP", "IF", "IMPLICIT",

1199 "IN", "INT", "INTERFACE", "INTERNAL", "INTO", "IS",

1200 "JOIN", "LET", "LOCK", "LONG", "NAMEOF", "NAMESPACE",

1201 "NEW", "NULL_", "OBJECT", "ON", "OPERATOR", "ORDERBY",

1202 "OUT", "OVERRIDE", "PARAMS", "PARTIAL", "PRIVATE",

1203 "PROTECTED", "PUBLIC", "READONLY", "REF", "REMOVE",

1204 "RETURN", "SBYTE", "SEALED", "SELECT", "SET", "SHORT",

1205 "SIZEOF", "STACKALLOC", "STATIC", "STRING", "STRUCT",

1206 "SWITCH", "THIS", "THROW", "TRUE", "TRY", "TYPEOF",

1207 "UINT", "ULONG", "UNCHECKED", "UNMANAGED", "UNSAFE",

1208 "USHORT", "USING", "VAR", "VIRTUAL", "VOID", "VOLATILE",

1209 "WHEN", "WHERE", "WHILE", "YIELD", "IDENTIFIER", "LITERAL_ACCESS",

1210 "INTEGER_LITERAL", "HEX_INTEGER_LITERAL", "BIN_INTEGER_LITERAL",

1211 "REAL_LITERAL", "CHARACTER_LITERAL", "REGULAR_STRING",

1212 "VERBATIUM_STRING", "INTERPOLATED_REGULAR_STRING_START",

1213 "INTERPOLATED_VERBATIUM_STRING_START", "OPEN_BRACE",

1214 "CLOSE_BRACE", "OPEN_BRACKET", "CLOSE_BRACKET", "OPEN_PARENS",

1215 "CLOSE_PARENS", "DOT", "COMMA", "COLON", "SEMICOLON",

1216 "PLUS", "MINUS", "STAR", "DIV", "PERCENT", "AMP",

1217 "BITWISE_OR", "CARET", "BANG", "TILDE", "ASSIGNMENT",

1218 "LT", "GT", "INTERR", "DOUBLE_COLON", "OP_COALESCING",

1219 "OP_INC", "OP_DEC", "OP_AND", "OP_OR", "OP_PTR", "OP_EQ",

1220 "OP_NE", "OP_LE", "OP_GE", "OP_ADD_ASSIGNMENT", "OP_SUB_ASSIGNMENT",

1221 "OP_MULT_ASSIGNMENT", "OP_DIV_ASSIGNMENT", "OP_MOD_ASSIGNMENT",

1222 "OP_AND_ASSIGNMENT", "OP_OR_ASSIGNMENT", "OP_XOR_ASSIGNMENT",

1223 "OP_LEFT_SHIFT", "OP_LEFT_SHIFT_ASSIGNMENT", "OP_COALESCING_ASSIGNMENT",

1224 "OP_RANGE", "DOUBLE_CURLY_INSIDE", "OPEN_BRACE_INSIDE",

1225 "REGULAR_CHAR_INSIDE", "VERBATIUM_DOUBLE_QUOTE_INSIDE",

1226 "DOUBLE_QUOTE_INSIDE", "REGULAR_STRING_INSIDE", "VERBATIUM_INSIDE_STRING",

1227 "CLOSE_BRACE_INSIDE", "FORMAT_STRING", "DIRECTIVE_WHITESPACES",

1228 "DIGITS", "DEFINE", "UNDEF", "ELIF", "ENDIF", "LINE",

1229 "ERROR", "WARNING", "REGION", "ENDREGION", "PRAGMA",

1230 "NULLABLE", "DIRECTIVE_HIDDEN", "CONDITIONAL_SYMBOL",

1231 "DIRECTIVE_NEW_LINE", "TEXT", "DOUBLE_CURLY_CLOSE_INSIDE" ]

1232

1233 RULE_compilation_unit = 0

1234 RULE_namespace_or_type_name = 1

1235 RULE_type_ = 2

1236 RULE_base_type = 3

1237 RULE_tuple_type = 4

1238 RULE_tuple_element = 5

1239 RULE_simple_type = 6

1240 RULE_numeric_type = 7

1241 RULE_integral_type = 8

1242 RULE_floating_point_type = 9

1243 RULE_class_type = 10

1244 RULE_type_argument_list = 11

1245 RULE_argument_list = 12

1246 RULE_argument = 13

1247 RULE_expression = 14

1248 RULE_non_assignment_expression = 15

1249 RULE_assignment = 16

1250 RULE_assignment_operator = 17

1251 RULE_conditional_expression = 18

1252 RULE_null_coalescing_expression = 19

1253 RULE_conditional_or_expression = 20

1254 RULE_conditional_and_expression = 21

1255 RULE_inclusive_or_expression = 22

1256 RULE_exclusive_or_expression = 23

1257 RULE_and_expression = 24

1258 RULE_equality_expression = 25

1259 RULE_relational_expression = 26

1260 RULE_shift_expression = 27

1261 RULE_additive_expression = 28

1262 RULE_multiplicative_expression = 29

1263 RULE_switch_expression = 30

1264 RULE_switch_expression_arms = 31

1265 RULE_switch_expression_arm = 32

1266 RULE_range_expression = 33

1267 RULE_unary_expression = 34

1268 RULE_primary_expression = 35

1269 RULE_primary_expression_start = 36

1270 RULE_throwable_expression = 37

1271 RULE_throw_expression = 38

1272 RULE_member_access = 39

1273 RULE_bracket_expression = 40

1274 RULE_indexer_argument = 41

1275 RULE_predefined_type = 42

1276 RULE_expression_list = 43

1277 RULE_object_or_collection_initializer = 44

1278 RULE_object_initializer = 45

1279 RULE_member_initializer_list = 46

1280 RULE_member_initializer = 47

1281 RULE_initializer_value = 48

1282 RULE_collection_initializer = 49

1283 RULE_element_initializer = 50

1284 RULE_anonymous_object_initializer = 51

1285 RULE_member_declarator_list = 52

1286 RULE_member_declarator = 53

1287 RULE_unbound_type_name = 54

1288 RULE_generic_dimension_specifier = 55

1289 RULE_isType = 56

1290 RULE_isTypePatternArms = 57

1291 RULE_isTypePatternArm = 58

1292 RULE_lambda_expression = 59

1293 RULE_anonymous_function_signature = 60

1294 RULE_explicit_anonymous_function_parameter_list = 61

1295 RULE_explicit_anonymous_function_parameter = 62

1296 RULE_implicit_anonymous_function_parameter_list = 63

1297 RULE_anonymous_function_body = 64

1298 RULE_query_expression = 65

1299 RULE_from_clause = 66

1300 RULE_query_body = 67

1301 RULE_query_body_clause = 68

1302 RULE_let_clause = 69

1303 RULE_where_clause = 70

1304 RULE_combined_join_clause = 71

1305 RULE_orderby_clause = 72

1306 RULE_ordering = 73

1307 RULE_select_or_group_clause = 74

1308 RULE_query_continuation = 75

1309 RULE_statement = 76

1310 RULE_declarationStatement = 77

1311 RULE_local_function_declaration = 78

1312 RULE_local_function_header = 79

1313 RULE_local_function_modifiers = 80

1314 RULE_local_function_body = 81

1315 RULE_labeled_Statement = 82

1316 RULE_embedded_statement = 83

1317 RULE_simple_embedded_statement = 84

1318 RULE_block = 85

1319 RULE_local_variable_declaration = 86

1320 RULE_local_variable_type = 87

1321 RULE_local_variable_declarator = 88

1322 RULE_local_variable_initializer = 89

1323 RULE_local_constant_declaration = 90

1324 RULE_if_body = 91

1325 RULE_switch_section = 92

1326 RULE_switch_label = 93

1327 RULE_case_guard = 94

1328 RULE_statement_list = 95

1329 RULE_for_initializer = 96

1330 RULE_for_iterator = 97

1331 RULE_catch_clauses = 98

1332 RULE_specific_catch_clause = 99

1333 RULE_general_catch_clause = 100

1334 RULE_exception_filter = 101

1335 RULE_finally_clause = 102

1336 RULE_resource_acquisition = 103

1337 RULE_namespace_declaration = 104

1338 RULE_qualified_identifier = 105

1339 RULE_namespace_body = 106

1340 RULE_extern_alias_directives = 107

1341 RULE_extern_alias_directive = 108

1342 RULE_using_directives = 109

1343 RULE_using_directive = 110

1344 RULE_namespace_member_declarations = 111

1345 RULE_namespace_member_declaration = 112

1346 RULE_type_declaration = 113

1347 RULE_qualified_alias_member = 114

1348 RULE_type_parameter_list = 115

1349 RULE_type_parameter = 116

1350 RULE_class_base = 117

1351 RULE_interface_type_list = 118

1352 RULE_type_parameter_constraints_clauses = 119

1353 RULE_type_parameter_constraints_clause = 120

1354 RULE_type_parameter_constraints = 121

1355 RULE_primary_constraint = 122

1356 RULE_secondary_constraints = 123

1357 RULE_constructor_constraint = 124

1358 RULE_class_body = 125

1359 RULE_class_member_declarations = 126

1360 RULE_class_member_declaration = 127

1361 RULE_all_member_modifiers = 128

1362 RULE_all_member_modifier = 129

1363 RULE_common_member_declaration = 130

1364 RULE_typed_member_declaration = 131

1365 RULE_constant_declarators = 132

1366 RULE_constant_declarator = 133

1367 RULE_variable_declarators = 134

1368 RULE_variable_declarator = 135

1369 RULE_variable_initializer = 136

1370 RULE_return_type = 137

1371 RULE_member_name = 138

1372 RULE_method_body = 139

1373 RULE_formal_parameter_list = 140

1374 RULE_fixed_parameters = 141

1375 RULE_fixed_parameter = 142

1376 RULE_parameter_modifier = 143

1377 RULE_parameter_array = 144

1378 RULE_accessor_declarations = 145

1379 RULE_get_accessor_declaration = 146

1380 RULE_set_accessor_declaration = 147

1381 RULE_accessor_modifier = 148

1382 RULE_accessor_body = 149

1383 RULE_event_accessor_declarations = 150

1384 RULE_add_accessor_declaration = 151

1385 RULE_remove_accessor_declaration = 152

1386 RULE_overloadable_operator = 153

1387 RULE_conversion_operator_declarator = 154

1388 RULE_constructor_initializer = 155

1389 RULE_body = 156

1390 RULE_struct_interfaces = 157

1391 RULE_struct_body = 158

1392 RULE_struct_member_declaration = 159

1393 RULE_array_type = 160

1394 RULE_rank_specifier = 161

1395 RULE_array_initializer = 162

1396 RULE_variant_type_parameter_list = 163

1397 RULE_variant_type_parameter = 164

1398 RULE_variance_annotation = 165

1399 RULE_interface_base = 166

1400 RULE_interface_body = 167

1401 RULE_interface_member_declaration = 168

1402 RULE_interface_accessors = 169

1403 RULE_enum_base = 170

1404 RULE_enum_body = 171

1405 RULE_enum_member_declaration = 172

1406 RULE_global_attribute_section = 173

1407 RULE_global_attribute_target = 174

1408 RULE_attributes = 175

1409 RULE_attribute_section = 176

1410 RULE_attribute_target = 177

1411 RULE_attribute_list = 178

1412 RULE_attribute = 179

1413 RULE_attribute_argument = 180

1414 RULE_pointer_type = 181

1415 RULE_fixed_pointer_declarators = 182

1416 RULE_fixed_pointer_declarator = 183

1417 RULE_fixed_pointer_initializer = 184

1418 RULE_fixed_size_buffer_declarator = 185

1419 RULE_stackalloc_initializer = 186

1420 RULE_right_arrow = 187

1421 RULE_right_shift = 188

1422 RULE_right_shift_assignment = 189

1423 RULE_literal = 190

1424 RULE_boolean_literal = 191

1425 RULE_string_literal = 192

1426 RULE_interpolated_regular_string = 193

1427 RULE_interpolated_verbatium_string = 194

1428 RULE_interpolated_regular_string_part = 195

1429 RULE_interpolated_verbatium_string_part = 196

1430 RULE_interpolated_string_expression = 197

1431 RULE_keyword = 198

1432 RULE_class_definition = 199

1433 RULE_struct_definition = 200

1434 RULE_interface_definition = 201

1435 RULE_enum_definition = 202

1436 RULE_delegate_definition = 203

1437 RULE_event_declaration = 204

1438 RULE_field_declaration = 205

1439 RULE_property_declaration = 206

1440 RULE_constant_declaration = 207

1441 RULE_indexer_declaration = 208

1442 RULE_destructor_definition = 209

1443 RULE_constructor_declaration = 210

1444 RULE_method_declaration = 211

1445 RULE_method_member_name = 212

1446 RULE_operator_declaration = 213

1447 RULE_arg_declaration = 214

1448 RULE_method_invocation = 215

1449 RULE_object_creation_expression = 216

1450 RULE_identifier = 217

1451

1452 ruleNames = [ "compilation_unit", "namespace_or_type_name", "type_",

1453 "base_type", "tuple_type", "tuple_element", "simple_type",

1454 "numeric_type", "integral_type", "floating_point_type",

1455 "class_type", "type_argument_list", "argument_list",

1456 "argument", "expression", "non_assignment_expression",

1457 "assignment", "assignment_operator", "conditional_expression",

1458 "null_coalescing_expression", "conditional_or_expression",

1459 "conditional_and_expression", "inclusive_or_expression",

1460 "exclusive_or_expression", "and_expression", "equality_expression",

1461 "relational_expression", "shift_expression", "additive_expression",

1462 "multiplicative_expression", "switch_expression", "switch_expression_arms",

1463 "switch_expression_arm", "range_expression", "unary_expression",

1464 "primary_expression", "primary_expression_start", "throwable_expression",

1465 "throw_expression", "member_access", "bracket_expression",

1466 "indexer_argument", "predefined_type", "expression_list",

1467 "object_or_collection_initializer", "object_initializer",

1468 "member_initializer_list", "member_initializer", "initializer_value",

1469 "collection_initializer", "element_initializer", "anonymous_object_initializer",

1470 "member_declarator_list", "member_declarator", "unbound_type_name",

1471 "generic_dimension_specifier", "isType", "isTypePatternArms",

1472 "isTypePatternArm", "lambda_expression", "anonymous_function_signature",

1473 "explicit_anonymous_function_parameter_list", "explicit_anonymous_function_parameter",

1474 "implicit_anonymous_function_parameter_list", "anonymous_function_body",

1475 "query_expression", "from_clause", "query_body", "query_body_clause",

1476 "let_clause", "where_clause", "combined_join_clause",

1477 "orderby_clause", "ordering", "select_or_group_clause",

1478 "query_continuation", "statement", "declarationStatement",

1479 "local_function_declaration", "local_function_header",

1480 "local_function_modifiers", "local_function_body", "labeled_Statement",

1481 "embedded_statement", "simple_embedded_statement", "block",

1482 "local_variable_declaration", "local_variable_type",

1483 "local_variable_declarator", "local_variable_initializer",

1484 "local_constant_declaration", "if_body", "switch_section",

1485 "switch_label", "case_guard", "statement_list", "for_initializer",

1486 "for_iterator", "catch_clauses", "specific_catch_clause",

1487 "general_catch_clause", "exception_filter", "finally_clause",

1488 "resource_acquisition", "namespace_declaration", "qualified_identifier",

1489 "namespace_body", "extern_alias_directives", "extern_alias_directive",

1490 "using_directives", "using_directive", "namespace_member_declarations",

1491 "namespace_member_declaration", "type_declaration", "qualified_alias_member",

1492 "type_parameter_list", "type_parameter", "class_base",

1493 "interface_type_list", "type_parameter_constraints_clauses",

1494 "type_parameter_constraints_clause", "type_parameter_constraints",

1495 "primary_constraint", "secondary_constraints", "constructor_constraint",

1496 "class_body", "class_member_declarations", "class_member_declaration",

1497 "all_member_modifiers", "all_member_modifier", "common_member_declaration",

1498 "typed_member_declaration", "constant_declarators", "constant_declarator",

1499 "variable_declarators", "variable_declarator", "variable_initializer",

1500 "return_type", "member_name", "method_body", "formal_parameter_list",

1501 "fixed_parameters", "fixed_parameter", "parameter_modifier",

1502 "parameter_array", "accessor_declarations", "get_accessor_declaration",

1503 "set_accessor_declaration", "accessor_modifier", "accessor_body",

1504 "event_accessor_declarations", "add_accessor_declaration",

1505 "remove_accessor_declaration", "overloadable_operator",

1506 "conversion_operator_declarator", "constructor_initializer",

1507 "body", "struct_interfaces", "struct_body", "struct_member_declaration",

1508 "array_type", "rank_specifier", "array_initializer",

1509 "variant_type_parameter_list", "variant_type_parameter",

1510 "variance_annotation", "interface_base", "interface_body",

1511 "interface_member_declaration", "interface_accessors",

1512 "enum_base", "enum_body", "enum_member_declaration",

1513 "global_attribute_section", "global_attribute_target",

1514 "attributes", "attribute_section", "attribute_target",

1515 "attribute_list", "attribute", "attribute_argument",

1516 "pointer_type", "fixed_pointer_declarators", "fixed_pointer_declarator",

1517 "fixed_pointer_initializer", "fixed_size_buffer_declarator",

1518 "stackalloc_initializer", "right_arrow", "right_shift",

1519 "right_shift_assignment", "literal", "boolean_literal",

1520 "string_literal", "interpolated_regular_string", "interpolated_verbatium_string",

1521 "interpolated_regular_string_part", "interpolated_verbatium_string_part",

1522 "interpolated_string_expression", "keyword", "class_definition",

1523 "struct_definition", "interface_definition", "enum_definition",

1524 "delegate_definition", "event_declaration", "field_declaration",

1525 "property_declaration", "constant_declaration", "indexer_declaration",

1526 "destructor_definition", "constructor_declaration", "method_declaration",

1527 "method_member_name", "operator_declaration", "arg_declaration",

1528 "method_invocation", "object_creation_expression", "identifier" ]

1529

1530 EOF = Token.EOF

1531 BYTE_ORDER_MARK=1

1532 SINGLE_LINE_DOC_COMMENT=2

1533 EMPTY_DELIMITED_DOC_COMMENT=3

1534 DELIMITED_DOC_COMMENT=4

1535 SINGLE_LINE_COMMENT=5

1536 DELIMITED_COMMENT=6

1537 WHITESPACES=7

1538 SHARP=8

1539 ABSTRACT=9

1540 ADD=10

1541 ALIAS=11

1542 ARGLIST=12

1543 AS=13

1544 ASCENDING=14

1545 ASYNC=15

1546 AWAIT=16

1547 BASE=17

1548 BOOL=18

1549 BREAK=19

1550 BY=20

1551 BYTE=21

1552 CASE=22

1553 CATCH=23

1554 CHAR=24

1555 CHECKED=25

1556 CLASS=26

1557 CONST=27

1558 CONTINUE=28

1559 DECIMAL=29

1560 DEFAULT=30

1561 DELEGATE=31

1562 DESCENDING=32

1563 DO=33

1564 DOUBLE=34

1565 DYNAMIC=35

1566 ELSE=36

1567 ENUM=37

1568 EQUALS=38

1569 EVENT=39

1570 EXPLICIT=40

1571 EXTERN=41

1572 FALSE=42

1573 FINALLY=43

1574 FIXED=44

1575 FLOAT=45

1576 FOR=46

1577 FOREACH=47

1578 FROM=48

1579 GET=49

1580 GOTO=50

1581 GROUP=51

1582 IF=52

1583 IMPLICIT=53

1584 IN=54

1585 INT=55

1586 INTERFACE=56

1587 INTERNAL=57

1588 INTO=58

1589 IS=59

1590 JOIN=60

1591 LET=61

1592 LOCK=62

1593 LONG=63

1594 NAMEOF=64

1595 NAMESPACE=65

1596 NEW=66

1597 NULL_=67

1598 OBJECT=68

1599 ON=69

1600 OPERATOR=70

1601 ORDERBY=71

1602 OUT=72

1603 OVERRIDE=73

1604 PARAMS=74

1605 PARTIAL=75

1606 PRIVATE=76

1607 PROTECTED=77

1608 PUBLIC=78

1609 READONLY=79

1610 REF=80

1611 REMOVE=81

1612 RETURN=82

1613 SBYTE=83

1614 SEALED=84

1615 SELECT=85

1616 SET=86

1617 SHORT=87

1618 SIZEOF=88

1619 STACKALLOC=89

1620 STATIC=90

1621 STRING=91

1622 STRUCT=92

1623 SWITCH=93

1624 THIS=94

1625 THROW=95

1626 TRUE=96

1627 TRY=97

1628 TYPEOF=98

1629 UINT=99

1630 ULONG=100

1631 UNCHECKED=101

1632 UNMANAGED=102

1633 UNSAFE=103

1634 USHORT=104

1635 USING=105

1636 VAR=106

1637 VIRTUAL=107

1638 VOID=108

1639 VOLATILE=109

1640 WHEN=110

1641 WHERE=111

1642 WHILE=112

1643 YIELD=113

1644 IDENTIFIER=114

1645 LITERAL_ACCESS=115

1646 INTEGER_LITERAL=116

1647 HEX_INTEGER_LITERAL=117

1648 BIN_INTEGER_LITERAL=118

1649 REAL_LITERAL=119

1650 CHARACTER_LITERAL=120

1651 REGULAR_STRING=121

1652 VERBATIUM_STRING=122

1653 INTERPOLATED_REGULAR_STRING_START=123

1654 INTERPOLATED_VERBATIUM_STRING_START=124

1655 OPEN_BRACE=125

1656 CLOSE_BRACE=126

1657 OPEN_BRACKET=127

1658 CLOSE_BRACKET=128

1659 OPEN_PARENS=129

1660 CLOSE_PARENS=130

1661 DOT=131

1662 COMMA=132

1663 COLON=133

1664 SEMICOLON=134

1665 PLUS=135

1666 MINUS=136

1667 STAR=137

1668 DIV=138

1669 PERCENT=139

1670 AMP=140

1671 BITWISE_OR=141

1672 CARET=142

1673 BANG=143

1674 TILDE=144

1675 ASSIGNMENT=145

1676 LT=146

1677 GT=147

1678 INTERR=148

1679 DOUBLE_COLON=149

1680 OP_COALESCING=150

1681 OP_INC=151

1682 OP_DEC=152

1683 OP_AND=153

1684 OP_OR=154

1685 OP_PTR=155

1686 OP_EQ=156

1687 OP_NE=157

1688 OP_LE=158

1689 OP_GE=159

1690 OP_ADD_ASSIGNMENT=160

1691 OP_SUB_ASSIGNMENT=161

1692 OP_MULT_ASSIGNMENT=162

1693 OP_DIV_ASSIGNMENT=163

1694 OP_MOD_ASSIGNMENT=164

1695 OP_AND_ASSIGNMENT=165

1696 OP_OR_ASSIGNMENT=166

1697 OP_XOR_ASSIGNMENT=167

1698 OP_LEFT_SHIFT=168

1699 OP_LEFT_SHIFT_ASSIGNMENT=169

1700 OP_COALESCING_ASSIGNMENT=170

1701 OP_RANGE=171

1702 DOUBLE_CURLY_INSIDE=172

1703 OPEN_BRACE_INSIDE=173

1704 REGULAR_CHAR_INSIDE=174

1705 VERBATIUM_DOUBLE_QUOTE_INSIDE=175

1706 DOUBLE_QUOTE_INSIDE=176

1707 REGULAR_STRING_INSIDE=177

1708 VERBATIUM_INSIDE_STRING=178

1709 CLOSE_BRACE_INSIDE=179

1710 FORMAT_STRING=180

1711 DIRECTIVE_WHITESPACES=181

1712 DIGITS=182

1713 DEFINE=183

1714 UNDEF=184

1715 ELIF=185

1716 ENDIF=186

1717 LINE=187

1718 ERROR=188

1719 WARNING=189

1720 REGION=190

1721 ENDREGION=191

1722 PRAGMA=192

1723 NULLABLE=193

1724 DIRECTIVE_HIDDEN=194

1725 CONDITIONAL_SYMBOL=195

1726 DIRECTIVE_NEW_LINE=196

1727 TEXT=197

1728 DOUBLE_CURLY_CLOSE_INSIDE=198

1729

1730 def __init__(self, input:TokenStream, output:TextIO = sys.stdout):

1731 super().__init__(input, output)

1732 self.checkVersion("4.10.1")

1733 self._interp = ParserATNSimulator(self, self.atn, self.decisionsToDFA, self.sharedContextCache)

1734 self._predicates = None

1739 class Compilation_unitContext(ParserRuleContext):

1740 __slots__ = 'parser'

1741

1742 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

1743 super().__init__(parent, invokingState)

1744 self.parser = parser

1745

1746 def EOF(self):

1747 return self.getToken(CSharpParser.EOF, 0)

1748

1749 def BYTE_ORDER_MARK(self):

1750 return self.getToken(CSharpParser.BYTE_ORDER_MARK, 0)

1751

1752 def extern_alias_directives(self):

1753 return self.getTypedRuleContext(CSharpParser.Extern_alias_directivesContext,0)

1754

1755

1756 def using_directives(self):

1757 return self.getTypedRuleContext(CSharpParser.Using_directivesContext,0)

1758

1759

1760 def global_attribute_section(self, i:int=None):

1761 if i is None:

1762 return self.getTypedRuleContexts(CSharpParser.Global_attribute_sectionContext)

1763 else:

1764 return self.getTypedRuleContext(CSharpParser.Global_attribute_sectionContext,i)

1765

1766

1767 def namespace_member_declarations(self):

1768 return self.getTypedRuleContext(CSharpParser.Namespace_member_declarationsContext,0)

1769

1770

1771 def getRuleIndex(self):

1772 return CSharpParser.RULE_compilation_unit

1773

1774 def enterRule(self, listener:ParseTreeListener):

1775 if hasattr( listener, "enterCompilation_unit" ):

1776 listener.enterCompilation_unit(self)

1777

1778 def exitRule(self, listener:ParseTreeListener):

1779 if hasattr( listener, "exitCompilation_unit" ):

1780 listener.exitCompilation_unit(self)

1785 def compilation_unit(self):

1786

1787 localctx = CSharpParser.Compilation_unitContext(self, self._ctx, self.state)

1788 self.enterRule(localctx, 0, self.RULE_compilation_unit)

1789 self._la = 0 # Token type

1790 try:

1791 self.enterOuterAlt(localctx, 1)

1792 self.state = 437

1793 self._errHandler.sync(self)

1794 _la = self._input.LA(1)

1795 if _la==CSharpParser.BYTE_ORDER_MARK:

1796 self.state = 436

1797 self.match(CSharpParser.BYTE_ORDER_MARK)

1798

1799

1800 self.state = 440

1801 self._errHandler.sync(self)

1802 la_ = self._interp.adaptivePredict(self._input,1,self._ctx)

1803 if la_ == 1:

1804 self.state = 439

1805 self.extern_alias_directives()

1806

1807

1808 self.state = 443

1809 self._errHandler.sync(self)

1810 _la = self._input.LA(1)

1811 if _la==CSharpParser.USING:

1812 self.state = 442

1813 self.using_directives()

1814

1815

1816 self.state = 448

1817 self._errHandler.sync(self)

1818 _alt = self._interp.adaptivePredict(self._input,3,self._ctx)

1819 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

1820 if _alt==1:

1821 self.state = 445

1822 self.global_attribute_section()

1823 self.state = 450

1824 self._errHandler.sync(self)

1825 _alt = self._interp.adaptivePredict(self._input,3,self._ctx)

1826

1827 self.state = 452

1828 self._errHandler.sync(self)

1829 _la = self._input.LA(1)

1831 self.state = 451

1832 self.namespace_member_declarations()

1833

1834

1835 self.state = 454

1836 self.match(CSharpParser.EOF)

1837 except RecognitionException as re:

1838 localctx.exception = re

1839 self._errHandler.reportError(self, re)

1840 self._errHandler.recover(self, re)

1841 finally:

1842 self.exitRule()

1843 return localctx

1844

1845

1846 class Namespace_or_type_nameContext(ParserRuleContext):

1847 __slots__ = 'parser'

1848

1849 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

1850 super().__init__(parent, invokingState)

1851 self.parser = parser

1852

1853 def identifier(self, i:int=None):

1854 if i is None:

1855 return self.getTypedRuleContexts(CSharpParser.IdentifierContext)

1856 else:

1857 return self.getTypedRuleContext(CSharpParser.IdentifierContext,i)

1858

1859

1860 def qualified_alias_member(self):

1861 return self.getTypedRuleContext(CSharpParser.Qualified_alias_memberContext,0)

1862

1863

1864 def DOT(self, i:int=None):

1865 if i is None:

1866 return self.getTokens(CSharpParser.DOT)

1867 else:

1868 return self.getToken(CSharpParser.DOT, i)

1869

1870 def type_argument_list(self, i:int=None):

1871 if i is None:

1872 return self.getTypedRuleContexts(CSharpParser.Type_argument_listContext)

1873 else:

1874 return self.getTypedRuleContext(CSharpParser.Type_argument_listContext,i)

1875

1876

1877 def getRuleIndex(self):

1878 return CSharpParser.RULE_namespace_or_type_name

1879

1880 def enterRule(self, listener:ParseTreeListener):

1881 if hasattr( listener, "enterNamespace_or_type_name" ):

1882 listener.enterNamespace_or_type_name(self)

1883

1884 def exitRule(self, listener:ParseTreeListener):

1885 if hasattr( listener, "exitNamespace_or_type_name" ):

1886 listener.exitNamespace_or_type_name(self)

1891 def namespace_or_type_name(self):

1892

1893 localctx = CSharpParser.Namespace_or_type_nameContext(self, self._ctx, self.state)

1894 self.enterRule(localctx, 2, self.RULE_namespace_or_type_name)

1895 try:

1896 self.enterOuterAlt(localctx, 1)

1897 self.state = 461

1898 self._errHandler.sync(self)

1899 la_ = self._interp.adaptivePredict(self._input,6,self._ctx)

1900 if la_ == 1:

1901 self.state = 456

1902 self.identifier()

1903 self.state = 458

1904 self._errHandler.sync(self)

1905 la_ = self._interp.adaptivePredict(self._input,5,self._ctx)

1906 if la_ == 1:

1907 self.state = 457

1908 self.type_argument_list()

1909

1910

1911 pass

1912

1913 elif la_ == 2:

1914 self.state = 460

1915 self.qualified_alias_member()

1916 pass

1917

1918

1919 self.state = 470

1920 self._errHandler.sync(self)

1921 _alt = self._interp.adaptivePredict(self._input,8,self._ctx)

1922 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

1923 if _alt==1:

1924 self.state = 463

1925 self.match(CSharpParser.DOT)

1926 self.state = 464

1927 self.identifier()

1928 self.state = 466

1929 self._errHandler.sync(self)

1930 la_ = self._interp.adaptivePredict(self._input,7,self._ctx)

1931 if la_ == 1:

1932 self.state = 465

1933 self.type_argument_list()

1934

1935

1936 self.state = 472

1937 self._errHandler.sync(self)

1938 _alt = self._interp.adaptivePredict(self._input,8,self._ctx)

1939

1940 except RecognitionException as re:

1941 localctx.exception = re

1942 self._errHandler.reportError(self, re)

1943 self._errHandler.recover(self, re)

1944 finally:

1945 self.exitRule()

1946 return localctx

1947

1948

1949 class Type_Context(ParserRuleContext):

1950 __slots__ = 'parser'

1951

1952 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

1953 super().__init__(parent, invokingState)

1954 self.parser = parser

1955

1956 def base_type(self):

1957 return self.getTypedRuleContext(CSharpParser.Base_typeContext,0)

1958

1959

1960 def INTERR(self, i:int=None):

1961 if i is None:

1962 return self.getTokens(CSharpParser.INTERR)

1963 else:

1964 return self.getToken(CSharpParser.INTERR, i)

1965

1966 def rank_specifier(self, i:int=None):

1967 if i is None:

1968 return self.getTypedRuleContexts(CSharpParser.Rank_specifierContext)

1969 else:

1970 return self.getTypedRuleContext(CSharpParser.Rank_specifierContext,i)

1971

1972

1973 def STAR(self, i:int=None):

1974 if i is None:

1975 return self.getTokens(CSharpParser.STAR)

1976 else:

1977 return self.getToken(CSharpParser.STAR, i)

1978

1979 def getRuleIndex(self):

1980 return CSharpParser.RULE_type_

1981

1982 def enterRule(self, listener:ParseTreeListener):

1983 if hasattr( listener, "enterType_" ):

1984 listener.enterType_(self)

1985

1986 def exitRule(self, listener:ParseTreeListener):

1987 if hasattr( listener, "exitType_" ):

1988 listener.exitType_(self)

1993 def type_(self):

1994

1995 localctx = CSharpParser.Type_Context(self, self._ctx, self.state)

1996 self.enterRule(localctx, 4, self.RULE_type_)

1997 try:

1998 self.enterOuterAlt(localctx, 1)

1999 self.state = 473

2000 self.base_type()

2001 self.state = 479

2002 self._errHandler.sync(self)

2003 _alt = self._interp.adaptivePredict(self._input,10,self._ctx)

2004 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

2005 if _alt==1:

2006 self.state = 477

2007 self._errHandler.sync(self)

2008 token = self._input.LA(1)

2009 if token in [CSharpParser.INTERR]:

2010 self.state = 474

2011 self.match(CSharpParser.INTERR)

2012 pass

2013 elif token in [CSharpParser.OPEN_BRACKET]:

2014 self.state = 475

2015 self.rank_specifier()

2016 pass

2017 elif token in [CSharpParser.STAR]:

2018 self.state = 476

2019 self.match(CSharpParser.STAR)

2020 pass

2021 else:

2022 raise NoViableAltException(self)

2023

2024 self.state = 481

2025 self._errHandler.sync(self)

2026 _alt = self._interp.adaptivePredict(self._input,10,self._ctx)

2027

2028 except RecognitionException as re:

2029 localctx.exception = re

2030 self._errHandler.reportError(self, re)

2031 self._errHandler.recover(self, re)

2032 finally:

2033 self.exitRule()

2034 return localctx

2035

2036

2037 class Base_typeContext(ParserRuleContext):

2038 __slots__ = 'parser'

2039

2040 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

2041 super().__init__(parent, invokingState)

2042 self.parser = parser

2043

2044 def simple_type(self):

2045 return self.getTypedRuleContext(CSharpParser.Simple_typeContext,0)

2046

2047

2048 def class_type(self):

2049 return self.getTypedRuleContext(CSharpParser.Class_typeContext,0)

2050

2051

2052 def VOID(self):

2053 return self.getToken(CSharpParser.VOID, 0)

2054

2055 def STAR(self):

2056 return self.getToken(CSharpParser.STAR, 0)

2057

2058 def tuple_type(self):

2059 return self.getTypedRuleContext(CSharpParser.Tuple_typeContext,0)

2060

2061

2062 def getRuleIndex(self):

2063 return CSharpParser.RULE_base_type

2064

2065 def enterRule(self, listener:ParseTreeListener):

2066 if hasattr( listener, "enterBase_type" ):

2067 listener.enterBase_type(self)

2068

2069 def exitRule(self, listener:ParseTreeListener):

2070 if hasattr( listener, "exitBase_type" ):

2071 listener.exitBase_type(self)

2076 def base_type(self):

2077

2078 localctx = CSharpParser.Base_typeContext(self, self._ctx, self.state)

2079 self.enterRule(localctx, 6, self.RULE_base_type)

2080 try:

2081 self.state = 487

2082 self._errHandler.sync(self)

2083 token = self._input.LA(1)

2084 if token in [CSharpParser.BOOL, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.DECIMAL, CSharpParser.DOUBLE, CSharpParser.FLOAT, CSharpParser.INT, CSharpParser.LONG, CSharpParser.SBYTE, CSharpParser.SHORT, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.USHORT]:

2085 self.enterOuterAlt(localctx, 1)

2086 self.state = 482

2087 self.simple_type()

2088 pass

2089 elif token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BY, CSharpParser.DESCENDING, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.STRING, CSharpParser.UNMANAGED, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER]:

2090 self.enterOuterAlt(localctx, 2)

2091 self.state = 483

2092 self.class_type()

2093 pass

2094 elif token in [CSharpParser.VOID]:

2095 self.enterOuterAlt(localctx, 3)

2096 self.state = 484

2097 self.match(CSharpParser.VOID)

2098 self.state = 485

2099 self.match(CSharpParser.STAR)

2100 pass

2101 elif token in [CSharpParser.OPEN_PARENS]:

2102 self.enterOuterAlt(localctx, 4)

2103 self.state = 486

2104 self.tuple_type()

2105 pass

2106 else:

2107 raise NoViableAltException(self)

2108

2109 except RecognitionException as re:

2110 localctx.exception = re

2111 self._errHandler.reportError(self, re)

2112 self._errHandler.recover(self, re)

2113 finally:

2114 self.exitRule()

2115 return localctx

2116

2117

2118 class Tuple_typeContext(ParserRuleContext):

2119 __slots__ = 'parser'

2120

2121 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

2122 super().__init__(parent, invokingState)

2123 self.parser = parser

2124

2125 def OPEN_PARENS(self):

2126 return self.getToken(CSharpParser.OPEN_PARENS, 0)

2127

2128 def tuple_element(self, i:int=None):

2129 if i is None:

2130 return self.getTypedRuleContexts(CSharpParser.Tuple_elementContext)

2131 else:

2132 return self.getTypedRuleContext(CSharpParser.Tuple_elementContext,i)

2133

2134

2135 def CLOSE_PARENS(self):

2136 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

2137

2138 def COMMA(self, i:int=None):

2139 if i is None:

2140 return self.getTokens(CSharpParser.COMMA)

2141 else:

2142 return self.getToken(CSharpParser.COMMA, i)

2143

2144 def getRuleIndex(self):

2145 return CSharpParser.RULE_tuple_type

2146

2147 def enterRule(self, listener:ParseTreeListener):

2148 if hasattr( listener, "enterTuple_type" ):

2149 listener.enterTuple_type(self)

2150

2151 def exitRule(self, listener:ParseTreeListener):

2152 if hasattr( listener, "exitTuple_type" ):

2153 listener.exitTuple_type(self)

2158 def tuple_type(self):

2159

2160 localctx = CSharpParser.Tuple_typeContext(self, self._ctx, self.state)

2161 self.enterRule(localctx, 8, self.RULE_tuple_type)

2162 self._la = 0 # Token type

2163 try:

2164 self.enterOuterAlt(localctx, 1)

2165 self.state = 489

2166 self.match(CSharpParser.OPEN_PARENS)

2167 self.state = 490

2168 self.tuple_element()

2169 self.state = 493

2170 self._errHandler.sync(self)

2171 _la = self._input.LA(1)

2172 while True:

2173 self.state = 491

2174 self.match(CSharpParser.COMMA)

2175 self.state = 492

2176 self.tuple_element()

2177 self.state = 495

2178 self._errHandler.sync(self)

2179 _la = self._input.LA(1)

2180 if not (_la==CSharpParser.COMMA):

2181 break

2182

2183 self.state = 497

2184 self.match(CSharpParser.CLOSE_PARENS)

2185 except RecognitionException as re:

2186 localctx.exception = re

2187 self._errHandler.reportError(self, re)

2188 self._errHandler.recover(self, re)

2189 finally:

2190 self.exitRule()

2191 return localctx

2192

2193

2194 class Tuple_elementContext(ParserRuleContext):

2195 __slots__ = 'parser'

2196

2197 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

2198 super().__init__(parent, invokingState)

2199 self.parser = parser

2200

2201 def type_(self):

2202 return self.getTypedRuleContext(CSharpParser.Type_Context,0)

2203

2204

2205 def identifier(self):

2206 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

2207

2208

2209 def getRuleIndex(self):

2210 return CSharpParser.RULE_tuple_element

2211

2212 def enterRule(self, listener:ParseTreeListener):

2213 if hasattr( listener, "enterTuple_element" ):

2214 listener.enterTuple_element(self)

2215

2216 def exitRule(self, listener:ParseTreeListener):

2217 if hasattr( listener, "exitTuple_element" ):

2218 listener.exitTuple_element(self)

2223 def tuple_element(self):

2224

2225 localctx = CSharpParser.Tuple_elementContext(self, self._ctx, self.state)

2226 self.enterRule(localctx, 10, self.RULE_tuple_element)

2227 self._la = 0 # Token type

2228 try:

2229 self.enterOuterAlt(localctx, 1)

2230 self.state = 499

2231 self.type_()

2232 self.state = 501

2233 self._errHandler.sync(self)

2234 _la = self._input.LA(1)

2236 self.state = 500

2237 self.identifier()

2238

2239

2240 except RecognitionException as re:

2241 localctx.exception = re

2242 self._errHandler.reportError(self, re)

2243 self._errHandler.recover(self, re)

2244 finally:

2245 self.exitRule()

2246 return localctx

2247

2248

2249 class Simple_typeContext(ParserRuleContext):

2250 __slots__ = 'parser'

2251

2252 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

2253 super().__init__(parent, invokingState)

2254 self.parser = parser

2255

2256 def numeric_type(self):

2257 return self.getTypedRuleContext(CSharpParser.Numeric_typeContext,0)

2258

2259

2260 def BOOL(self):

2261 return self.getToken(CSharpParser.BOOL, 0)

2262

2263 def getRuleIndex(self):

2264 return CSharpParser.RULE_simple_type

2265

2266 def enterRule(self, listener:ParseTreeListener):

2267 if hasattr( listener, "enterSimple_type" ):

2268 listener.enterSimple_type(self)

2269

2270 def exitRule(self, listener:ParseTreeListener):

2271 if hasattr( listener, "exitSimple_type" ):

2272 listener.exitSimple_type(self)

2277 def simple_type(self):

2278

2279 localctx = CSharpParser.Simple_typeContext(self, self._ctx, self.state)

2280 self.enterRule(localctx, 12, self.RULE_simple_type)

2281 try:

2282 self.state = 505

2283 self._errHandler.sync(self)

2284 token = self._input.LA(1)

2285 if token in [CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.DECIMAL, CSharpParser.DOUBLE, CSharpParser.FLOAT, CSharpParser.INT, CSharpParser.LONG, CSharpParser.SBYTE, CSharpParser.SHORT, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.USHORT]:

2286 self.enterOuterAlt(localctx, 1)

2287 self.state = 503

2288 self.numeric_type()

2289 pass

2290 elif token in [CSharpParser.BOOL]:

2291 self.enterOuterAlt(localctx, 2)

2292 self.state = 504

2293 self.match(CSharpParser.BOOL)

2294 pass

2295 else:

2296 raise NoViableAltException(self)

2297

2298 except RecognitionException as re:

2299 localctx.exception = re

2300 self._errHandler.reportError(self, re)

2301 self._errHandler.recover(self, re)

2302 finally:

2303 self.exitRule()

2304 return localctx

2305

2306

2307 class Numeric_typeContext(ParserRuleContext):

2308 __slots__ = 'parser'

2309

2310 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

2311 super().__init__(parent, invokingState)

2312 self.parser = parser

2313

2314 def integral_type(self):

2315 return self.getTypedRuleContext(CSharpParser.Integral_typeContext,0)

2316

2317

2318 def floating_point_type(self):

2319 return self.getTypedRuleContext(CSharpParser.Floating_point_typeContext,0)

2320

2321

2322 def DECIMAL(self):

2323 return self.getToken(CSharpParser.DECIMAL, 0)

2324

2325 def getRuleIndex(self):

2326 return CSharpParser.RULE_numeric_type

2327

2328 def enterRule(self, listener:ParseTreeListener):

2329 if hasattr( listener, "enterNumeric_type" ):

2330 listener.enterNumeric_type(self)

2331

2332 def exitRule(self, listener:ParseTreeListener):

2333 if hasattr( listener, "exitNumeric_type" ):

2334 listener.exitNumeric_type(self)

2339 def numeric_type(self):

2340

2341 localctx = CSharpParser.Numeric_typeContext(self, self._ctx, self.state)

2342 self.enterRule(localctx, 14, self.RULE_numeric_type)

2343 try:

2344 self.state = 510

2345 self._errHandler.sync(self)

2346 token = self._input.LA(1)

2347 if token in [CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.INT, CSharpParser.LONG, CSharpParser.SBYTE, CSharpParser.SHORT, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.USHORT]:

2348 self.enterOuterAlt(localctx, 1)

2349 self.state = 507

2350 self.integral_type()

2351 pass

2352 elif token in [CSharpParser.DOUBLE, CSharpParser.FLOAT]:

2353 self.enterOuterAlt(localctx, 2)

2354 self.state = 508

2355 self.floating_point_type()

2356 pass

2357 elif token in [CSharpParser.DECIMAL]:

2358 self.enterOuterAlt(localctx, 3)

2359 self.state = 509

2360 self.match(CSharpParser.DECIMAL)

2361 pass

2362 else:

2363 raise NoViableAltException(self)

2364

2365 except RecognitionException as re:

2366 localctx.exception = re

2367 self._errHandler.reportError(self, re)

2368 self._errHandler.recover(self, re)

2369 finally:

2370 self.exitRule()

2371 return localctx

2372

2373

2374 class Integral_typeContext(ParserRuleContext):

2375 __slots__ = 'parser'

2376

2377 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

2378 super().__init__(parent, invokingState)

2379 self.parser = parser

2380

2381 def SBYTE(self):

2382 return self.getToken(CSharpParser.SBYTE, 0)

2383

2384 def BYTE(self):

2385 return self.getToken(CSharpParser.BYTE, 0)

2386

2387 def SHORT(self):

2388 return self.getToken(CSharpParser.SHORT, 0)

2389

2390 def USHORT(self):

2391 return self.getToken(CSharpParser.USHORT, 0)

2392

2393 def INT(self):

2394 return self.getToken(CSharpParser.INT, 0)

2395

2396 def UINT(self):

2397 return self.getToken(CSharpParser.UINT, 0)

2398

2399 def LONG(self):

2400 return self.getToken(CSharpParser.LONG, 0)

2401

2402 def ULONG(self):

2403 return self.getToken(CSharpParser.ULONG, 0)

2404

2405 def CHAR(self):

2406 return self.getToken(CSharpParser.CHAR, 0)

2407

2408 def getRuleIndex(self):

2409 return CSharpParser.RULE_integral_type

2410

2411 def enterRule(self, listener:ParseTreeListener):

2412 if hasattr( listener, "enterIntegral_type" ):

2413 listener.enterIntegral_type(self)

2414

2415 def exitRule(self, listener:ParseTreeListener):

2416 if hasattr( listener, "exitIntegral_type" ):

2417 listener.exitIntegral_type(self)

2422 def integral_type(self):

2423

2424 localctx = CSharpParser.Integral_typeContext(self, self._ctx, self.state)

2425 self.enterRule(localctx, 16, self.RULE_integral_type)

2426 self._la = 0 # Token type

2427 try:

2428 self.enterOuterAlt(localctx, 1)

2429 self.state = 512

2430 _la = self._input.LA(1)

2431 if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.BYTE) | (1 << CSharpParser.CHAR) | (1 << CSharpParser.INT) | (1 << CSharpParser.LONG))) != 0) or ((((_la - 83)) & ~0x3f) == 0 and ((1 << (_la - 83)) & ((1 << (CSharpParser.SBYTE - 83)) | (1 << (CSharpParser.SHORT - 83)) | (1 << (CSharpParser.UINT - 83)) | (1 << (CSharpParser.ULONG - 83)) | (1 << (CSharpParser.USHORT - 83)))) != 0)):

2432 self._errHandler.recoverInline(self)

2433 else:

2434 self._errHandler.reportMatch(self)

2435 self.consume()

2436 except RecognitionException as re:

2437 localctx.exception = re

2438 self._errHandler.reportError(self, re)

2439 self._errHandler.recover(self, re)

2440 finally:

2441 self.exitRule()

2442 return localctx

2443

2444

2445 class Floating_point_typeContext(ParserRuleContext):

2446 __slots__ = 'parser'

2447

2448 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

2449 super().__init__(parent, invokingState)

2450 self.parser = parser

2451

2452 def FLOAT(self):

2453 return self.getToken(CSharpParser.FLOAT, 0)

2454

2455 def DOUBLE(self):

2456 return self.getToken(CSharpParser.DOUBLE, 0)

2457

2458 def getRuleIndex(self):

2459 return CSharpParser.RULE_floating_point_type

2460

2461 def enterRule(self, listener:ParseTreeListener):

2462 if hasattr( listener, "enterFloating_point_type" ):

2463 listener.enterFloating_point_type(self)

2464

2465 def exitRule(self, listener:ParseTreeListener):

2466 if hasattr( listener, "exitFloating_point_type" ):

2467 listener.exitFloating_point_type(self)

2472 def floating_point_type(self):

2473

2474 localctx = CSharpParser.Floating_point_typeContext(self, self._ctx, self.state)

2475 self.enterRule(localctx, 18, self.RULE_floating_point_type)

2476 self._la = 0 # Token type

2477 try:

2478 self.enterOuterAlt(localctx, 1)

2479 self.state = 514

2480 _la = self._input.LA(1)

2481 if not(_la==CSharpParser.DOUBLE or _la==CSharpParser.FLOAT):

2482 self._errHandler.recoverInline(self)

2483 else:

2484 self._errHandler.reportMatch(self)

2485 self.consume()

2486 except RecognitionException as re:

2487 localctx.exception = re

2488 self._errHandler.reportError(self, re)

2489 self._errHandler.recover(self, re)

2490 finally:

2491 self.exitRule()

2492 return localctx

2493

2494

2495 class Class_typeContext(ParserRuleContext):

2496 __slots__ = 'parser'

2497

2498 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

2499 super().__init__(parent, invokingState)

2500 self.parser = parser

2501

2502 def namespace_or_type_name(self):

2503 return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,0)

2504

2505

2506 def OBJECT(self):

2507 return self.getToken(CSharpParser.OBJECT, 0)

2508

2509 def DYNAMIC(self):

2510 return self.getToken(CSharpParser.DYNAMIC, 0)

2511

2512 def STRING(self):

2513 return self.getToken(CSharpParser.STRING, 0)

2514

2515 def getRuleIndex(self):

2516 return CSharpParser.RULE_class_type

2517

2518 def enterRule(self, listener:ParseTreeListener):

2519 if hasattr( listener, "enterClass_type" ):

2520 listener.enterClass_type(self)

2521

2522 def exitRule(self, listener:ParseTreeListener):

2523 if hasattr( listener, "exitClass_type" ):

2524 listener.exitClass_type(self)

2529 def class_type(self):

2530

2531 localctx = CSharpParser.Class_typeContext(self, self._ctx, self.state)

2532 self.enterRule(localctx, 20, self.RULE_class_type)

2533 try:

2534 self.state = 520

2535 self._errHandler.sync(self)

2536 la_ = self._interp.adaptivePredict(self._input,16,self._ctx)

2537 if la_ == 1:

2538 self.enterOuterAlt(localctx, 1)

2539 self.state = 516

2540 self.namespace_or_type_name()

2541 pass

2542

2543 elif la_ == 2:

2544 self.enterOuterAlt(localctx, 2)

2545 self.state = 517

2546 self.match(CSharpParser.OBJECT)

2547 pass

2548

2549 elif la_ == 3:

2550 self.enterOuterAlt(localctx, 3)

2551 self.state = 518

2552 self.match(CSharpParser.DYNAMIC)

2553 pass

2554

2555 elif la_ == 4:

2556 self.enterOuterAlt(localctx, 4)

2557 self.state = 519

2558 self.match(CSharpParser.STRING)

2559 pass

2560

2561

2562 except RecognitionException as re:

2563 localctx.exception = re

2564 self._errHandler.reportError(self, re)

2565 self._errHandler.recover(self, re)

2566 finally:

2567 self.exitRule()

2568 return localctx

2569

2570

2571 class Type_argument_listContext(ParserRuleContext):

2572 __slots__ = 'parser'

2573

2574 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

2575 super().__init__(parent, invokingState)

2576 self.parser = parser

2577

2578 def LT(self):

2579 return self.getToken(CSharpParser.LT, 0)

2580

2581 def type_(self, i:int=None):

2582 if i is None:

2583 return self.getTypedRuleContexts(CSharpParser.Type_Context)

2584 else:

2585 return self.getTypedRuleContext(CSharpParser.Type_Context,i)

2586

2587

2588 def GT(self):

2589 return self.getToken(CSharpParser.GT, 0)

2590

2591 def COMMA(self, i:int=None):

2592 if i is None:

2593 return self.getTokens(CSharpParser.COMMA)

2594 else:

2595 return self.getToken(CSharpParser.COMMA, i)

2596

2597 def getRuleIndex(self):

2598 return CSharpParser.RULE_type_argument_list

2599

2600 def enterRule(self, listener:ParseTreeListener):

2601 if hasattr( listener, "enterType_argument_list" ):

2602 listener.enterType_argument_list(self)

2603

2604 def exitRule(self, listener:ParseTreeListener):

2605 if hasattr( listener, "exitType_argument_list" ):

2606 listener.exitType_argument_list(self)

2611 def type_argument_list(self):

2612

2613 localctx = CSharpParser.Type_argument_listContext(self, self._ctx, self.state)

2614 self.enterRule(localctx, 22, self.RULE_type_argument_list)

2615 self._la = 0 # Token type

2616 try:

2617 self.enterOuterAlt(localctx, 1)

2618 self.state = 522

2619 self.match(CSharpParser.LT)

2620 self.state = 523

2621 self.type_()

2622 self.state = 528

2623 self._errHandler.sync(self)

2624 _la = self._input.LA(1)

2625 while _la==CSharpParser.COMMA:

2626 self.state = 524

2627 self.match(CSharpParser.COMMA)

2628 self.state = 525

2629 self.type_()

2630 self.state = 530

2631 self._errHandler.sync(self)

2632 _la = self._input.LA(1)

2633

2634 self.state = 531

2635 self.match(CSharpParser.GT)

2636 except RecognitionException as re:

2637 localctx.exception = re

2638 self._errHandler.reportError(self, re)

2639 self._errHandler.recover(self, re)

2640 finally:

2641 self.exitRule()

2642 return localctx

2643

2644

2645 class Argument_listContext(ParserRuleContext):

2646 __slots__ = 'parser'

2647

2648 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

2649 super().__init__(parent, invokingState)

2650 self.parser = parser

2651

2652 def argument(self, i:int=None):

2653 if i is None:

2654 return self.getTypedRuleContexts(CSharpParser.ArgumentContext)

2655 else:

2656 return self.getTypedRuleContext(CSharpParser.ArgumentContext,i)

2657

2658

2659 def COMMA(self, i:int=None):

2660 if i is None:

2661 return self.getTokens(CSharpParser.COMMA)

2662 else:

2663 return self.getToken(CSharpParser.COMMA, i)

2664

2665 def getRuleIndex(self):

2666 return CSharpParser.RULE_argument_list

2667

2668 def enterRule(self, listener:ParseTreeListener):

2669 if hasattr( listener, "enterArgument_list" ):

2670 listener.enterArgument_list(self)

2671

2672 def exitRule(self, listener:ParseTreeListener):

2673 if hasattr( listener, "exitArgument_list" ):

2674 listener.exitArgument_list(self)

2679 def argument_list(self):

2680

2681 localctx = CSharpParser.Argument_listContext(self, self._ctx, self.state)

2682 self.enterRule(localctx, 24, self.RULE_argument_list)

2683 self._la = 0 # Token type

2684 try:

2685 self.enterOuterAlt(localctx, 1)

2686 self.state = 533

2687 self.argument()

2688 self.state = 538

2689 self._errHandler.sync(self)

2690 _la = self._input.LA(1)

2691 while _la==CSharpParser.COMMA:

2692 self.state = 534

2693 self.match(CSharpParser.COMMA)

2694 self.state = 535

2695 self.argument()

2696 self.state = 540

2697 self._errHandler.sync(self)

2698 _la = self._input.LA(1)

2699

2700 except RecognitionException as re:

2701 localctx.exception = re

2702 self._errHandler.reportError(self, re)

2703 self._errHandler.recover(self, re)

2704 finally:

2705 self.exitRule()

2706 return localctx

2707

2708

2709 class ArgumentContext(ParserRuleContext):

2710 __slots__ = 'parser'

2711

2712 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

2713 super().__init__(parent, invokingState)

2714 self.parser = parser

2715 self.refout = None # Token

2716

2717 def expression(self):

2718 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

2719

2720

2721 def identifier(self):

2722 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

2723

2724

2725 def COLON(self):

2726 return self.getToken(CSharpParser.COLON, 0)

2727

2728 def VAR(self):

2729 return self.getToken(CSharpParser.VAR, 0)

2730

2731 def type_(self):

2732 return self.getTypedRuleContext(CSharpParser.Type_Context,0)

2733

2734

2735 def REF(self):

2736 return self.getToken(CSharpParser.REF, 0)

2737

2738 def OUT(self):

2739 return self.getToken(CSharpParser.OUT, 0)

2740

2741 def IN(self):

2742 return self.getToken(CSharpParser.IN, 0)

2743

2744 def getRuleIndex(self):

2745 return CSharpParser.RULE_argument

2746

2747 def enterRule(self, listener:ParseTreeListener):

2748 if hasattr( listener, "enterArgument" ):

2749 listener.enterArgument(self)

2750

2751 def exitRule(self, listener:ParseTreeListener):

2752 if hasattr( listener, "exitArgument" ):

2753 listener.exitArgument(self)

2758 def argument(self):

2759

2760 localctx = CSharpParser.ArgumentContext(self, self._ctx, self.state)

2761 self.enterRule(localctx, 26, self.RULE_argument)

2762 self._la = 0 # Token type

2763 try:

2764 self.enterOuterAlt(localctx, 1)

2765 self.state = 544

2766 self._errHandler.sync(self)

2767 la_ = self._interp.adaptivePredict(self._input,19,self._ctx)

2768 if la_ == 1:

2769 self.state = 541

2770 self.identifier()

2771 self.state = 542

2772 self.match(CSharpParser.COLON)

2773

2774

2775 self.state = 547

2776 self._errHandler.sync(self)

2777 la_ = self._interp.adaptivePredict(self._input,20,self._ctx)

2778 if la_ == 1:

2779 self.state = 546

2780 localctx.refout = self._input.LT(1)

2781 _la = self._input.LA(1)

2782 if not(((((_la - 54)) & ~0x3f) == 0 and ((1 << (_la - 54)) & ((1 << (CSharpParser.IN - 54)) | (1 << (CSharpParser.OUT - 54)) | (1 << (CSharpParser.REF - 54)))) != 0)):

2783 localctx.refout = self._errHandler.recoverInline(self)

2784 else:

2785 self._errHandler.reportMatch(self)

2786 self.consume()

2787

2788

2789 self.state = 551

2790 self._errHandler.sync(self)

2791 la_ = self._interp.adaptivePredict(self._input,21,self._ctx)

2792 if la_ == 1:

2793 self.state = 549

2794 self.match(CSharpParser.VAR)

2795

2796 elif la_ == 2:

2797 self.state = 550

2798 self.type_()

2799

2800

2801 self.state = 553

2802 self.expression()

2803 except RecognitionException as re:

2804 localctx.exception = re

2805 self._errHandler.reportError(self, re)

2806 self._errHandler.recover(self, re)

2807 finally:

2808 self.exitRule()

2809 return localctx

2810

2811

2812 class ExpressionContext(ParserRuleContext):

2813 __slots__ = 'parser'

2814

2815 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

2816 super().__init__(parent, invokingState)

2817 self.parser = parser

2818

2819 def assignment(self):

2820 return self.getTypedRuleContext(CSharpParser.AssignmentContext,0)

2821

2822

2823 def non_assignment_expression(self):

2824 return self.getTypedRuleContext(CSharpParser.Non_assignment_expressionContext,0)

2825

2826

2827 def REF(self):

2828 return self.getToken(CSharpParser.REF, 0)

2829

2830 def getRuleIndex(self):

2831 return CSharpParser.RULE_expression

2832

2833 def enterRule(self, listener:ParseTreeListener):

2834 if hasattr( listener, "enterExpression" ):

2835 listener.enterExpression(self)

2836

2837 def exitRule(self, listener:ParseTreeListener):

2838 if hasattr( listener, "exitExpression" ):

2839 listener.exitExpression(self)

2844 def expression(self):

2845

2846 localctx = CSharpParser.ExpressionContext(self, self._ctx, self.state)

2847 self.enterRule(localctx, 28, self.RULE_expression)

2848 try:

2849 self.state = 559

2850 self._errHandler.sync(self)

2851 la_ = self._interp.adaptivePredict(self._input,22,self._ctx)

2852 if la_ == 1:

2853 self.enterOuterAlt(localctx, 1)

2854 self.state = 555

2855 self.assignment()

2856 pass

2857

2858 elif la_ == 2:

2859 self.enterOuterAlt(localctx, 2)

2860 self.state = 556

2861 self.non_assignment_expression()

2862 pass

2863

2864 elif la_ == 3:

2865 self.enterOuterAlt(localctx, 3)

2866 self.state = 557

2867 self.match(CSharpParser.REF)

2868 self.state = 558

2869 self.non_assignment_expression()

2870 pass

2871

2872

2873 except RecognitionException as re:

2874 localctx.exception = re

2875 self._errHandler.reportError(self, re)

2876 self._errHandler.recover(self, re)

2877 finally:

2878 self.exitRule()

2879 return localctx

2880

2881

2882 class Non_assignment_expressionContext(ParserRuleContext):

2883 __slots__ = 'parser'

2884

2885 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

2886 super().__init__(parent, invokingState)

2887 self.parser = parser

2888

2889 def lambda_expression(self):

2890 return self.getTypedRuleContext(CSharpParser.Lambda_expressionContext,0)

2891

2892

2893 def query_expression(self):

2894 return self.getTypedRuleContext(CSharpParser.Query_expressionContext,0)

2895

2896

2897 def conditional_expression(self):

2898 return self.getTypedRuleContext(CSharpParser.Conditional_expressionContext,0)

2899

2900

2901 def getRuleIndex(self):

2902 return CSharpParser.RULE_non_assignment_expression

2903

2904 def enterRule(self, listener:ParseTreeListener):

2905 if hasattr( listener, "enterNon_assignment_expression" ):

2906 listener.enterNon_assignment_expression(self)

2907

2908 def exitRule(self, listener:ParseTreeListener):

2909 if hasattr( listener, "exitNon_assignment_expression" ):

2910 listener.exitNon_assignment_expression(self)

2915 def non_assignment_expression(self):

2916

2917 localctx = CSharpParser.Non_assignment_expressionContext(self, self._ctx, self.state)

2918 self.enterRule(localctx, 30, self.RULE_non_assignment_expression)

2919 try:

2920 self.state = 564

2921 self._errHandler.sync(self)

2922 la_ = self._interp.adaptivePredict(self._input,23,self._ctx)

2923 if la_ == 1:

2924 self.enterOuterAlt(localctx, 1)

2925 self.state = 561

2926 self.lambda_expression()

2927 pass

2928

2929 elif la_ == 2:

2930 self.enterOuterAlt(localctx, 2)

2931 self.state = 562

2932 self.query_expression()

2933 pass

2934

2935 elif la_ == 3:

2936 self.enterOuterAlt(localctx, 3)

2937 self.state = 563

2938 self.conditional_expression()

2939 pass

2940

2941

2942 except RecognitionException as re:

2943 localctx.exception = re

2944 self._errHandler.reportError(self, re)

2945 self._errHandler.recover(self, re)

2946 finally:

2947 self.exitRule()

2948 return localctx

2949

2950

2951 class AssignmentContext(ParserRuleContext):

2952 __slots__ = 'parser'

2953

2954 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

2955 super().__init__(parent, invokingState)

2956 self.parser = parser

2957

2958 def unary_expression(self):

2959 return self.getTypedRuleContext(CSharpParser.Unary_expressionContext,0)

2960

2961

2962 def assignment_operator(self):

2963 return self.getTypedRuleContext(CSharpParser.Assignment_operatorContext,0)

2964

2965

2966 def expression(self):

2967 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

2968

2969

2970 def OP_COALESCING_ASSIGNMENT(self):

2971 return self.getToken(CSharpParser.OP_COALESCING_ASSIGNMENT, 0)

2972

2973 def throwable_expression(self):

2974 return self.getTypedRuleContext(CSharpParser.Throwable_expressionContext,0)

2975

2976

2977 def getRuleIndex(self):

2978 return CSharpParser.RULE_assignment

2979

2980 def enterRule(self, listener:ParseTreeListener):

2981 if hasattr( listener, "enterAssignment" ):

2982 listener.enterAssignment(self)

2983

2984 def exitRule(self, listener:ParseTreeListener):

2985 if hasattr( listener, "exitAssignment" ):

2986 listener.exitAssignment(self)

2991 def assignment(self):

2992

2993 localctx = CSharpParser.AssignmentContext(self, self._ctx, self.state)

2994 self.enterRule(localctx, 32, self.RULE_assignment)

2995 try:

2996 self.state = 574

2997 self._errHandler.sync(self)

2998 la_ = self._interp.adaptivePredict(self._input,24,self._ctx)

2999 if la_ == 1:

3000 self.enterOuterAlt(localctx, 1)

3001 self.state = 566

3002 self.unary_expression()

3003 self.state = 567

3004 self.assignment_operator()

3005 self.state = 568

3006 self.expression()

3007 pass

3008

3009 elif la_ == 2:

3010 self.enterOuterAlt(localctx, 2)

3011 self.state = 570

3012 self.unary_expression()

3013 self.state = 571

3014 self.match(CSharpParser.OP_COALESCING_ASSIGNMENT)

3015 self.state = 572

3016 self.throwable_expression()

3017 pass

3018

3019

3020 except RecognitionException as re:

3021 localctx.exception = re

3022 self._errHandler.reportError(self, re)

3023 self._errHandler.recover(self, re)

3024 finally:

3025 self.exitRule()

3026 return localctx

3027

3028

3029 class Assignment_operatorContext(ParserRuleContext):

3030 __slots__ = 'parser'

3031

3032 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

3033 super().__init__(parent, invokingState)

3034 self.parser = parser

3035

3036 def ASSIGNMENT(self):

3037 return self.getToken(CSharpParser.ASSIGNMENT, 0)

3038

3039 def OP_ADD_ASSIGNMENT(self):

3040 return self.getToken(CSharpParser.OP_ADD_ASSIGNMENT, 0)

3041

3042 def OP_SUB_ASSIGNMENT(self):

3043 return self.getToken(CSharpParser.OP_SUB_ASSIGNMENT, 0)

3044

3045 def OP_MULT_ASSIGNMENT(self):

3046 return self.getToken(CSharpParser.OP_MULT_ASSIGNMENT, 0)

3047

3048 def OP_DIV_ASSIGNMENT(self):

3049 return self.getToken(CSharpParser.OP_DIV_ASSIGNMENT, 0)

3050

3051 def OP_MOD_ASSIGNMENT(self):

3052 return self.getToken(CSharpParser.OP_MOD_ASSIGNMENT, 0)

3053

3054 def OP_AND_ASSIGNMENT(self):

3055 return self.getToken(CSharpParser.OP_AND_ASSIGNMENT, 0)

3056

3057 def OP_OR_ASSIGNMENT(self):

3058 return self.getToken(CSharpParser.OP_OR_ASSIGNMENT, 0)

3059

3060 def OP_XOR_ASSIGNMENT(self):

3061 return self.getToken(CSharpParser.OP_XOR_ASSIGNMENT, 0)

3062

3063 def OP_LEFT_SHIFT_ASSIGNMENT(self):

3064 return self.getToken(CSharpParser.OP_LEFT_SHIFT_ASSIGNMENT, 0)

3065

3066 def right_shift_assignment(self):

3067 return self.getTypedRuleContext(CSharpParser.Right_shift_assignmentContext,0)

3068

3069

3070 def getRuleIndex(self):

3071 return CSharpParser.RULE_assignment_operator

3072

3073 def enterRule(self, listener:ParseTreeListener):

3074 if hasattr( listener, "enterAssignment_operator" ):

3075 listener.enterAssignment_operator(self)

3076

3077 def exitRule(self, listener:ParseTreeListener):

3078 if hasattr( listener, "exitAssignment_operator" ):

3079 listener.exitAssignment_operator(self)

3084 def assignment_operator(self):

3085

3086 localctx = CSharpParser.Assignment_operatorContext(self, self._ctx, self.state)

3087 self.enterRule(localctx, 34, self.RULE_assignment_operator)

3088 try:

3089 self.state = 587

3090 self._errHandler.sync(self)

3091 token = self._input.LA(1)

3092 if token in [CSharpParser.ASSIGNMENT]:

3093 self.enterOuterAlt(localctx, 1)

3094 self.state = 576

3095 self.match(CSharpParser.ASSIGNMENT)

3096 pass

3097 elif token in [CSharpParser.OP_ADD_ASSIGNMENT]:

3098 self.enterOuterAlt(localctx, 2)

3099 self.state = 577

3100 self.match(CSharpParser.OP_ADD_ASSIGNMENT)

3101 pass

3102 elif token in [CSharpParser.OP_SUB_ASSIGNMENT]:

3103 self.enterOuterAlt(localctx, 3)

3104 self.state = 578

3105 self.match(CSharpParser.OP_SUB_ASSIGNMENT)

3106 pass

3107 elif token in [CSharpParser.OP_MULT_ASSIGNMENT]:

3108 self.enterOuterAlt(localctx, 4)

3109 self.state = 579

3110 self.match(CSharpParser.OP_MULT_ASSIGNMENT)

3111 pass

3112 elif token in [CSharpParser.OP_DIV_ASSIGNMENT]:

3113 self.enterOuterAlt(localctx, 5)

3114 self.state = 580

3115 self.match(CSharpParser.OP_DIV_ASSIGNMENT)

3116 pass

3117 elif token in [CSharpParser.OP_MOD_ASSIGNMENT]:

3118 self.enterOuterAlt(localctx, 6)

3119 self.state = 581

3120 self.match(CSharpParser.OP_MOD_ASSIGNMENT)

3121 pass

3122 elif token in [CSharpParser.OP_AND_ASSIGNMENT]:

3123 self.enterOuterAlt(localctx, 7)

3124 self.state = 582

3125 self.match(CSharpParser.OP_AND_ASSIGNMENT)

3126 pass

3127 elif token in [CSharpParser.OP_OR_ASSIGNMENT]:

3128 self.enterOuterAlt(localctx, 8)

3129 self.state = 583

3130 self.match(CSharpParser.OP_OR_ASSIGNMENT)

3131 pass

3132 elif token in [CSharpParser.OP_XOR_ASSIGNMENT]:

3133 self.enterOuterAlt(localctx, 9)

3134 self.state = 584

3135 self.match(CSharpParser.OP_XOR_ASSIGNMENT)

3136 pass

3137 elif token in [CSharpParser.OP_LEFT_SHIFT_ASSIGNMENT]:

3138 self.enterOuterAlt(localctx, 10)

3139 self.state = 585

3140 self.match(CSharpParser.OP_LEFT_SHIFT_ASSIGNMENT)

3141 pass

3142 elif token in [CSharpParser.GT]:

3143 self.enterOuterAlt(localctx, 11)

3144 self.state = 586

3145 self.right_shift_assignment()

3146 pass

3147 else:

3148 raise NoViableAltException(self)

3149

3150 except RecognitionException as re:

3151 localctx.exception = re

3152 self._errHandler.reportError(self, re)

3153 self._errHandler.recover(self, re)

3154 finally:

3155 self.exitRule()

3156 return localctx

3157

3158

3159 class Conditional_expressionContext(ParserRuleContext):

3160 __slots__ = 'parser'

3161

3162 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

3163 super().__init__(parent, invokingState)

3164 self.parser = parser

3165

3166 def null_coalescing_expression(self):

3167 return self.getTypedRuleContext(CSharpParser.Null_coalescing_expressionContext,0)

3168

3169

3170 def INTERR(self):

3171 return self.getToken(CSharpParser.INTERR, 0)

3172

3173 def throwable_expression(self, i:int=None):

3174 if i is None:

3175 return self.getTypedRuleContexts(CSharpParser.Throwable_expressionContext)

3176 else:

3177 return self.getTypedRuleContext(CSharpParser.Throwable_expressionContext,i)

3178

3179

3180 def COLON(self):

3181 return self.getToken(CSharpParser.COLON, 0)

3182

3183 def getRuleIndex(self):

3184 return CSharpParser.RULE_conditional_expression

3185

3186 def enterRule(self, listener:ParseTreeListener):

3187 if hasattr( listener, "enterConditional_expression" ):

3188 listener.enterConditional_expression(self)

3189

3190 def exitRule(self, listener:ParseTreeListener):

3191 if hasattr( listener, "exitConditional_expression" ):

3192 listener.exitConditional_expression(self)

3197 def conditional_expression(self):

3198

3199 localctx = CSharpParser.Conditional_expressionContext(self, self._ctx, self.state)

3200 self.enterRule(localctx, 36, self.RULE_conditional_expression)

3201 try:

3202 self.enterOuterAlt(localctx, 1)

3203 self.state = 589

3204 self.null_coalescing_expression()

3205 self.state = 595

3206 self._errHandler.sync(self)

3207 la_ = self._interp.adaptivePredict(self._input,26,self._ctx)

3208 if la_ == 1:

3209 self.state = 590

3210 self.match(CSharpParser.INTERR)

3211 self.state = 591

3212 self.throwable_expression()

3213 self.state = 592

3214 self.match(CSharpParser.COLON)

3215 self.state = 593

3216 self.throwable_expression()

3217

3218

3219 except RecognitionException as re:

3220 localctx.exception = re

3221 self._errHandler.reportError(self, re)

3222 self._errHandler.recover(self, re)

3223 finally:

3224 self.exitRule()

3225 return localctx

3226

3227

3228 class Null_coalescing_expressionContext(ParserRuleContext):

3229 __slots__ = 'parser'

3230

3231 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

3232 super().__init__(parent, invokingState)

3233 self.parser = parser

3234

3235 def conditional_or_expression(self):

3236 return self.getTypedRuleContext(CSharpParser.Conditional_or_expressionContext,0)

3237

3238

3239 def OP_COALESCING(self):

3240 return self.getToken(CSharpParser.OP_COALESCING, 0)

3241

3242 def null_coalescing_expression(self):

3243 return self.getTypedRuleContext(CSharpParser.Null_coalescing_expressionContext,0)

3244

3245

3246 def throw_expression(self):

3247 return self.getTypedRuleContext(CSharpParser.Throw_expressionContext,0)

3248

3249

3250 def getRuleIndex(self):

3251 return CSharpParser.RULE_null_coalescing_expression

3252

3253 def enterRule(self, listener:ParseTreeListener):

3254 if hasattr( listener, "enterNull_coalescing_expression" ):

3255 listener.enterNull_coalescing_expression(self)

3256

3257 def exitRule(self, listener:ParseTreeListener):

3258 if hasattr( listener, "exitNull_coalescing_expression" ):

3259 listener.exitNull_coalescing_expression(self)

3264 def null_coalescing_expression(self):

3265

3266 localctx = CSharpParser.Null_coalescing_expressionContext(self, self._ctx, self.state)

3267 self.enterRule(localctx, 38, self.RULE_null_coalescing_expression)

3268 try:

3269 self.enterOuterAlt(localctx, 1)

3270 self.state = 597

3271 self.conditional_or_expression()

3272 self.state = 603

3273 self._errHandler.sync(self)

3274 la_ = self._interp.adaptivePredict(self._input,28,self._ctx)

3275 if la_ == 1:

3276 self.state = 598

3277 self.match(CSharpParser.OP_COALESCING)

3278 self.state = 601

3279 self._errHandler.sync(self)

3280 token = self._input.LA(1)

3281 if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:

3282 self.state = 599

3283 self.null_coalescing_expression()

3284 pass

3285 elif token in [CSharpParser.THROW]:

3286 self.state = 600

3287 self.throw_expression()

3288 pass

3289 else:

3290 raise NoViableAltException(self)

3291

3292

3293

3294 except RecognitionException as re:

3295 localctx.exception = re

3296 self._errHandler.reportError(self, re)

3297 self._errHandler.recover(self, re)

3298 finally:

3299 self.exitRule()

3300 return localctx

3301

3302

3303 class Conditional_or_expressionContext(ParserRuleContext):

3304 __slots__ = 'parser'

3305

3306 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

3307 super().__init__(parent, invokingState)

3308 self.parser = parser

3309

3310 def conditional_and_expression(self, i:int=None):

3311 if i is None:

3312 return self.getTypedRuleContexts(CSharpParser.Conditional_and_expressionContext)

3313 else:

3314 return self.getTypedRuleContext(CSharpParser.Conditional_and_expressionContext,i)

3315

3316

3317 def OP_OR(self, i:int=None):

3318 if i is None:

3319 return self.getTokens(CSharpParser.OP_OR)

3320 else:

3321 return self.getToken(CSharpParser.OP_OR, i)

3322

3323 def getRuleIndex(self):

3324 return CSharpParser.RULE_conditional_or_expression

3325

3326 def enterRule(self, listener:ParseTreeListener):

3327 if hasattr( listener, "enterConditional_or_expression" ):

3328 listener.enterConditional_or_expression(self)

3329

3330 def exitRule(self, listener:ParseTreeListener):

3331 if hasattr( listener, "exitConditional_or_expression" ):

3332 listener.exitConditional_or_expression(self)

3337 def conditional_or_expression(self):

3338

3339 localctx = CSharpParser.Conditional_or_expressionContext(self, self._ctx, self.state)

3340 self.enterRule(localctx, 40, self.RULE_conditional_or_expression)

3341 try:

3342 self.enterOuterAlt(localctx, 1)

3343 self.state = 605

3344 self.conditional_and_expression()

3345 self.state = 610

3346 self._errHandler.sync(self)

3347 _alt = self._interp.adaptivePredict(self._input,29,self._ctx)

3348 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

3349 if _alt==1:

3350 self.state = 606

3351 self.match(CSharpParser.OP_OR)

3352 self.state = 607

3353 self.conditional_and_expression()

3354 self.state = 612

3355 self._errHandler.sync(self)

3356 _alt = self._interp.adaptivePredict(self._input,29,self._ctx)

3357

3358 except RecognitionException as re:

3359 localctx.exception = re

3360 self._errHandler.reportError(self, re)

3361 self._errHandler.recover(self, re)

3362 finally:

3363 self.exitRule()

3364 return localctx

3365

3366

3367 class Conditional_and_expressionContext(ParserRuleContext):

3368 __slots__ = 'parser'

3369

3370 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

3371 super().__init__(parent, invokingState)

3372 self.parser = parser

3373

3374 def inclusive_or_expression(self, i:int=None):

3375 if i is None:

3376 return self.getTypedRuleContexts(CSharpParser.Inclusive_or_expressionContext)

3377 else:

3378 return self.getTypedRuleContext(CSharpParser.Inclusive_or_expressionContext,i)

3379

3380

3381 def OP_AND(self, i:int=None):

3382 if i is None:

3383 return self.getTokens(CSharpParser.OP_AND)

3384 else:

3385 return self.getToken(CSharpParser.OP_AND, i)

3386

3387 def getRuleIndex(self):

3388 return CSharpParser.RULE_conditional_and_expression

3389

3390 def enterRule(self, listener:ParseTreeListener):

3391 if hasattr( listener, "enterConditional_and_expression" ):

3392 listener.enterConditional_and_expression(self)

3393

3394 def exitRule(self, listener:ParseTreeListener):

3395 if hasattr( listener, "exitConditional_and_expression" ):

3396 listener.exitConditional_and_expression(self)

3401 def conditional_and_expression(self):

3402

3403 localctx = CSharpParser.Conditional_and_expressionContext(self, self._ctx, self.state)

3404 self.enterRule(localctx, 42, self.RULE_conditional_and_expression)

3405 try:

3406 self.enterOuterAlt(localctx, 1)

3407 self.state = 613

3408 self.inclusive_or_expression()

3409 self.state = 618

3410 self._errHandler.sync(self)

3411 _alt = self._interp.adaptivePredict(self._input,30,self._ctx)

3412 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

3413 if _alt==1:

3414 self.state = 614

3415 self.match(CSharpParser.OP_AND)

3416 self.state = 615

3417 self.inclusive_or_expression()

3418 self.state = 620

3419 self._errHandler.sync(self)

3420 _alt = self._interp.adaptivePredict(self._input,30,self._ctx)

3421

3422 except RecognitionException as re:

3423 localctx.exception = re

3424 self._errHandler.reportError(self, re)

3425 self._errHandler.recover(self, re)

3426 finally:

3427 self.exitRule()

3428 return localctx

3429

3430

3431 class Inclusive_or_expressionContext(ParserRuleContext):

3432 __slots__ = 'parser'

3433

3434 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

3435 super().__init__(parent, invokingState)

3436 self.parser = parser

3437

3438 def exclusive_or_expression(self, i:int=None):

3439 if i is None:

3440 return self.getTypedRuleContexts(CSharpParser.Exclusive_or_expressionContext)

3441 else:

3442 return self.getTypedRuleContext(CSharpParser.Exclusive_or_expressionContext,i)

3443

3444

3445 def BITWISE_OR(self, i:int=None):

3446 if i is None:

3447 return self.getTokens(CSharpParser.BITWISE_OR)

3448 else:

3449 return self.getToken(CSharpParser.BITWISE_OR, i)

3450

3451 def getRuleIndex(self):

3452 return CSharpParser.RULE_inclusive_or_expression

3453

3454 def enterRule(self, listener:ParseTreeListener):

3455 if hasattr( listener, "enterInclusive_or_expression" ):

3456 listener.enterInclusive_or_expression(self)

3457

3458 def exitRule(self, listener:ParseTreeListener):

3459 if hasattr( listener, "exitInclusive_or_expression" ):

3460 listener.exitInclusive_or_expression(self)

3465 def inclusive_or_expression(self):

3466

3467 localctx = CSharpParser.Inclusive_or_expressionContext(self, self._ctx, self.state)

3468 self.enterRule(localctx, 44, self.RULE_inclusive_or_expression)

3469 try:

3470 self.enterOuterAlt(localctx, 1)

3471 self.state = 621

3472 self.exclusive_or_expression()

3473 self.state = 626

3474 self._errHandler.sync(self)

3475 _alt = self._interp.adaptivePredict(self._input,31,self._ctx)

3476 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

3477 if _alt==1:

3478 self.state = 622

3479 self.match(CSharpParser.BITWISE_OR)

3480 self.state = 623

3481 self.exclusive_or_expression()

3482 self.state = 628

3483 self._errHandler.sync(self)

3484 _alt = self._interp.adaptivePredict(self._input,31,self._ctx)

3485

3486 except RecognitionException as re:

3487 localctx.exception = re

3488 self._errHandler.reportError(self, re)

3489 self._errHandler.recover(self, re)

3490 finally:

3491 self.exitRule()

3492 return localctx

3493

3494

3495 class Exclusive_or_expressionContext(ParserRuleContext):

3496 __slots__ = 'parser'

3497

3498 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

3499 super().__init__(parent, invokingState)

3500 self.parser = parser

3501

3502 def and_expression(self, i:int=None):

3503 if i is None:

3504 return self.getTypedRuleContexts(CSharpParser.And_expressionContext)

3505 else:

3506 return self.getTypedRuleContext(CSharpParser.And_expressionContext,i)

3507

3508

3509 def CARET(self, i:int=None):

3510 if i is None:

3511 return self.getTokens(CSharpParser.CARET)

3512 else:

3513 return self.getToken(CSharpParser.CARET, i)

3514

3515 def getRuleIndex(self):

3516 return CSharpParser.RULE_exclusive_or_expression

3517

3518 def enterRule(self, listener:ParseTreeListener):

3519 if hasattr( listener, "enterExclusive_or_expression" ):

3520 listener.enterExclusive_or_expression(self)

3521

3522 def exitRule(self, listener:ParseTreeListener):

3523 if hasattr( listener, "exitExclusive_or_expression" ):

3524 listener.exitExclusive_or_expression(self)

3529 def exclusive_or_expression(self):

3530

3531 localctx = CSharpParser.Exclusive_or_expressionContext(self, self._ctx, self.state)

3532 self.enterRule(localctx, 46, self.RULE_exclusive_or_expression)

3533 try:

3534 self.enterOuterAlt(localctx, 1)

3535 self.state = 629

3536 self.and_expression()

3537 self.state = 634

3538 self._errHandler.sync(self)

3539 _alt = self._interp.adaptivePredict(self._input,32,self._ctx)

3540 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

3541 if _alt==1:

3542 self.state = 630

3543 self.match(CSharpParser.CARET)

3544 self.state = 631

3545 self.and_expression()

3546 self.state = 636

3547 self._errHandler.sync(self)

3548 _alt = self._interp.adaptivePredict(self._input,32,self._ctx)

3549

3550 except RecognitionException as re:

3551 localctx.exception = re

3552 self._errHandler.reportError(self, re)

3553 self._errHandler.recover(self, re)

3554 finally:

3555 self.exitRule()

3556 return localctx

3557

3558

3559 class And_expressionContext(ParserRuleContext):

3560 __slots__ = 'parser'

3561

3562 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

3563 super().__init__(parent, invokingState)

3564 self.parser = parser

3565

3566 def equality_expression(self, i:int=None):

3567 if i is None:

3568 return self.getTypedRuleContexts(CSharpParser.Equality_expressionContext)

3569 else:

3570 return self.getTypedRuleContext(CSharpParser.Equality_expressionContext,i)

3571

3572

3573 def AMP(self, i:int=None):

3574 if i is None:

3575 return self.getTokens(CSharpParser.AMP)

3576 else:

3577 return self.getToken(CSharpParser.AMP, i)

3578

3579 def getRuleIndex(self):

3580 return CSharpParser.RULE_and_expression

3581

3582 def enterRule(self, listener:ParseTreeListener):

3583 if hasattr( listener, "enterAnd_expression" ):

3584 listener.enterAnd_expression(self)

3585

3586 def exitRule(self, listener:ParseTreeListener):

3587 if hasattr( listener, "exitAnd_expression" ):

3588 listener.exitAnd_expression(self)

3593 def and_expression(self):

3594

3595 localctx = CSharpParser.And_expressionContext(self, self._ctx, self.state)

3596 self.enterRule(localctx, 48, self.RULE_and_expression)

3597 try:

3598 self.enterOuterAlt(localctx, 1)

3599 self.state = 637

3600 self.equality_expression()

3601 self.state = 642

3602 self._errHandler.sync(self)

3603 _alt = self._interp.adaptivePredict(self._input,33,self._ctx)

3604 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

3605 if _alt==1:

3606 self.state = 638

3607 self.match(CSharpParser.AMP)

3608 self.state = 639

3609 self.equality_expression()

3610 self.state = 644

3611 self._errHandler.sync(self)

3612 _alt = self._interp.adaptivePredict(self._input,33,self._ctx)

3613

3614 except RecognitionException as re:

3615 localctx.exception = re

3616 self._errHandler.reportError(self, re)

3617 self._errHandler.recover(self, re)

3618 finally:

3619 self.exitRule()

3620 return localctx

3621

3622

3623 class Equality_expressionContext(ParserRuleContext):

3624 __slots__ = 'parser'

3625

3626 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

3627 super().__init__(parent, invokingState)

3628 self.parser = parser

3629

3630 def relational_expression(self, i:int=None):

3631 if i is None:

3632 return self.getTypedRuleContexts(CSharpParser.Relational_expressionContext)

3633 else:

3634 return self.getTypedRuleContext(CSharpParser.Relational_expressionContext,i)

3635

3636

3637 def OP_EQ(self, i:int=None):

3638 if i is None:

3639 return self.getTokens(CSharpParser.OP_EQ)

3640 else:

3641 return self.getToken(CSharpParser.OP_EQ, i)

3642

3643 def OP_NE(self, i:int=None):

3644 if i is None:

3645 return self.getTokens(CSharpParser.OP_NE)

3646 else:

3647 return self.getToken(CSharpParser.OP_NE, i)

3648

3649 def getRuleIndex(self):

3650 return CSharpParser.RULE_equality_expression

3651

3652 def enterRule(self, listener:ParseTreeListener):

3653 if hasattr( listener, "enterEquality_expression" ):

3654 listener.enterEquality_expression(self)

3655

3656 def exitRule(self, listener:ParseTreeListener):

3657 if hasattr( listener, "exitEquality_expression" ):

3658 listener.exitEquality_expression(self)

3663 def equality_expression(self):

3664

3665 localctx = CSharpParser.Equality_expressionContext(self, self._ctx, self.state)

3666 self.enterRule(localctx, 50, self.RULE_equality_expression)

3667 self._la = 0 # Token type

3668 try:

3669 self.enterOuterAlt(localctx, 1)

3670 self.state = 645

3671 self.relational_expression()

3672 self.state = 650

3673 self._errHandler.sync(self)

3674 _alt = self._interp.adaptivePredict(self._input,34,self._ctx)

3675 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

3676 if _alt==1:

3677 self.state = 646

3678 _la = self._input.LA(1)

3679 if not(_la==CSharpParser.OP_EQ or _la==CSharpParser.OP_NE):

3680 self._errHandler.recoverInline(self)

3681 else:

3682 self._errHandler.reportMatch(self)

3683 self.consume()

3684 self.state = 647

3685 self.relational_expression()

3686 self.state = 652

3687 self._errHandler.sync(self)

3688 _alt = self._interp.adaptivePredict(self._input,34,self._ctx)

3689

3690 except RecognitionException as re:

3691 localctx.exception = re

3692 self._errHandler.reportError(self, re)

3693 self._errHandler.recover(self, re)

3694 finally:

3695 self.exitRule()

3696 return localctx

3697

3698

3699 class Relational_expressionContext(ParserRuleContext):

3700 __slots__ = 'parser'

3701

3702 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

3703 super().__init__(parent, invokingState)

3704 self.parser = parser

3705

3706 def shift_expression(self, i:int=None):

3707 if i is None:

3708 return self.getTypedRuleContexts(CSharpParser.Shift_expressionContext)

3709 else:

3710 return self.getTypedRuleContext(CSharpParser.Shift_expressionContext,i)

3711

3712

3713 def IS(self, i:int=None):

3714 if i is None:

3715 return self.getTokens(CSharpParser.IS)

3716 else:

3717 return self.getToken(CSharpParser.IS, i)

3718

3719 def isType(self, i:int=None):

3720 if i is None:

3721 return self.getTypedRuleContexts(CSharpParser.IsTypeContext)

3722 else:

3723 return self.getTypedRuleContext(CSharpParser.IsTypeContext,i)

3724

3725

3726 def AS(self, i:int=None):

3727 if i is None:

3728 return self.getTokens(CSharpParser.AS)

3729 else:

3730 return self.getToken(CSharpParser.AS, i)

3731

3732 def type_(self, i:int=None):

3733 if i is None:

3734 return self.getTypedRuleContexts(CSharpParser.Type_Context)

3735 else:

3736 return self.getTypedRuleContext(CSharpParser.Type_Context,i)

3737

3738

3739 def LT(self, i:int=None):

3740 if i is None:

3741 return self.getTokens(CSharpParser.LT)

3742 else:

3743 return self.getToken(CSharpParser.LT, i)

3744

3745 def GT(self, i:int=None):

3746 if i is None:

3747 return self.getTokens(CSharpParser.GT)

3748 else:

3749 return self.getToken(CSharpParser.GT, i)

3750

3751 def OP_LE(self, i:int=None):

3752 if i is None:

3753 return self.getTokens(CSharpParser.OP_LE)

3754 else:

3755 return self.getToken(CSharpParser.OP_LE, i)

3756

3757 def OP_GE(self, i:int=None):

3758 if i is None:

3759 return self.getTokens(CSharpParser.OP_GE)

3760 else:

3761 return self.getToken(CSharpParser.OP_GE, i)

3762

3763 def getRuleIndex(self):

3764 return CSharpParser.RULE_relational_expression

3765

3766 def enterRule(self, listener:ParseTreeListener):

3767 if hasattr( listener, "enterRelational_expression" ):

3768 listener.enterRelational_expression(self)

3769

3770 def exitRule(self, listener:ParseTreeListener):

3771 if hasattr( listener, "exitRelational_expression" ):

3772 listener.exitRelational_expression(self)

3777 def relational_expression(self):

3778

3779 localctx = CSharpParser.Relational_expressionContext(self, self._ctx, self.state)

3780 self.enterRule(localctx, 52, self.RULE_relational_expression)

3781 self._la = 0 # Token type

3782 try:

3783 self.enterOuterAlt(localctx, 1)

3784 self.state = 653

3785 self.shift_expression()

3786 self.state = 662

3787 self._errHandler.sync(self)

3788 _alt = self._interp.adaptivePredict(self._input,36,self._ctx)

3789 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

3790 if _alt==1:

3791 self.state = 660

3792 self._errHandler.sync(self)

3793 token = self._input.LA(1)

3794 if token in [CSharpParser.LT, CSharpParser.GT, CSharpParser.OP_LE, CSharpParser.OP_GE]:

3795 self.state = 654

3796 _la = self._input.LA(1)

3797 if not(((((_la - 146)) & ~0x3f) == 0 and ((1 << (_la - 146)) & ((1 << (CSharpParser.LT - 146)) | (1 << (CSharpParser.GT - 146)) | (1 << (CSharpParser.OP_LE - 146)) | (1 << (CSharpParser.OP_GE - 146)))) != 0)):

3798 self._errHandler.recoverInline(self)

3799 else:

3800 self._errHandler.reportMatch(self)

3801 self.consume()

3802 self.state = 655

3803 self.shift_expression()

3804 pass

3805 elif token in [CSharpParser.IS]:

3806 self.state = 656

3807 self.match(CSharpParser.IS)

3808 self.state = 657

3809 self.isType()

3810 pass

3811 elif token in [CSharpParser.AS]:

3812 self.state = 658

3813 self.match(CSharpParser.AS)

3814 self.state = 659

3815 self.type_()

3816 pass

3817 else:

3818 raise NoViableAltException(self)

3819

3820 self.state = 664

3821 self._errHandler.sync(self)

3822 _alt = self._interp.adaptivePredict(self._input,36,self._ctx)

3823

3824 except RecognitionException as re:

3825 localctx.exception = re

3826 self._errHandler.reportError(self, re)

3827 self._errHandler.recover(self, re)

3828 finally:

3829 self.exitRule()

3830 return localctx

3831

3832

3833 class Shift_expressionContext(ParserRuleContext):

3834 __slots__ = 'parser'

3835

3836 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

3837 super().__init__(parent, invokingState)

3838 self.parser = parser

3839

3840 def additive_expression(self, i:int=None):

3841 if i is None:

3842 return self.getTypedRuleContexts(CSharpParser.Additive_expressionContext)

3843 else:

3844 return self.getTypedRuleContext(CSharpParser.Additive_expressionContext,i)

3845

3846

3847 def OP_LEFT_SHIFT(self, i:int=None):

3848 if i is None:

3849 return self.getTokens(CSharpParser.OP_LEFT_SHIFT)

3850 else:

3851 return self.getToken(CSharpParser.OP_LEFT_SHIFT, i)

3852

3853 def right_shift(self, i:int=None):

3854 if i is None:

3855 return self.getTypedRuleContexts(CSharpParser.Right_shiftContext)

3856 else:

3857 return self.getTypedRuleContext(CSharpParser.Right_shiftContext,i)

3858

3859

3860 def getRuleIndex(self):

3861 return CSharpParser.RULE_shift_expression

3862

3863 def enterRule(self, listener:ParseTreeListener):

3864 if hasattr( listener, "enterShift_expression" ):

3865 listener.enterShift_expression(self)

3866

3867 def exitRule(self, listener:ParseTreeListener):

3868 if hasattr( listener, "exitShift_expression" ):

3869 listener.exitShift_expression(self)

3874 def shift_expression(self):

3875

3876 localctx = CSharpParser.Shift_expressionContext(self, self._ctx, self.state)

3877 self.enterRule(localctx, 54, self.RULE_shift_expression)

3878 try:

3879 self.enterOuterAlt(localctx, 1)

3880 self.state = 665

3881 self.additive_expression()

3882 self.state = 673

3883 self._errHandler.sync(self)

3884 _alt = self._interp.adaptivePredict(self._input,38,self._ctx)

3885 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

3886 if _alt==1:

3887 self.state = 668

3888 self._errHandler.sync(self)

3889 token = self._input.LA(1)

3890 if token in [CSharpParser.OP_LEFT_SHIFT]:

3891 self.state = 666

3892 self.match(CSharpParser.OP_LEFT_SHIFT)

3893 pass

3894 elif token in [CSharpParser.GT]:

3895 self.state = 667

3896 self.right_shift()

3897 pass

3898 else:

3899 raise NoViableAltException(self)

3900

3901 self.state = 670

3902 self.additive_expression()

3903 self.state = 675

3904 self._errHandler.sync(self)

3905 _alt = self._interp.adaptivePredict(self._input,38,self._ctx)

3906

3907 except RecognitionException as re:

3908 localctx.exception = re

3909 self._errHandler.reportError(self, re)

3910 self._errHandler.recover(self, re)

3911 finally:

3912 self.exitRule()

3913 return localctx

3914

3915

3916 class Additive_expressionContext(ParserRuleContext):

3917 __slots__ = 'parser'

3918

3919 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

3920 super().__init__(parent, invokingState)

3921 self.parser = parser

3922

3923 def multiplicative_expression(self, i:int=None):

3924 if i is None:

3925 return self.getTypedRuleContexts(CSharpParser.Multiplicative_expressionContext)

3926 else:

3927 return self.getTypedRuleContext(CSharpParser.Multiplicative_expressionContext,i)

3928

3929

3930 def PLUS(self, i:int=None):

3931 if i is None:

3932 return self.getTokens(CSharpParser.PLUS)

3933 else:

3934 return self.getToken(CSharpParser.PLUS, i)

3935

3936 def MINUS(self, i:int=None):

3937 if i is None:

3938 return self.getTokens(CSharpParser.MINUS)

3939 else:

3940 return self.getToken(CSharpParser.MINUS, i)

3941

3942 def getRuleIndex(self):

3943 return CSharpParser.RULE_additive_expression

3944

3945 def enterRule(self, listener:ParseTreeListener):

3946 if hasattr( listener, "enterAdditive_expression" ):

3947 listener.enterAdditive_expression(self)

3948

3949 def exitRule(self, listener:ParseTreeListener):

3950 if hasattr( listener, "exitAdditive_expression" ):

3951 listener.exitAdditive_expression(self)

3956 def additive_expression(self):

3957

3958 localctx = CSharpParser.Additive_expressionContext(self, self._ctx, self.state)

3959 self.enterRule(localctx, 56, self.RULE_additive_expression)

3960 self._la = 0 # Token type

3961 try:

3962 self.enterOuterAlt(localctx, 1)

3963 self.state = 676

3964 self.multiplicative_expression()

3965 self.state = 681

3966 self._errHandler.sync(self)

3967 _alt = self._interp.adaptivePredict(self._input,39,self._ctx)

3968 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

3969 if _alt==1:

3970 self.state = 677

3971 _la = self._input.LA(1)

3972 if not(_la==CSharpParser.PLUS or _la==CSharpParser.MINUS):

3973 self._errHandler.recoverInline(self)

3974 else:

3975 self._errHandler.reportMatch(self)

3976 self.consume()

3977 self.state = 678

3978 self.multiplicative_expression()

3979 self.state = 683

3980 self._errHandler.sync(self)

3981 _alt = self._interp.adaptivePredict(self._input,39,self._ctx)

3982

3983 except RecognitionException as re:

3984 localctx.exception = re

3985 self._errHandler.reportError(self, re)

3986 self._errHandler.recover(self, re)

3987 finally:

3988 self.exitRule()

3989 return localctx

3990

3991

3992 class Multiplicative_expressionContext(ParserRuleContext):

3993 __slots__ = 'parser'

3994

3995 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

3996 super().__init__(parent, invokingState)

3997 self.parser = parser

3998

3999 def switch_expression(self, i:int=None):

4000 if i is None:

4001 return self.getTypedRuleContexts(CSharpParser.Switch_expressionContext)

4002 else:

4003 return self.getTypedRuleContext(CSharpParser.Switch_expressionContext,i)

4004

4005

4006 def STAR(self, i:int=None):

4007 if i is None:

4008 return self.getTokens(CSharpParser.STAR)

4009 else:

4010 return self.getToken(CSharpParser.STAR, i)

4011

4012 def DIV(self, i:int=None):

4013 if i is None:

4014 return self.getTokens(CSharpParser.DIV)

4015 else:

4016 return self.getToken(CSharpParser.DIV, i)

4017

4018 def PERCENT(self, i:int=None):

4019 if i is None:

4020 return self.getTokens(CSharpParser.PERCENT)

4021 else:

4022 return self.getToken(CSharpParser.PERCENT, i)

4023

4024 def getRuleIndex(self):

4025 return CSharpParser.RULE_multiplicative_expression

4026

4027 def enterRule(self, listener:ParseTreeListener):

4028 if hasattr( listener, "enterMultiplicative_expression" ):

4029 listener.enterMultiplicative_expression(self)

4030

4031 def exitRule(self, listener:ParseTreeListener):

4032 if hasattr( listener, "exitMultiplicative_expression" ):

4033 listener.exitMultiplicative_expression(self)

4038 def multiplicative_expression(self):

4039

4040 localctx = CSharpParser.Multiplicative_expressionContext(self, self._ctx, self.state)

4041 self.enterRule(localctx, 58, self.RULE_multiplicative_expression)

4042 self._la = 0 # Token type

4043 try:

4044 self.enterOuterAlt(localctx, 1)

4045 self.state = 684

4046 self.switch_expression()

4047 self.state = 689

4048 self._errHandler.sync(self)

4049 _alt = self._interp.adaptivePredict(self._input,40,self._ctx)

4050 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

4051 if _alt==1:

4052 self.state = 685

4053 _la = self._input.LA(1)

4054 if not(((((_la - 137)) & ~0x3f) == 0 and ((1 << (_la - 137)) & ((1 << (CSharpParser.STAR - 137)) | (1 << (CSharpParser.DIV - 137)) | (1 << (CSharpParser.PERCENT - 137)))) != 0)):

4055 self._errHandler.recoverInline(self)

4056 else:

4057 self._errHandler.reportMatch(self)

4058 self.consume()

4059 self.state = 686

4060 self.switch_expression()

4061 self.state = 691

4062 self._errHandler.sync(self)

4063 _alt = self._interp.adaptivePredict(self._input,40,self._ctx)

4064

4065 except RecognitionException as re:

4066 localctx.exception = re

4067 self._errHandler.reportError(self, re)

4068 self._errHandler.recover(self, re)

4069 finally:

4070 self.exitRule()

4071 return localctx

4072

4073

4074 class Switch_expressionContext(ParserRuleContext):

4075 __slots__ = 'parser'

4076

4077 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

4078 super().__init__(parent, invokingState)

4079 self.parser = parser

4080

4081 def range_expression(self):

4082 return self.getTypedRuleContext(CSharpParser.Range_expressionContext,0)

4083

4084

4085 def SWITCH(self):

4086 return self.getToken(CSharpParser.SWITCH, 0)

4087

4088 def OPEN_BRACE(self):

4089 return self.getToken(CSharpParser.OPEN_BRACE, 0)

4090

4091 def CLOSE_BRACE(self):

4092 return self.getToken(CSharpParser.CLOSE_BRACE, 0)

4093

4094 def switch_expression_arms(self):

4095 return self.getTypedRuleContext(CSharpParser.Switch_expression_armsContext,0)

4096

4097

4098 def COMMA(self):

4099 return self.getToken(CSharpParser.COMMA, 0)

4100

4101 def getRuleIndex(self):

4102 return CSharpParser.RULE_switch_expression

4103

4104 def enterRule(self, listener:ParseTreeListener):

4105 if hasattr( listener, "enterSwitch_expression" ):

4106 listener.enterSwitch_expression(self)

4107

4108 def exitRule(self, listener:ParseTreeListener):

4109 if hasattr( listener, "exitSwitch_expression" ):

4110 listener.exitSwitch_expression(self)

4115 def switch_expression(self):

4116

4117 localctx = CSharpParser.Switch_expressionContext(self, self._ctx, self.state)

4118 self.enterRule(localctx, 60, self.RULE_switch_expression)

4119 self._la = 0 # Token type

4120 try:

4121 self.enterOuterAlt(localctx, 1)

4122 self.state = 692

4123 self.range_expression()

4124 self.state = 702

4125 self._errHandler.sync(self)

4126 la_ = self._interp.adaptivePredict(self._input,43,self._ctx)

4127 if la_ == 1:

4128 self.state = 693

4129 self.match(CSharpParser.SWITCH)

4130 self.state = 694

4131 self.match(CSharpParser.OPEN_BRACE)

4132 self.state = 699

4133 self._errHandler.sync(self)

4134 _la = self._input.LA(1)

4136 self.state = 695

4137 self.switch_expression_arms()

4138 self.state = 697

4139 self._errHandler.sync(self)

4140 _la = self._input.LA(1)

4141 if _la==CSharpParser.COMMA:

4142 self.state = 696

4143 self.match(CSharpParser.COMMA)

4148 self.state = 701

4149 self.match(CSharpParser.CLOSE_BRACE)

4150

4151

4152 except RecognitionException as re:

4153 localctx.exception = re

4154 self._errHandler.reportError(self, re)

4155 self._errHandler.recover(self, re)

4156 finally:

4157 self.exitRule()

4158 return localctx

4159

4160

4161 class Switch_expression_armsContext(ParserRuleContext):

4162 __slots__ = 'parser'

4163

4164 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

4165 super().__init__(parent, invokingState)

4166 self.parser = parser

4167

4168 def switch_expression_arm(self, i:int=None):

4169 if i is None:

4170 return self.getTypedRuleContexts(CSharpParser.Switch_expression_armContext)

4171 else:

4172 return self.getTypedRuleContext(CSharpParser.Switch_expression_armContext,i)

4173

4174

4175 def COMMA(self, i:int=None):

4176 if i is None:

4177 return self.getTokens(CSharpParser.COMMA)

4178 else:

4179 return self.getToken(CSharpParser.COMMA, i)

4180

4181 def getRuleIndex(self):

4182 return CSharpParser.RULE_switch_expression_arms

4183

4184 def enterRule(self, listener:ParseTreeListener):

4185 if hasattr( listener, "enterSwitch_expression_arms" ):

4186 listener.enterSwitch_expression_arms(self)

4187

4188 def exitRule(self, listener:ParseTreeListener):

4189 if hasattr( listener, "exitSwitch_expression_arms" ):

4190 listener.exitSwitch_expression_arms(self)

4195 def switch_expression_arms(self):

4196

4197 localctx = CSharpParser.Switch_expression_armsContext(self, self._ctx, self.state)

4198 self.enterRule(localctx, 62, self.RULE_switch_expression_arms)

4199 try:

4200 self.enterOuterAlt(localctx, 1)

4201 self.state = 704

4202 self.switch_expression_arm()

4203 self.state = 709

4204 self._errHandler.sync(self)

4205 _alt = self._interp.adaptivePredict(self._input,44,self._ctx)

4206 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

4207 if _alt==1:

4208 self.state = 705

4209 self.match(CSharpParser.COMMA)

4210 self.state = 706

4211 self.switch_expression_arm()

4212 self.state = 711

4213 self._errHandler.sync(self)

4214 _alt = self._interp.adaptivePredict(self._input,44,self._ctx)

4215

4216 except RecognitionException as re:

4217 localctx.exception = re

4218 self._errHandler.reportError(self, re)

4219 self._errHandler.recover(self, re)

4220 finally:

4221 self.exitRule()

4222 return localctx

4223

4224

4225 class Switch_expression_armContext(ParserRuleContext):

4226 __slots__ = 'parser'

4227

4228 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

4229 super().__init__(parent, invokingState)

4230 self.parser = parser

4231

4232 def expression(self):

4233 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

4234

4235

4236 def right_arrow(self):

4237 return self.getTypedRuleContext(CSharpParser.Right_arrowContext,0)

4238

4239

4240 def throwable_expression(self):

4241 return self.getTypedRuleContext(CSharpParser.Throwable_expressionContext,0)

4242

4243

4244 def case_guard(self):

4245 return self.getTypedRuleContext(CSharpParser.Case_guardContext,0)

4246

4247

4248 def getRuleIndex(self):

4249 return CSharpParser.RULE_switch_expression_arm

4250

4251 def enterRule(self, listener:ParseTreeListener):

4252 if hasattr( listener, "enterSwitch_expression_arm" ):

4253 listener.enterSwitch_expression_arm(self)

4254

4255 def exitRule(self, listener:ParseTreeListener):

4256 if hasattr( listener, "exitSwitch_expression_arm" ):

4257 listener.exitSwitch_expression_arm(self)

4262 def switch_expression_arm(self):

4263

4264 localctx = CSharpParser.Switch_expression_armContext(self, self._ctx, self.state)

4265 self.enterRule(localctx, 64, self.RULE_switch_expression_arm)

4266 self._la = 0 # Token type

4267 try:

4268 self.enterOuterAlt(localctx, 1)

4269 self.state = 712

4270 self.expression()

4271 self.state = 714

4272 self._errHandler.sync(self)

4273 _la = self._input.LA(1)

4274 if _la==CSharpParser.WHEN:

4275 self.state = 713

4276 self.case_guard()

4277

4278

4279 self.state = 716

4280 self.right_arrow()

4281 self.state = 717

4282 self.throwable_expression()

4283 except RecognitionException as re:

4284 localctx.exception = re

4285 self._errHandler.reportError(self, re)

4286 self._errHandler.recover(self, re)

4287 finally:

4288 self.exitRule()

4289 return localctx

4290

4291

4292 class Range_expressionContext(ParserRuleContext):

4293 __slots__ = 'parser'

4294

4295 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

4296 super().__init__(parent, invokingState)

4297 self.parser = parser

4298

4299 def unary_expression(self, i:int=None):

4300 if i is None:

4301 return self.getTypedRuleContexts(CSharpParser.Unary_expressionContext)

4302 else:

4303 return self.getTypedRuleContext(CSharpParser.Unary_expressionContext,i)

4304

4305

4306 def OP_RANGE(self):

4307 return self.getToken(CSharpParser.OP_RANGE, 0)

4308

4309 def getRuleIndex(self):

4310 return CSharpParser.RULE_range_expression

4311

4312 def enterRule(self, listener:ParseTreeListener):

4313 if hasattr( listener, "enterRange_expression" ):

4314 listener.enterRange_expression(self)

4315

4316 def exitRule(self, listener:ParseTreeListener):

4317 if hasattr( listener, "exitRange_expression" ):

4318 listener.exitRange_expression(self)

4323 def range_expression(self):

4324

4325 localctx = CSharpParser.Range_expressionContext(self, self._ctx, self.state)

4326 self.enterRule(localctx, 66, self.RULE_range_expression)

4327 self._la = 0 # Token type

4328 try:

4329 self.state = 727

4330 self._errHandler.sync(self)

4331 la_ = self._interp.adaptivePredict(self._input,48,self._ctx)

4332 if la_ == 1:

4333 self.enterOuterAlt(localctx, 1)

4334 self.state = 719

4335 self.unary_expression()

4336 pass

4337

4338 elif la_ == 2:

4339 self.enterOuterAlt(localctx, 2)

4340 self.state = 721

4341 self._errHandler.sync(self)

4342 _la = self._input.LA(1)

4344 self.state = 720

4345 self.unary_expression()

4346

4347

4348 self.state = 723

4349 self.match(CSharpParser.OP_RANGE)

4350 self.state = 725

4351 self._errHandler.sync(self)

4352 la_ = self._interp.adaptivePredict(self._input,47,self._ctx)

4353 if la_ == 1:

4354 self.state = 724

4355 self.unary_expression()

4358 pass

4361 except RecognitionException as re:

4362 localctx.exception = re

4363 self._errHandler.reportError(self, re)

4364 self._errHandler.recover(self, re)

4365 finally:

4366 self.exitRule()

4367 return localctx

4368

4369

4370 class Unary_expressionContext(ParserRuleContext):

4371 __slots__ = 'parser'

4372

4373 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

4374 super().__init__(parent, invokingState)

4375 self.parser = parser

4376

4377 def primary_expression(self):

4378 return self.getTypedRuleContext(CSharpParser.Primary_expressionContext,0)

4379

4380

4381 def PLUS(self):

4382 return self.getToken(CSharpParser.PLUS, 0)

4383

4384 def unary_expression(self):

4385 return self.getTypedRuleContext(CSharpParser.Unary_expressionContext,0)

4386

4387

4388 def MINUS(self):

4389 return self.getToken(CSharpParser.MINUS, 0)

4390

4391 def BANG(self):

4392 return self.getToken(CSharpParser.BANG, 0)

4393

4394 def TILDE(self):

4395 return self.getToken(CSharpParser.TILDE, 0)

4396

4397 def OP_INC(self):

4398 return self.getToken(CSharpParser.OP_INC, 0)

4399

4400 def OP_DEC(self):

4401 return self.getToken(CSharpParser.OP_DEC, 0)

4402

4403 def OPEN_PARENS(self):

4404 return self.getToken(CSharpParser.OPEN_PARENS, 0)

4405

4406 def type_(self):

4407 return self.getTypedRuleContext(CSharpParser.Type_Context,0)

4408

4409

4410 def CLOSE_PARENS(self):

4411 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

4412

4413 def AWAIT(self):

4414 return self.getToken(CSharpParser.AWAIT, 0)

4415

4416 def AMP(self):

4417 return self.getToken(CSharpParser.AMP, 0)

4418

4419 def STAR(self):

4420 return self.getToken(CSharpParser.STAR, 0)

4421

4422 def CARET(self):

4423 return self.getToken(CSharpParser.CARET, 0)

4424

4425 def getRuleIndex(self):

4426 return CSharpParser.RULE_unary_expression

4427

4428 def enterRule(self, listener:ParseTreeListener):

4429 if hasattr( listener, "enterUnary_expression" ):

4430 listener.enterUnary_expression(self)

4431

4432 def exitRule(self, listener:ParseTreeListener):

4433 if hasattr( listener, "exitUnary_expression" ):

4434 listener.exitUnary_expression(self)

4439 def unary_expression(self):

4440

4441 localctx = CSharpParser.Unary_expressionContext(self, self._ctx, self.state)

4442 self.enterRule(localctx, 68, self.RULE_unary_expression)

4443 try:

4444 self.state = 755

4445 self._errHandler.sync(self)

4446 la_ = self._interp.adaptivePredict(self._input,49,self._ctx)

4447 if la_ == 1:

4448 self.enterOuterAlt(localctx, 1)

4449 self.state = 729

4450 self.primary_expression()

4451 pass

4452

4453 elif la_ == 2:

4454 self.enterOuterAlt(localctx, 2)

4455 self.state = 730

4456 self.match(CSharpParser.PLUS)

4457 self.state = 731

4458 self.unary_expression()

4459 pass

4460

4461 elif la_ == 3:

4462 self.enterOuterAlt(localctx, 3)

4463 self.state = 732

4464 self.match(CSharpParser.MINUS)

4465 self.state = 733

4466 self.unary_expression()

4467 pass

4468

4469 elif la_ == 4:

4470 self.enterOuterAlt(localctx, 4)

4471 self.state = 734

4472 self.match(CSharpParser.BANG)

4473 self.state = 735

4474 self.unary_expression()

4475 pass

4476

4477 elif la_ == 5:

4478 self.enterOuterAlt(localctx, 5)

4479 self.state = 736

4480 self.match(CSharpParser.TILDE)

4481 self.state = 737

4482 self.unary_expression()

4483 pass

4484

4485 elif la_ == 6:

4486 self.enterOuterAlt(localctx, 6)

4487 self.state = 738

4488 self.match(CSharpParser.OP_INC)

4489 self.state = 739

4490 self.unary_expression()

4491 pass

4492

4493 elif la_ == 7:

4494 self.enterOuterAlt(localctx, 7)

4495 self.state = 740

4496 self.match(CSharpParser.OP_DEC)

4497 self.state = 741

4498 self.unary_expression()

4499 pass

4500

4501 elif la_ == 8:

4502 self.enterOuterAlt(localctx, 8)

4503 self.state = 742

4504 self.match(CSharpParser.OPEN_PARENS)

4505 self.state = 743

4506 self.type_()

4507 self.state = 744

4508 self.match(CSharpParser.CLOSE_PARENS)

4509 self.state = 745

4510 self.unary_expression()

4511 pass

4512

4513 elif la_ == 9:

4514 self.enterOuterAlt(localctx, 9)

4515 self.state = 747

4516 self.match(CSharpParser.AWAIT)

4517 self.state = 748

4518 self.unary_expression()

4519 pass

4520

4521 elif la_ == 10:

4522 self.enterOuterAlt(localctx, 10)

4523 self.state = 749

4524 self.match(CSharpParser.AMP)

4525 self.state = 750

4526 self.unary_expression()

4527 pass

4528

4529 elif la_ == 11:

4530 self.enterOuterAlt(localctx, 11)

4531 self.state = 751

4532 self.match(CSharpParser.STAR)

4533 self.state = 752

4534 self.unary_expression()

4535 pass

4536

4537 elif la_ == 12:

4538 self.enterOuterAlt(localctx, 12)

4539 self.state = 753

4540 self.match(CSharpParser.CARET)

4541 self.state = 754

4542 self.unary_expression()

4543 pass

4544

4545

4546 except RecognitionException as re:

4547 localctx.exception = re

4548 self._errHandler.reportError(self, re)

4549 self._errHandler.recover(self, re)

4550 finally:

4551 self.exitRule()

4552 return localctx

4553

4554

4555 class Primary_expressionContext(ParserRuleContext):

4556 __slots__ = 'parser'

4557

4558 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

4559 super().__init__(parent, invokingState)

4560 self.parser = parser

4561 self.pe = None # Primary_expression_startContext

4562

4563 def primary_expression_start(self):

4564 return self.getTypedRuleContext(CSharpParser.Primary_expression_startContext,0)

4565

4566

4567 def BANG(self, i:int=None):

4568 if i is None:

4569 return self.getTokens(CSharpParser.BANG)

4570 else:

4571 return self.getToken(CSharpParser.BANG, i)

4572

4573 def bracket_expression(self, i:int=None):

4574 if i is None:

4575 return self.getTypedRuleContexts(CSharpParser.Bracket_expressionContext)

4576 else:

4577 return self.getTypedRuleContext(CSharpParser.Bracket_expressionContext,i)

4578

4579

4580 def member_access(self, i:int=None):

4581 if i is None:

4582 return self.getTypedRuleContexts(CSharpParser.Member_accessContext)

4583 else:

4584 return self.getTypedRuleContext(CSharpParser.Member_accessContext,i)

4585

4586

4587 def method_invocation(self, i:int=None):

4588 if i is None:

4589 return self.getTypedRuleContexts(CSharpParser.Method_invocationContext)

4590 else:

4591 return self.getTypedRuleContext(CSharpParser.Method_invocationContext,i)

4592

4593

4594 def OP_INC(self, i:int=None):

4595 if i is None:

4596 return self.getTokens(CSharpParser.OP_INC)

4597 else:

4598 return self.getToken(CSharpParser.OP_INC, i)

4599

4600 def OP_DEC(self, i:int=None):

4601 if i is None:

4602 return self.getTokens(CSharpParser.OP_DEC)

4603 else:

4604 return self.getToken(CSharpParser.OP_DEC, i)

4605

4606 def OP_PTR(self, i:int=None):

4607 if i is None:

4608 return self.getTokens(CSharpParser.OP_PTR)

4609 else:

4610 return self.getToken(CSharpParser.OP_PTR, i)

4611

4612 def identifier(self, i:int=None):

4613 if i is None:

4614 return self.getTypedRuleContexts(CSharpParser.IdentifierContext)

4615 else:

4616 return self.getTypedRuleContext(CSharpParser.IdentifierContext,i)

4617

4618

4619 def getRuleIndex(self):

4620 return CSharpParser.RULE_primary_expression

4621

4622 def enterRule(self, listener:ParseTreeListener):

4623 if hasattr( listener, "enterPrimary_expression" ):

4624 listener.enterPrimary_expression(self)

4625

4626 def exitRule(self, listener:ParseTreeListener):

4627 if hasattr( listener, "exitPrimary_expression" ):

4628 listener.exitPrimary_expression(self)

4633 def primary_expression(self):

4634

4635 localctx = CSharpParser.Primary_expressionContext(self, self._ctx, self.state)

4636 self.enterRule(localctx, 70, self.RULE_primary_expression)

4637 try:

4638 self.enterOuterAlt(localctx, 1)

4639 self.state = 757

4640 localctx.pe = self.primary_expression_start()

4641 self.state = 759

4642 self._errHandler.sync(self)

4643 la_ = self._interp.adaptivePredict(self._input,50,self._ctx)

4644 if la_ == 1:

4645 self.state = 758

4646 self.match(CSharpParser.BANG)

4647

4648

4649 self.state = 764

4650 self._errHandler.sync(self)

4651 _alt = self._interp.adaptivePredict(self._input,51,self._ctx)

4652 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

4653 if _alt==1:

4654 self.state = 761

4655 self.bracket_expression()

4656 self.state = 766

4657 self._errHandler.sync(self)

4658 _alt = self._interp.adaptivePredict(self._input,51,self._ctx)

4659

4660 self.state = 768

4661 self._errHandler.sync(self)

4662 la_ = self._interp.adaptivePredict(self._input,52,self._ctx)

4663 if la_ == 1:

4664 self.state = 767

4665 self.match(CSharpParser.BANG)

4666

4667

4668 self.state = 792

4669 self._errHandler.sync(self)

4670 _alt = self._interp.adaptivePredict(self._input,57,self._ctx)

4671 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

4672 if _alt==1:

4673 self.state = 776

4674 self._errHandler.sync(self)

4675 token = self._input.LA(1)

4676 if token in [CSharpParser.DOT, CSharpParser.INTERR]:

4677 self.state = 770

4678 self.member_access()

4679 pass

4680 elif token in [CSharpParser.OPEN_PARENS]:

4681 self.state = 771

4682 self.method_invocation()

4683 pass

4684 elif token in [CSharpParser.OP_INC]:

4685 self.state = 772

4686 self.match(CSharpParser.OP_INC)

4687 pass

4688 elif token in [CSharpParser.OP_DEC]:

4689 self.state = 773

4690 self.match(CSharpParser.OP_DEC)

4691 pass

4692 elif token in [CSharpParser.OP_PTR]:

4693 self.state = 774

4694 self.match(CSharpParser.OP_PTR)

4695 self.state = 775

4696 self.identifier()

4697 pass

4698 else:

4699 raise NoViableAltException(self)

4700

4701 self.state = 779

4702 self._errHandler.sync(self)

4703 la_ = self._interp.adaptivePredict(self._input,54,self._ctx)

4704 if la_ == 1:

4705 self.state = 778

4706 self.match(CSharpParser.BANG)

4707

4708

4709 self.state = 784

4710 self._errHandler.sync(self)

4711 _alt = self._interp.adaptivePredict(self._input,55,self._ctx)

4712 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

4713 if _alt==1:

4714 self.state = 781

4715 self.bracket_expression()

4716 self.state = 786

4717 self._errHandler.sync(self)

4718 _alt = self._interp.adaptivePredict(self._input,55,self._ctx)

4719

4720 self.state = 788

4721 self._errHandler.sync(self)

4722 la_ = self._interp.adaptivePredict(self._input,56,self._ctx)

4723 if la_ == 1:

4724 self.state = 787

4725 self.match(CSharpParser.BANG)

4726

4727

4728 self.state = 794

4729 self._errHandler.sync(self)

4730 _alt = self._interp.adaptivePredict(self._input,57,self._ctx)

4731

4732 except RecognitionException as re:

4733 localctx.exception = re

4734 self._errHandler.reportError(self, re)

4735 self._errHandler.recover(self, re)

4736 finally:

4737 self.exitRule()

4738 return localctx

4739

4740

4741 class Primary_expression_startContext(ParserRuleContext):

4742 __slots__ = 'parser'

4743

4744 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

4745 super().__init__(parent, invokingState)

4746 self.parser = parser

4747

4748

4749 def getRuleIndex(self):

4750 return CSharpParser.RULE_primary_expression_start

4751

4752

4753 def copyFrom(self, ctx:ParserRuleContext):

4754 super().copyFrom(ctx)

4755

4756

4757

4758 class LiteralAccessExpressionContext(Primary_expression_startContext):

4759

4760 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Primary_expression_startContext

4761 super().__init__(parser)

4762 self.copyFrom(ctx)

4763

4764 def LITERAL_ACCESS(self):

4765 return self.getToken(CSharpParser.LITERAL_ACCESS, 0)

4766

4767 def enterRule(self, listener:ParseTreeListener):

4768 if hasattr( listener, "enterLiteralAccessExpression" ):

4769 listener.enterLiteralAccessExpression(self)

4770

4771 def exitRule(self, listener:ParseTreeListener):

4772 if hasattr( listener, "exitLiteralAccessExpression" ):

4773 listener.exitLiteralAccessExpression(self)

4774

4775

4776 class DefaultValueExpressionContext(Primary_expression_startContext):

4777

4778 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Primary_expression_startContext

4779 super().__init__(parser)

4780 self.copyFrom(ctx)

4781

4782 def DEFAULT(self):

4783 return self.getToken(CSharpParser.DEFAULT, 0)

4784 def OPEN_PARENS(self):

4785 return self.getToken(CSharpParser.OPEN_PARENS, 0)

4786 def type_(self):

4787 return self.getTypedRuleContext(CSharpParser.Type_Context,0)

4788

4789 def CLOSE_PARENS(self):

4790 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

4791

4792 def enterRule(self, listener:ParseTreeListener):

4793 if hasattr( listener, "enterDefaultValueExpression" ):

4794 listener.enterDefaultValueExpression(self)

4795

4796 def exitRule(self, listener:ParseTreeListener):

4797 if hasattr( listener, "exitDefaultValueExpression" ):

4798 listener.exitDefaultValueExpression(self)

4799

4800

4801 class BaseAccessExpressionContext(Primary_expression_startContext):

4802

4803 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Primary_expression_startContext

4804 super().__init__(parser)

4805 self.copyFrom(ctx)

4806

4807 def BASE(self):

4808 return self.getToken(CSharpParser.BASE, 0)

4809 def DOT(self):

4810 return self.getToken(CSharpParser.DOT, 0)

4811 def identifier(self):

4812 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

4813

4814 def OPEN_BRACKET(self):

4815 return self.getToken(CSharpParser.OPEN_BRACKET, 0)

4816 def expression_list(self):

4817 return self.getTypedRuleContext(CSharpParser.Expression_listContext,0)

4818

4819 def CLOSE_BRACKET(self):

4820 return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

4821 def type_argument_list(self):

4822 return self.getTypedRuleContext(CSharpParser.Type_argument_listContext,0)

4823

4824

4825 def enterRule(self, listener:ParseTreeListener):

4826 if hasattr( listener, "enterBaseAccessExpression" ):

4827 listener.enterBaseAccessExpression(self)

4828

4829 def exitRule(self, listener:ParseTreeListener):

4830 if hasattr( listener, "exitBaseAccessExpression" ):

4831 listener.exitBaseAccessExpression(self)

4832

4833

4834 class SizeofExpressionContext(Primary_expression_startContext):

4835

4836 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Primary_expression_startContext

4837 super().__init__(parser)

4838 self.copyFrom(ctx)

4839

4840 def SIZEOF(self):

4841 return self.getToken(CSharpParser.SIZEOF, 0)

4842 def OPEN_PARENS(self):

4843 return self.getToken(CSharpParser.OPEN_PARENS, 0)

4844 def type_(self):

4845 return self.getTypedRuleContext(CSharpParser.Type_Context,0)

4846

4847 def CLOSE_PARENS(self):

4848 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

4849

4850 def enterRule(self, listener:ParseTreeListener):

4851 if hasattr( listener, "enterSizeofExpression" ):

4852 listener.enterSizeofExpression(self)

4853

4854 def exitRule(self, listener:ParseTreeListener):

4855 if hasattr( listener, "exitSizeofExpression" ):

4856 listener.exitSizeofExpression(self)

4857

4858

4859 class ParenthesisExpressionsContext(Primary_expression_startContext):

4860

4861 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Primary_expression_startContext

4862 super().__init__(parser)

4863 self.copyFrom(ctx)

4864

4865 def OPEN_PARENS(self):

4866 return self.getToken(CSharpParser.OPEN_PARENS, 0)

4867 def expression(self):

4868 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

4869

4870 def CLOSE_PARENS(self):

4871 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

4872

4873 def enterRule(self, listener:ParseTreeListener):

4874 if hasattr( listener, "enterParenthesisExpressions" ):

4875 listener.enterParenthesisExpressions(self)

4876

4877 def exitRule(self, listener:ParseTreeListener):

4878 if hasattr( listener, "exitParenthesisExpressions" ):

4879 listener.exitParenthesisExpressions(self)

4880

4881

4882 class ThisReferenceExpressionContext(Primary_expression_startContext):

4883

4884 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Primary_expression_startContext

4885 super().__init__(parser)

4886 self.copyFrom(ctx)

4887

4888 def THIS(self):

4889 return self.getToken(CSharpParser.THIS, 0)

4890

4891 def enterRule(self, listener:ParseTreeListener):

4892 if hasattr( listener, "enterThisReferenceExpression" ):

4893 listener.enterThisReferenceExpression(self)

4894

4895 def exitRule(self, listener:ParseTreeListener):

4896 if hasattr( listener, "exitThisReferenceExpression" ):

4897 listener.exitThisReferenceExpression(self)

4898

4899

4900 class ObjectCreationExpressionContext(Primary_expression_startContext):

4901

4902 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Primary_expression_startContext

4903 super().__init__(parser)

4904 self.copyFrom(ctx)

4905

4906 def NEW(self):

4907 return self.getToken(CSharpParser.NEW, 0)

4908 def type_(self):

4909 return self.getTypedRuleContext(CSharpParser.Type_Context,0)

4910

4911 def anonymous_object_initializer(self):

4912 return self.getTypedRuleContext(CSharpParser.Anonymous_object_initializerContext,0)

4913

4914 def rank_specifier(self, i:int=None):

4915 if i is None:

4916 return self.getTypedRuleContexts(CSharpParser.Rank_specifierContext)

4917 else:

4918 return self.getTypedRuleContext(CSharpParser.Rank_specifierContext,i)

4919

4920 def array_initializer(self):

4921 return self.getTypedRuleContext(CSharpParser.Array_initializerContext,0)

4922

4923 def object_creation_expression(self):

4924 return self.getTypedRuleContext(CSharpParser.Object_creation_expressionContext,0)

4925

4926 def object_or_collection_initializer(self):

4927 return self.getTypedRuleContext(CSharpParser.Object_or_collection_initializerContext,0)

4928

4929 def OPEN_BRACKET(self):

4930 return self.getToken(CSharpParser.OPEN_BRACKET, 0)

4931 def expression_list(self):

4932 return self.getTypedRuleContext(CSharpParser.Expression_listContext,0)

4933

4934 def CLOSE_BRACKET(self):

4935 return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

4936

4937 def enterRule(self, listener:ParseTreeListener):

4938 if hasattr( listener, "enterObjectCreationExpression" ):

4939 listener.enterObjectCreationExpression(self)

4940

4941 def exitRule(self, listener:ParseTreeListener):

4942 if hasattr( listener, "exitObjectCreationExpression" ):

4943 listener.exitObjectCreationExpression(self)

4944

4945

4946 class AnonymousMethodExpressionContext(Primary_expression_startContext):

4947

4948 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Primary_expression_startContext

4949 super().__init__(parser)

4950 self.copyFrom(ctx)

4951

4952 def DELEGATE(self):

4953 return self.getToken(CSharpParser.DELEGATE, 0)

4954 def block(self):

4955 return self.getTypedRuleContext(CSharpParser.BlockContext,0)

4956

4957 def ASYNC(self):

4958 return self.getToken(CSharpParser.ASYNC, 0)

4959 def OPEN_PARENS(self):

4960 return self.getToken(CSharpParser.OPEN_PARENS, 0)

4961 def CLOSE_PARENS(self):

4962 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

4963 def explicit_anonymous_function_parameter_list(self):

4964 return self.getTypedRuleContext(CSharpParser.Explicit_anonymous_function_parameter_listContext,0)

4965

4966

4967 def enterRule(self, listener:ParseTreeListener):

4968 if hasattr( listener, "enterAnonymousMethodExpression" ):

4969 listener.enterAnonymousMethodExpression(self)

4970

4971 def exitRule(self, listener:ParseTreeListener):

4972 if hasattr( listener, "exitAnonymousMethodExpression" ):

4973 listener.exitAnonymousMethodExpression(self)

4974

4975

4976 class TypeofExpressionContext(Primary_expression_startContext):

4977

4978 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Primary_expression_startContext

4979 super().__init__(parser)

4980 self.copyFrom(ctx)

4981

4982 def TYPEOF(self):

4983 return self.getToken(CSharpParser.TYPEOF, 0)

4984 def OPEN_PARENS(self):

4985 return self.getToken(CSharpParser.OPEN_PARENS, 0)

4986 def CLOSE_PARENS(self):

4987 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

4988 def unbound_type_name(self):

4989 return self.getTypedRuleContext(CSharpParser.Unbound_type_nameContext,0)

4990

4991 def type_(self):

4992 return self.getTypedRuleContext(CSharpParser.Type_Context,0)

4993

4994 def VOID(self):

4995 return self.getToken(CSharpParser.VOID, 0)

4996

4997 def enterRule(self, listener:ParseTreeListener):

4998 if hasattr( listener, "enterTypeofExpression" ):

4999 listener.enterTypeofExpression(self)

5000

5001 def exitRule(self, listener:ParseTreeListener):

5002 if hasattr( listener, "exitTypeofExpression" ):

5003 listener.exitTypeofExpression(self)

5004

5005

5006 class TupleExpressionContext(Primary_expression_startContext):

5007

5008 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Primary_expression_startContext

5009 super().__init__(parser)

5010 self.copyFrom(ctx)

5011

5012 def OPEN_PARENS(self):

5013 return self.getToken(CSharpParser.OPEN_PARENS, 0)

5014 def argument(self, i:int=None):

5015 if i is None:

5016 return self.getTypedRuleContexts(CSharpParser.ArgumentContext)

5017 else:

5018 return self.getTypedRuleContext(CSharpParser.ArgumentContext,i)

5019

5020 def CLOSE_PARENS(self):

5021 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

5022 def COMMA(self, i:int=None):

5023 if i is None:

5024 return self.getTokens(CSharpParser.COMMA)

5025 else:

5026 return self.getToken(CSharpParser.COMMA, i)

5027

5028 def enterRule(self, listener:ParseTreeListener):

5029 if hasattr( listener, "enterTupleExpression" ):

5030 listener.enterTupleExpression(self)

5031

5032 def exitRule(self, listener:ParseTreeListener):

5033 if hasattr( listener, "exitTupleExpression" ):

5034 listener.exitTupleExpression(self)

5035

5036

5037 class UncheckedExpressionContext(Primary_expression_startContext):

5038

5039 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Primary_expression_startContext

5040 super().__init__(parser)

5041 self.copyFrom(ctx)

5042

5043 def UNCHECKED(self):

5044 return self.getToken(CSharpParser.UNCHECKED, 0)

5045 def OPEN_PARENS(self):

5046 return self.getToken(CSharpParser.OPEN_PARENS, 0)

5047 def expression(self):

5048 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

5049

5050 def CLOSE_PARENS(self):

5051 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

5052

5053 def enterRule(self, listener:ParseTreeListener):

5054 if hasattr( listener, "enterUncheckedExpression" ):

5055 listener.enterUncheckedExpression(self)

5056

5057 def exitRule(self, listener:ParseTreeListener):

5058 if hasattr( listener, "exitUncheckedExpression" ):

5059 listener.exitUncheckedExpression(self)

5060

5061

5062 class SimpleNameExpressionContext(Primary_expression_startContext):

5063

5064 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Primary_expression_startContext

5065 super().__init__(parser)

5066 self.copyFrom(ctx)

5067

5068 def identifier(self):

5069 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

5070

5071 def type_argument_list(self):

5072 return self.getTypedRuleContext(CSharpParser.Type_argument_listContext,0)

5073

5074

5075 def enterRule(self, listener:ParseTreeListener):

5076 if hasattr( listener, "enterSimpleNameExpression" ):

5077 listener.enterSimpleNameExpression(self)

5078

5079 def exitRule(self, listener:ParseTreeListener):

5080 if hasattr( listener, "exitSimpleNameExpression" ):

5081 listener.exitSimpleNameExpression(self)

5082

5083

5084 class MemberAccessExpressionContext(Primary_expression_startContext):

5085

5086 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Primary_expression_startContext

5087 super().__init__(parser)

5088 self.copyFrom(ctx)

5089

5090 def predefined_type(self):

5091 return self.getTypedRuleContext(CSharpParser.Predefined_typeContext,0)

5092

5093 def qualified_alias_member(self):

5094 return self.getTypedRuleContext(CSharpParser.Qualified_alias_memberContext,0)

5095

5096

5097 def enterRule(self, listener:ParseTreeListener):

5098 if hasattr( listener, "enterMemberAccessExpression" ):

5099 listener.enterMemberAccessExpression(self)

5100

5101 def exitRule(self, listener:ParseTreeListener):

5102 if hasattr( listener, "exitMemberAccessExpression" ):

5103 listener.exitMemberAccessExpression(self)

5104

5105

5106 class CheckedExpressionContext(Primary_expression_startContext):

5107

5108 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Primary_expression_startContext

5109 super().__init__(parser)

5110 self.copyFrom(ctx)

5111

5112 def CHECKED(self):

5113 return self.getToken(CSharpParser.CHECKED, 0)

5114 def OPEN_PARENS(self):

5115 return self.getToken(CSharpParser.OPEN_PARENS, 0)

5116 def expression(self):

5117 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

5118

5119 def CLOSE_PARENS(self):

5120 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

5121

5122 def enterRule(self, listener:ParseTreeListener):

5123 if hasattr( listener, "enterCheckedExpression" ):

5124 listener.enterCheckedExpression(self)

5125

5126 def exitRule(self, listener:ParseTreeListener):

5127 if hasattr( listener, "exitCheckedExpression" ):

5128 listener.exitCheckedExpression(self)

5129

5130

5131 class LiteralExpressionContext(Primary_expression_startContext):

5132

5133 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Primary_expression_startContext

5134 super().__init__(parser)

5135 self.copyFrom(ctx)

5136

5137 def literal(self):

5138 return self.getTypedRuleContext(CSharpParser.LiteralContext,0)

5139

5140

5141 def enterRule(self, listener:ParseTreeListener):

5142 if hasattr( listener, "enterLiteralExpression" ):

5143 listener.enterLiteralExpression(self)

5144

5145 def exitRule(self, listener:ParseTreeListener):

5146 if hasattr( listener, "exitLiteralExpression" ):

5147 listener.exitLiteralExpression(self)

5148

5149

5150 class NameofExpressionContext(Primary_expression_startContext):

5151

5152 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Primary_expression_startContext

5153 super().__init__(parser)

5154 self.copyFrom(ctx)

5155

5156 def NAMEOF(self):

5157 return self.getToken(CSharpParser.NAMEOF, 0)

5158 def OPEN_PARENS(self):

5159 return self.getToken(CSharpParser.OPEN_PARENS, 0)

5160 def identifier(self, i:int=None):

5161 if i is None:

5162 return self.getTypedRuleContexts(CSharpParser.IdentifierContext)

5163 else:

5164 return self.getTypedRuleContext(CSharpParser.IdentifierContext,i)

5165

5166 def CLOSE_PARENS(self):

5167 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

5168 def DOT(self, i:int=None):

5169 if i is None:

5170 return self.getTokens(CSharpParser.DOT)

5171 else:

5172 return self.getToken(CSharpParser.DOT, i)

5173

5174 def enterRule(self, listener:ParseTreeListener):

5175 if hasattr( listener, "enterNameofExpression" ):

5176 listener.enterNameofExpression(self)

5177

5178 def exitRule(self, listener:ParseTreeListener):

5179 if hasattr( listener, "exitNameofExpression" ):

5180 listener.exitNameofExpression(self)

5181

5182

5183

5184 def primary_expression_start(self):

5185

5186 localctx = CSharpParser.Primary_expression_startContext(self, self._ctx, self.state)

5187 self.enterRule(localctx, 72, self.RULE_primary_expression_start)

5188 self._la = 0 # Token type

5189 try:

5190 self.state = 916

5191 self._errHandler.sync(self)

5192 la_ = self._interp.adaptivePredict(self._input,73,self._ctx)

5193 if la_ == 1:

5194 localctx = CSharpParser.LiteralExpressionContext(self, localctx)

5195 self.enterOuterAlt(localctx, 1)

5196 self.state = 795

5197 self.literal()

5198 pass

5199

5200 elif la_ == 2:

5201 localctx = CSharpParser.SimpleNameExpressionContext(self, localctx)

5202 self.enterOuterAlt(localctx, 2)

5203 self.state = 796

5204 self.identifier()

5205 self.state = 798

5206 self._errHandler.sync(self)

5207 la_ = self._interp.adaptivePredict(self._input,58,self._ctx)

5208 if la_ == 1:

5209 self.state = 797

5210 self.type_argument_list()

5211

5212

5213 pass

5214

5215 elif la_ == 3:

5216 localctx = CSharpParser.ParenthesisExpressionsContext(self, localctx)

5217 self.enterOuterAlt(localctx, 3)

5218 self.state = 800

5219 self.match(CSharpParser.OPEN_PARENS)

5220 self.state = 801

5221 self.expression()

5222 self.state = 802

5223 self.match(CSharpParser.CLOSE_PARENS)

5224 pass

5225

5226 elif la_ == 4:

5227 localctx = CSharpParser.MemberAccessExpressionContext(self, localctx)

5228 self.enterOuterAlt(localctx, 4)

5229 self.state = 804

5230 self.predefined_type()

5231 pass

5232

5233 elif la_ == 5:

5234 localctx = CSharpParser.MemberAccessExpressionContext(self, localctx)

5235 self.enterOuterAlt(localctx, 5)

5236 self.state = 805

5237 self.qualified_alias_member()

5238 pass

5239

5240 elif la_ == 6:

5241 localctx = CSharpParser.LiteralAccessExpressionContext(self, localctx)

5242 self.enterOuterAlt(localctx, 6)

5243 self.state = 806

5244 self.match(CSharpParser.LITERAL_ACCESS)

5245 pass

5246

5247 elif la_ == 7:

5248 localctx = CSharpParser.ThisReferenceExpressionContext(self, localctx)

5249 self.enterOuterAlt(localctx, 7)

5250 self.state = 807

5251 self.match(CSharpParser.THIS)

5252 pass

5253

5254 elif la_ == 8:

5255 localctx = CSharpParser.BaseAccessExpressionContext(self, localctx)

5256 self.enterOuterAlt(localctx, 8)

5257 self.state = 808

5258 self.match(CSharpParser.BASE)

5259 self.state = 818

5260 self._errHandler.sync(self)

5261 token = self._input.LA(1)

5262 if token in [CSharpParser.DOT]:

5263 self.state = 809

5264 self.match(CSharpParser.DOT)

5265 self.state = 810

5266 self.identifier()

5267 self.state = 812

5268 self._errHandler.sync(self)

5269 la_ = self._interp.adaptivePredict(self._input,59,self._ctx)

5270 if la_ == 1:

5271 self.state = 811

5272 self.type_argument_list()

5273

5274

5275 pass

5276 elif token in [CSharpParser.OPEN_BRACKET]:

5277 self.state = 814

5278 self.match(CSharpParser.OPEN_BRACKET)

5279 self.state = 815

5280 self.expression_list()

5281 self.state = 816

5282 self.match(CSharpParser.CLOSE_BRACKET)

5283 pass

5284 else:

5285 raise NoViableAltException(self)

5286

5287 pass

5288

5289 elif la_ == 9:

5290 localctx = CSharpParser.ObjectCreationExpressionContext(self, localctx)

5291 self.enterOuterAlt(localctx, 9)

5292 self.state = 820

5293 self.match(CSharpParser.NEW)

5294 self.state = 849

5295 self._errHandler.sync(self)

5296 token = self._input.LA(1)

5297 if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.DECIMAL, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.STRING, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.VOID, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.OPEN_PARENS]:

5298 self.state = 821

5299 self.type_()

5300 self.state = 843

5301 self._errHandler.sync(self)

5302 la_ = self._interp.adaptivePredict(self._input,64,self._ctx)

5303 if la_ == 1:

5304 self.state = 822

5305 self.object_creation_expression()

5306 pass

5307

5308 elif la_ == 2:

5309 self.state = 823

5310 self.object_or_collection_initializer()

5311 pass

5312

5313 elif la_ == 3:

5314 self.state = 824

5315 self.match(CSharpParser.OPEN_BRACKET)

5316 self.state = 825

5317 self.expression_list()

5318 self.state = 826

5319 self.match(CSharpParser.CLOSE_BRACKET)

5320 self.state = 830

5321 self._errHandler.sync(self)

5322 _alt = self._interp.adaptivePredict(self._input,61,self._ctx)

5323 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

5324 if _alt==1:

5325 self.state = 827

5326 self.rank_specifier()

5327 self.state = 832

5328 self._errHandler.sync(self)

5329 _alt = self._interp.adaptivePredict(self._input,61,self._ctx)

5330

5331 self.state = 834

5332 self._errHandler.sync(self)

5333 la_ = self._interp.adaptivePredict(self._input,62,self._ctx)

5334 if la_ == 1:

5335 self.state = 833

5336 self.array_initializer()

5337

5338

5339 pass

5340

5341 elif la_ == 4:

5342 self.state = 837

5343 self._errHandler.sync(self)

5344 _la = self._input.LA(1)

5345 while True:

5346 self.state = 836

5347 self.rank_specifier()

5348 self.state = 839

5349 self._errHandler.sync(self)

5350 _la = self._input.LA(1)

5351 if not (_la==CSharpParser.OPEN_BRACKET):

5352 break

5353

5354 self.state = 841

5355 self.array_initializer()

5356 pass

5357

5358

5359 pass

5360 elif token in [CSharpParser.OPEN_BRACE]:

5361 self.state = 845

5362 self.anonymous_object_initializer()

5363 pass

5364 elif token in [CSharpParser.OPEN_BRACKET]:

5365 self.state = 846

5366 self.rank_specifier()

5367 self.state = 847

5368 self.array_initializer()

5369 pass

5370 else:

5371 raise NoViableAltException(self)

5372

5373 pass

5374

5375 elif la_ == 10:

5376 localctx = CSharpParser.TupleExpressionContext(self, localctx)

5377 self.enterOuterAlt(localctx, 10)

5378 self.state = 851

5379 self.match(CSharpParser.OPEN_PARENS)

5380 self.state = 852

5381 self.argument()

5382 self.state = 855

5383 self._errHandler.sync(self)

5384 _la = self._input.LA(1)

5385 while True:

5386 self.state = 853

5387 self.match(CSharpParser.COMMA)

5388 self.state = 854

5389 self.argument()

5390 self.state = 857

5391 self._errHandler.sync(self)

5392 _la = self._input.LA(1)

5393 if not (_la==CSharpParser.COMMA):

5394 break

5395

5396 self.state = 859

5397 self.match(CSharpParser.CLOSE_PARENS)

5398 pass

5399

5400 elif la_ == 11:

5401 localctx = CSharpParser.TypeofExpressionContext(self, localctx)

5402 self.enterOuterAlt(localctx, 11)

5403 self.state = 861

5404 self.match(CSharpParser.TYPEOF)

5405 self.state = 862

5406 self.match(CSharpParser.OPEN_PARENS)

5407 self.state = 866

5408 self._errHandler.sync(self)

5409 la_ = self._interp.adaptivePredict(self._input,67,self._ctx)

5410 if la_ == 1:

5411 self.state = 863

5412 self.unbound_type_name()

5413 pass

5414

5415 elif la_ == 2:

5416 self.state = 864

5417 self.type_()

5418 pass

5419

5420 elif la_ == 3:

5421 self.state = 865

5422 self.match(CSharpParser.VOID)

5423 pass

5424

5425

5426 self.state = 868

5427 self.match(CSharpParser.CLOSE_PARENS)

5428 pass

5429

5430 elif la_ == 12:

5431 localctx = CSharpParser.CheckedExpressionContext(self, localctx)

5432 self.enterOuterAlt(localctx, 12)

5433 self.state = 869

5434 self.match(CSharpParser.CHECKED)

5435 self.state = 870

5436 self.match(CSharpParser.OPEN_PARENS)

5437 self.state = 871

5438 self.expression()

5439 self.state = 872

5440 self.match(CSharpParser.CLOSE_PARENS)

5441 pass

5442

5443 elif la_ == 13:

5444 localctx = CSharpParser.UncheckedExpressionContext(self, localctx)

5445 self.enterOuterAlt(localctx, 13)

5446 self.state = 874

5447 self.match(CSharpParser.UNCHECKED)

5448 self.state = 875

5449 self.match(CSharpParser.OPEN_PARENS)

5450 self.state = 876

5451 self.expression()

5452 self.state = 877

5453 self.match(CSharpParser.CLOSE_PARENS)

5454 pass

5455

5456 elif la_ == 14:

5457 localctx = CSharpParser.DefaultValueExpressionContext(self, localctx)

5458 self.enterOuterAlt(localctx, 14)

5459 self.state = 879

5460 self.match(CSharpParser.DEFAULT)

5461 self.state = 884

5462 self._errHandler.sync(self)

5463 la_ = self._interp.adaptivePredict(self._input,68,self._ctx)

5464 if la_ == 1:

5465 self.state = 880

5466 self.match(CSharpParser.OPEN_PARENS)

5467 self.state = 881

5468 self.type_()

5469 self.state = 882

5470 self.match(CSharpParser.CLOSE_PARENS)

5471

5472

5473 pass

5474

5475 elif la_ == 15:

5476 localctx = CSharpParser.AnonymousMethodExpressionContext(self, localctx)

5477 self.enterOuterAlt(localctx, 15)

5478 self.state = 887

5479 self._errHandler.sync(self)

5480 _la = self._input.LA(1)

5481 if _la==CSharpParser.ASYNC:

5482 self.state = 886

5483 self.match(CSharpParser.ASYNC)

5484

5485

5486 self.state = 889

5487 self.match(CSharpParser.DELEGATE)

5488 self.state = 895

5489 self._errHandler.sync(self)

5490 _la = self._input.LA(1)

5491 if _la==CSharpParser.OPEN_PARENS:

5492 self.state = 890

5493 self.match(CSharpParser.OPEN_PARENS)

5494 self.state = 892

5495 self._errHandler.sync(self)

5496 _la = self._input.LA(1)

5498 self.state = 891

5499 self.explicit_anonymous_function_parameter_list()

5500

5501

5502 self.state = 894

5503 self.match(CSharpParser.CLOSE_PARENS)

5504

5505

5506 self.state = 897

5507 self.block()

5508 pass

5509

5510 elif la_ == 16:

5511 localctx = CSharpParser.SizeofExpressionContext(self, localctx)

5512 self.enterOuterAlt(localctx, 16)

5513 self.state = 898

5514 self.match(CSharpParser.SIZEOF)

5515 self.state = 899

5516 self.match(CSharpParser.OPEN_PARENS)

5517 self.state = 900

5518 self.type_()

5519 self.state = 901

5520 self.match(CSharpParser.CLOSE_PARENS)

5521 pass

5522

5523 elif la_ == 17:

5524 localctx = CSharpParser.NameofExpressionContext(self, localctx)

5525 self.enterOuterAlt(localctx, 17)

5526 self.state = 903

5527 self.match(CSharpParser.NAMEOF)

5528 self.state = 904

5529 self.match(CSharpParser.OPEN_PARENS)

5530 self.state = 910

5531 self._errHandler.sync(self)

5532 _alt = self._interp.adaptivePredict(self._input,72,self._ctx)

5533 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

5534 if _alt==1:

5535 self.state = 905

5536 self.identifier()

5537 self.state = 906

5538 self.match(CSharpParser.DOT)

5539 self.state = 912

5540 self._errHandler.sync(self)

5541 _alt = self._interp.adaptivePredict(self._input,72,self._ctx)

5542

5543 self.state = 913

5544 self.identifier()

5545 self.state = 914

5546 self.match(CSharpParser.CLOSE_PARENS)

5547 pass

5548

5549

5550 except RecognitionException as re:

5551 localctx.exception = re

5552 self._errHandler.reportError(self, re)

5553 self._errHandler.recover(self, re)

5554 finally:

5555 self.exitRule()

5556 return localctx

5557

5558

5559 class Throwable_expressionContext(ParserRuleContext):

5560 __slots__ = 'parser'

5561

5562 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

5563 super().__init__(parent, invokingState)

5564 self.parser = parser

5565

5566 def expression(self):

5567 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

5568

5569

5570 def throw_expression(self):

5571 return self.getTypedRuleContext(CSharpParser.Throw_expressionContext,0)

5572

5573

5574 def getRuleIndex(self):

5575 return CSharpParser.RULE_throwable_expression

5576

5577 def enterRule(self, listener:ParseTreeListener):

5578 if hasattr( listener, "enterThrowable_expression" ):

5579 listener.enterThrowable_expression(self)

5580

5581 def exitRule(self, listener:ParseTreeListener):

5582 if hasattr( listener, "exitThrowable_expression" ):

5583 listener.exitThrowable_expression(self)

5588 def throwable_expression(self):

5589

5590 localctx = CSharpParser.Throwable_expressionContext(self, self._ctx, self.state)

5591 self.enterRule(localctx, 74, self.RULE_throwable_expression)

5592 try:

5593 self.state = 920

5594 self._errHandler.sync(self)

5595 token = self._input.LA(1)

5596 if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:

5597 self.enterOuterAlt(localctx, 1)

5598 self.state = 918

5599 self.expression()

5600 pass

5601 elif token in [CSharpParser.THROW]:

5602 self.enterOuterAlt(localctx, 2)

5603 self.state = 919

5604 self.throw_expression()

5605 pass

5606 else:

5607 raise NoViableAltException(self)

5608

5609 except RecognitionException as re:

5610 localctx.exception = re

5611 self._errHandler.reportError(self, re)

5612 self._errHandler.recover(self, re)

5613 finally:

5614 self.exitRule()

5615 return localctx

5616

5617

5618 class Throw_expressionContext(ParserRuleContext):

5619 __slots__ = 'parser'

5620

5621 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

5622 super().__init__(parent, invokingState)

5623 self.parser = parser

5624

5625 def THROW(self):

5626 return self.getToken(CSharpParser.THROW, 0)

5627

5628 def expression(self):

5629 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

5630

5631

5632 def getRuleIndex(self):

5633 return CSharpParser.RULE_throw_expression

5634

5635 def enterRule(self, listener:ParseTreeListener):

5636 if hasattr( listener, "enterThrow_expression" ):

5637 listener.enterThrow_expression(self)

5638

5639 def exitRule(self, listener:ParseTreeListener):

5640 if hasattr( listener, "exitThrow_expression" ):

5641 listener.exitThrow_expression(self)

5646 def throw_expression(self):

5647

5648 localctx = CSharpParser.Throw_expressionContext(self, self._ctx, self.state)

5649 self.enterRule(localctx, 76, self.RULE_throw_expression)

5650 try:

5651 self.enterOuterAlt(localctx, 1)

5652 self.state = 922

5653 self.match(CSharpParser.THROW)

5654 self.state = 923

5655 self.expression()

5656 except RecognitionException as re:

5657 localctx.exception = re

5658 self._errHandler.reportError(self, re)

5659 self._errHandler.recover(self, re)

5660 finally:

5661 self.exitRule()

5662 return localctx

5663

5664

5665 class Member_accessContext(ParserRuleContext):

5666 __slots__ = 'parser'

5667

5668 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

5669 super().__init__(parent, invokingState)

5670 self.parser = parser

5671

5672 def DOT(self):

5673 return self.getToken(CSharpParser.DOT, 0)

5674

5675 def identifier(self):

5676 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

5677

5678

5679 def INTERR(self):

5680 return self.getToken(CSharpParser.INTERR, 0)

5681

5682 def type_argument_list(self):

5683 return self.getTypedRuleContext(CSharpParser.Type_argument_listContext,0)

5684

5685

5686 def getRuleIndex(self):

5687 return CSharpParser.RULE_member_access

5688

5689 def enterRule(self, listener:ParseTreeListener):

5690 if hasattr( listener, "enterMember_access" ):

5691 listener.enterMember_access(self)

5692

5693 def exitRule(self, listener:ParseTreeListener):

5694 if hasattr( listener, "exitMember_access" ):

5695 listener.exitMember_access(self)

5700 def member_access(self):

5701

5702 localctx = CSharpParser.Member_accessContext(self, self._ctx, self.state)

5703 self.enterRule(localctx, 78, self.RULE_member_access)

5704 self._la = 0 # Token type

5705 try:

5706 self.enterOuterAlt(localctx, 1)

5707 self.state = 926

5708 self._errHandler.sync(self)

5709 _la = self._input.LA(1)

5710 if _la==CSharpParser.INTERR:

5711 self.state = 925

5712 self.match(CSharpParser.INTERR)

5713

5714

5715 self.state = 928

5716 self.match(CSharpParser.DOT)

5717 self.state = 929

5718 self.identifier()

5719 self.state = 931

5720 self._errHandler.sync(self)

5721 la_ = self._interp.adaptivePredict(self._input,76,self._ctx)

5722 if la_ == 1:

5723 self.state = 930

5724 self.type_argument_list()

5725

5726

5727 except RecognitionException as re:

5728 localctx.exception = re

5729 self._errHandler.reportError(self, re)

5730 self._errHandler.recover(self, re)

5731 finally:

5732 self.exitRule()

5733 return localctx

5734

5735

5736 class Bracket_expressionContext(ParserRuleContext):

5737 __slots__ = 'parser'

5738

5739 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

5740 super().__init__(parent, invokingState)

5741 self.parser = parser

5742

5743 def OPEN_BRACKET(self):

5744 return self.getToken(CSharpParser.OPEN_BRACKET, 0)

5745

5746 def indexer_argument(self, i:int=None):

5747 if i is None:

5748 return self.getTypedRuleContexts(CSharpParser.Indexer_argumentContext)

5749 else:

5750 return self.getTypedRuleContext(CSharpParser.Indexer_argumentContext,i)

5751

5752

5753 def CLOSE_BRACKET(self):

5754 return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

5755

5756 def INTERR(self):

5757 return self.getToken(CSharpParser.INTERR, 0)

5758

5759 def COMMA(self, i:int=None):

5760 if i is None:

5761 return self.getTokens(CSharpParser.COMMA)

5762 else:

5763 return self.getToken(CSharpParser.COMMA, i)

5764

5765 def getRuleIndex(self):

5766 return CSharpParser.RULE_bracket_expression

5767

5768 def enterRule(self, listener:ParseTreeListener):

5769 if hasattr( listener, "enterBracket_expression" ):

5770 listener.enterBracket_expression(self)

5771

5772 def exitRule(self, listener:ParseTreeListener):

5773 if hasattr( listener, "exitBracket_expression" ):

5774 listener.exitBracket_expression(self)

5779 def bracket_expression(self):

5780

5781 localctx = CSharpParser.Bracket_expressionContext(self, self._ctx, self.state)

5782 self.enterRule(localctx, 80, self.RULE_bracket_expression)

5783 self._la = 0 # Token type

5784 try:

5785 self.enterOuterAlt(localctx, 1)

5786 self.state = 934

5787 self._errHandler.sync(self)

5788 _la = self._input.LA(1)

5789 if _la==CSharpParser.INTERR:

5790 self.state = 933

5791 self.match(CSharpParser.INTERR)

5792

5793

5794 self.state = 936

5795 self.match(CSharpParser.OPEN_BRACKET)

5796 self.state = 937

5797 self.indexer_argument()

5798 self.state = 942

5799 self._errHandler.sync(self)

5800 _la = self._input.LA(1)

5801 while _la==CSharpParser.COMMA:

5802 self.state = 938

5803 self.match(CSharpParser.COMMA)

5804 self.state = 939

5805 self.indexer_argument()

5806 self.state = 944

5807 self._errHandler.sync(self)

5808 _la = self._input.LA(1)

5809

5810 self.state = 945

5811 self.match(CSharpParser.CLOSE_BRACKET)

5812 except RecognitionException as re:

5813 localctx.exception = re

5814 self._errHandler.reportError(self, re)

5815 self._errHandler.recover(self, re)

5816 finally:

5817 self.exitRule()

5818 return localctx

5819

5820

5821 class Indexer_argumentContext(ParserRuleContext):

5822 __slots__ = 'parser'

5823

5824 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

5825 super().__init__(parent, invokingState)

5826 self.parser = parser

5827

5828 def expression(self):

5829 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

5830

5831

5832 def identifier(self):

5833 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

5834

5835

5836 def COLON(self):

5837 return self.getToken(CSharpParser.COLON, 0)

5838

5839 def getRuleIndex(self):

5840 return CSharpParser.RULE_indexer_argument

5841

5842 def enterRule(self, listener:ParseTreeListener):

5843 if hasattr( listener, "enterIndexer_argument" ):

5844 listener.enterIndexer_argument(self)

5845

5846 def exitRule(self, listener:ParseTreeListener):

5847 if hasattr( listener, "exitIndexer_argument" ):

5848 listener.exitIndexer_argument(self)

5853 def indexer_argument(self):

5854

5855 localctx = CSharpParser.Indexer_argumentContext(self, self._ctx, self.state)

5856 self.enterRule(localctx, 82, self.RULE_indexer_argument)

5857 try:

5858 self.enterOuterAlt(localctx, 1)

5859 self.state = 950

5860 self._errHandler.sync(self)

5861 la_ = self._interp.adaptivePredict(self._input,79,self._ctx)

5862 if la_ == 1:

5863 self.state = 947

5864 self.identifier()

5865 self.state = 948

5866 self.match(CSharpParser.COLON)

5867

5868

5869 self.state = 952

5870 self.expression()

5871 except RecognitionException as re:

5872 localctx.exception = re

5873 self._errHandler.reportError(self, re)

5874 self._errHandler.recover(self, re)

5875 finally:

5876 self.exitRule()

5877 return localctx

5878

5879

5880 class Predefined_typeContext(ParserRuleContext):

5881 __slots__ = 'parser'

5882

5883 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

5884 super().__init__(parent, invokingState)

5885 self.parser = parser

5886

5887 def BOOL(self):

5888 return self.getToken(CSharpParser.BOOL, 0)

5889

5890 def BYTE(self):

5891 return self.getToken(CSharpParser.BYTE, 0)

5892

5893 def CHAR(self):

5894 return self.getToken(CSharpParser.CHAR, 0)

5895

5896 def DECIMAL(self):

5897 return self.getToken(CSharpParser.DECIMAL, 0)

5898

5899 def DOUBLE(self):

5900 return self.getToken(CSharpParser.DOUBLE, 0)

5901

5902 def FLOAT(self):

5903 return self.getToken(CSharpParser.FLOAT, 0)

5904

5905 def INT(self):

5906 return self.getToken(CSharpParser.INT, 0)

5907

5908 def LONG(self):

5909 return self.getToken(CSharpParser.LONG, 0)

5910

5911 def OBJECT(self):

5912 return self.getToken(CSharpParser.OBJECT, 0)

5913

5914 def SBYTE(self):

5915 return self.getToken(CSharpParser.SBYTE, 0)

5916

5917 def SHORT(self):

5918 return self.getToken(CSharpParser.SHORT, 0)

5919

5920 def STRING(self):

5921 return self.getToken(CSharpParser.STRING, 0)

5922

5923 def UINT(self):

5924 return self.getToken(CSharpParser.UINT, 0)

5925

5926 def ULONG(self):

5927 return self.getToken(CSharpParser.ULONG, 0)

5928

5929 def USHORT(self):

5930 return self.getToken(CSharpParser.USHORT, 0)

5931

5932 def getRuleIndex(self):

5933 return CSharpParser.RULE_predefined_type

5934

5935 def enterRule(self, listener:ParseTreeListener):

5936 if hasattr( listener, "enterPredefined_type" ):

5937 listener.enterPredefined_type(self)

5938

5939 def exitRule(self, listener:ParseTreeListener):

5940 if hasattr( listener, "exitPredefined_type" ):

5941 listener.exitPredefined_type(self)

5946 def predefined_type(self):

5947

5948 localctx = CSharpParser.Predefined_typeContext(self, self._ctx, self.state)

5949 self.enterRule(localctx, 84, self.RULE_predefined_type)

5950 self._la = 0 # Token type

5951 try:

5952 self.enterOuterAlt(localctx, 1)

5953 self.state = 954

5954 _la = self._input.LA(1)

5956 self._errHandler.recoverInline(self)

5957 else:

5958 self._errHandler.reportMatch(self)

5959 self.consume()

5960 except RecognitionException as re:

5961 localctx.exception = re

5962 self._errHandler.reportError(self, re)

5963 self._errHandler.recover(self, re)

5964 finally:

5965 self.exitRule()

5966 return localctx

5967

5968

5969 class Expression_listContext(ParserRuleContext):

5970 __slots__ = 'parser'

5971

5972 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

5973 super().__init__(parent, invokingState)

5974 self.parser = parser

5975

5976 def expression(self, i:int=None):

5977 if i is None:

5978 return self.getTypedRuleContexts(CSharpParser.ExpressionContext)

5979 else:

5980 return self.getTypedRuleContext(CSharpParser.ExpressionContext,i)

5981

5982

5983 def COMMA(self, i:int=None):

5984 if i is None:

5985 return self.getTokens(CSharpParser.COMMA)

5986 else:

5987 return self.getToken(CSharpParser.COMMA, i)

5988

5989 def getRuleIndex(self):

5990 return CSharpParser.RULE_expression_list

5991

5992 def enterRule(self, listener:ParseTreeListener):

5993 if hasattr( listener, "enterExpression_list" ):

5994 listener.enterExpression_list(self)

5995

5996 def exitRule(self, listener:ParseTreeListener):

5997 if hasattr( listener, "exitExpression_list" ):

5998 listener.exitExpression_list(self)

6003 def expression_list(self):

6004

6005 localctx = CSharpParser.Expression_listContext(self, self._ctx, self.state)

6006 self.enterRule(localctx, 86, self.RULE_expression_list)

6007 self._la = 0 # Token type

6008 try:

6009 self.enterOuterAlt(localctx, 1)

6010 self.state = 956

6011 self.expression()

6012 self.state = 961

6013 self._errHandler.sync(self)

6014 _la = self._input.LA(1)

6015 while _la==CSharpParser.COMMA:

6016 self.state = 957

6017 self.match(CSharpParser.COMMA)

6018 self.state = 958

6019 self.expression()

6020 self.state = 963

6021 self._errHandler.sync(self)

6022 _la = self._input.LA(1)

6023

6024 except RecognitionException as re:

6025 localctx.exception = re

6026 self._errHandler.reportError(self, re)

6027 self._errHandler.recover(self, re)

6028 finally:

6029 self.exitRule()

6030 return localctx

6031

6032

6033 class Object_or_collection_initializerContext(ParserRuleContext):

6034 __slots__ = 'parser'

6035

6036 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

6037 super().__init__(parent, invokingState)

6038 self.parser = parser

6039

6040 def object_initializer(self):

6041 return self.getTypedRuleContext(CSharpParser.Object_initializerContext,0)

6042

6043

6044 def collection_initializer(self):

6045 return self.getTypedRuleContext(CSharpParser.Collection_initializerContext,0)

6046

6047

6048 def getRuleIndex(self):

6049 return CSharpParser.RULE_object_or_collection_initializer

6050

6051 def enterRule(self, listener:ParseTreeListener):

6052 if hasattr( listener, "enterObject_or_collection_initializer" ):

6053 listener.enterObject_or_collection_initializer(self)

6054

6055 def exitRule(self, listener:ParseTreeListener):

6056 if hasattr( listener, "exitObject_or_collection_initializer" ):

6057 listener.exitObject_or_collection_initializer(self)

6062 def object_or_collection_initializer(self):

6063

6064 localctx = CSharpParser.Object_or_collection_initializerContext(self, self._ctx, self.state)

6065 self.enterRule(localctx, 88, self.RULE_object_or_collection_initializer)

6066 try:

6067 self.state = 966

6068 self._errHandler.sync(self)

6069 la_ = self._interp.adaptivePredict(self._input,81,self._ctx)

6070 if la_ == 1:

6071 self.enterOuterAlt(localctx, 1)

6072 self.state = 964

6073 self.object_initializer()

6074 pass

6075

6076 elif la_ == 2:

6077 self.enterOuterAlt(localctx, 2)

6078 self.state = 965

6079 self.collection_initializer()

6080 pass

6081

6082

6083 except RecognitionException as re:

6084 localctx.exception = re

6085 self._errHandler.reportError(self, re)

6086 self._errHandler.recover(self, re)

6087 finally:

6088 self.exitRule()

6089 return localctx

6090

6091

6092 class Object_initializerContext(ParserRuleContext):

6093 __slots__ = 'parser'

6094

6095 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

6096 super().__init__(parent, invokingState)

6097 self.parser = parser

6098

6099 def OPEN_BRACE(self):

6100 return self.getToken(CSharpParser.OPEN_BRACE, 0)

6101

6102 def CLOSE_BRACE(self):

6103 return self.getToken(CSharpParser.CLOSE_BRACE, 0)

6104

6105 def member_initializer_list(self):

6106 return self.getTypedRuleContext(CSharpParser.Member_initializer_listContext,0)

6107

6108

6109 def COMMA(self):

6110 return self.getToken(CSharpParser.COMMA, 0)

6111

6112 def getRuleIndex(self):

6113 return CSharpParser.RULE_object_initializer

6114

6115 def enterRule(self, listener:ParseTreeListener):

6116 if hasattr( listener, "enterObject_initializer" ):

6117 listener.enterObject_initializer(self)

6118

6119 def exitRule(self, listener:ParseTreeListener):

6120 if hasattr( listener, "exitObject_initializer" ):

6121 listener.exitObject_initializer(self)

6126 def object_initializer(self):

6127

6128 localctx = CSharpParser.Object_initializerContext(self, self._ctx, self.state)

6129 self.enterRule(localctx, 90, self.RULE_object_initializer)

6130 self._la = 0 # Token type

6131 try:

6132 self.enterOuterAlt(localctx, 1)

6133 self.state = 968

6134 self.match(CSharpParser.OPEN_BRACE)

6135 self.state = 973

6136 self._errHandler.sync(self)

6137 _la = self._input.LA(1)

6139 self.state = 969

6140 self.member_initializer_list()

6141 self.state = 971

6142 self._errHandler.sync(self)

6143 _la = self._input.LA(1)

6144 if _la==CSharpParser.COMMA:

6145 self.state = 970

6146 self.match(CSharpParser.COMMA)

6151 self.state = 975

6152 self.match(CSharpParser.CLOSE_BRACE)

6153 except RecognitionException as re:

6154 localctx.exception = re

6155 self._errHandler.reportError(self, re)

6156 self._errHandler.recover(self, re)

6157 finally:

6158 self.exitRule()

6159 return localctx

6160

6161

6162 class Member_initializer_listContext(ParserRuleContext):

6163 __slots__ = 'parser'

6164

6165 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

6166 super().__init__(parent, invokingState)

6167 self.parser = parser

6168

6169 def member_initializer(self, i:int=None):

6170 if i is None:

6171 return self.getTypedRuleContexts(CSharpParser.Member_initializerContext)

6172 else:

6173 return self.getTypedRuleContext(CSharpParser.Member_initializerContext,i)

6174

6175

6176 def COMMA(self, i:int=None):

6177 if i is None:

6178 return self.getTokens(CSharpParser.COMMA)

6179 else:

6180 return self.getToken(CSharpParser.COMMA, i)

6181

6182 def getRuleIndex(self):

6183 return CSharpParser.RULE_member_initializer_list

6184

6185 def enterRule(self, listener:ParseTreeListener):

6186 if hasattr( listener, "enterMember_initializer_list" ):

6187 listener.enterMember_initializer_list(self)

6188

6189 def exitRule(self, listener:ParseTreeListener):

6190 if hasattr( listener, "exitMember_initializer_list" ):

6191 listener.exitMember_initializer_list(self)

6196 def member_initializer_list(self):

6197

6198 localctx = CSharpParser.Member_initializer_listContext(self, self._ctx, self.state)

6199 self.enterRule(localctx, 92, self.RULE_member_initializer_list)

6200 try:

6201 self.enterOuterAlt(localctx, 1)

6202 self.state = 977

6203 self.member_initializer()

6204 self.state = 982

6205 self._errHandler.sync(self)

6206 _alt = self._interp.adaptivePredict(self._input,84,self._ctx)

6207 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

6208 if _alt==1:

6209 self.state = 978

6210 self.match(CSharpParser.COMMA)

6211 self.state = 979

6212 self.member_initializer()

6213 self.state = 984

6214 self._errHandler.sync(self)

6215 _alt = self._interp.adaptivePredict(self._input,84,self._ctx)

6216

6217 except RecognitionException as re:

6218 localctx.exception = re

6219 self._errHandler.reportError(self, re)

6220 self._errHandler.recover(self, re)

6221 finally:

6222 self.exitRule()

6223 return localctx

6224

6225

6226 class Member_initializerContext(ParserRuleContext):

6227 __slots__ = 'parser'

6228

6229 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

6230 super().__init__(parent, invokingState)

6231 self.parser = parser

6232

6233 def ASSIGNMENT(self):

6234 return self.getToken(CSharpParser.ASSIGNMENT, 0)

6235

6236 def initializer_value(self):

6237 return self.getTypedRuleContext(CSharpParser.Initializer_valueContext,0)

6238

6239

6240 def identifier(self):

6241 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

6242

6243

6244 def OPEN_BRACKET(self):

6245 return self.getToken(CSharpParser.OPEN_BRACKET, 0)

6246

6247 def expression(self):

6248 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

6249

6250

6251 def CLOSE_BRACKET(self):

6252 return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

6253

6254 def getRuleIndex(self):

6255 return CSharpParser.RULE_member_initializer

6256

6257 def enterRule(self, listener:ParseTreeListener):

6258 if hasattr( listener, "enterMember_initializer" ):

6259 listener.enterMember_initializer(self)

6260

6261 def exitRule(self, listener:ParseTreeListener):

6262 if hasattr( listener, "exitMember_initializer" ):

6263 listener.exitMember_initializer(self)

6268 def member_initializer(self):

6269

6270 localctx = CSharpParser.Member_initializerContext(self, self._ctx, self.state)

6271 self.enterRule(localctx, 94, self.RULE_member_initializer)

6272 try:

6273 self.enterOuterAlt(localctx, 1)

6274 self.state = 990

6275 self._errHandler.sync(self)

6276 token = self._input.LA(1)

6277 if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BY, CSharpParser.DESCENDING, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.NAMEOF, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.UNMANAGED, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER]:

6278 self.state = 985

6279 self.identifier()

6280 pass

6281 elif token in [CSharpParser.OPEN_BRACKET]:

6282 self.state = 986

6283 self.match(CSharpParser.OPEN_BRACKET)

6284 self.state = 987

6285 self.expression()

6286 self.state = 988

6287 self.match(CSharpParser.CLOSE_BRACKET)

6288 pass

6289 else:

6290 raise NoViableAltException(self)

6291

6292 self.state = 992

6293 self.match(CSharpParser.ASSIGNMENT)

6294 self.state = 993

6295 self.initializer_value()

6296 except RecognitionException as re:

6297 localctx.exception = re

6298 self._errHandler.reportError(self, re)

6299 self._errHandler.recover(self, re)

6300 finally:

6301 self.exitRule()

6302 return localctx

6303

6304

6305 class Initializer_valueContext(ParserRuleContext):

6306 __slots__ = 'parser'

6307

6308 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

6309 super().__init__(parent, invokingState)

6310 self.parser = parser

6311

6312 def expression(self):

6313 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

6314

6315

6316 def object_or_collection_initializer(self):

6317 return self.getTypedRuleContext(CSharpParser.Object_or_collection_initializerContext,0)

6318

6319

6320 def getRuleIndex(self):

6321 return CSharpParser.RULE_initializer_value

6322

6323 def enterRule(self, listener:ParseTreeListener):

6324 if hasattr( listener, "enterInitializer_value" ):

6325 listener.enterInitializer_value(self)

6326

6327 def exitRule(self, listener:ParseTreeListener):

6328 if hasattr( listener, "exitInitializer_value" ):

6329 listener.exitInitializer_value(self)

6334 def initializer_value(self):

6335

6336 localctx = CSharpParser.Initializer_valueContext(self, self._ctx, self.state)

6337 self.enterRule(localctx, 96, self.RULE_initializer_value)

6338 try:

6339 self.state = 997

6340 self._errHandler.sync(self)

6341 token = self._input.LA(1)

6342 if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:

6343 self.enterOuterAlt(localctx, 1)

6344 self.state = 995

6345 self.expression()

6346 pass

6347 elif token in [CSharpParser.OPEN_BRACE]:

6348 self.enterOuterAlt(localctx, 2)

6349 self.state = 996

6350 self.object_or_collection_initializer()

6351 pass

6352 else:

6353 raise NoViableAltException(self)

6354

6355 except RecognitionException as re:

6356 localctx.exception = re

6357 self._errHandler.reportError(self, re)

6358 self._errHandler.recover(self, re)

6359 finally:

6360 self.exitRule()

6361 return localctx

6362

6363

6364 class Collection_initializerContext(ParserRuleContext):

6365 __slots__ = 'parser'

6366

6367 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

6368 super().__init__(parent, invokingState)

6369 self.parser = parser

6370

6371 def OPEN_BRACE(self):

6372 return self.getToken(CSharpParser.OPEN_BRACE, 0)

6373

6374 def element_initializer(self, i:int=None):

6375 if i is None:

6376 return self.getTypedRuleContexts(CSharpParser.Element_initializerContext)

6377 else:

6378 return self.getTypedRuleContext(CSharpParser.Element_initializerContext,i)

6379

6380

6381 def CLOSE_BRACE(self):

6382 return self.getToken(CSharpParser.CLOSE_BRACE, 0)

6383

6384 def COMMA(self, i:int=None):

6385 if i is None:

6386 return self.getTokens(CSharpParser.COMMA)

6387 else:

6388 return self.getToken(CSharpParser.COMMA, i)

6389

6390 def getRuleIndex(self):

6391 return CSharpParser.RULE_collection_initializer

6392

6393 def enterRule(self, listener:ParseTreeListener):

6394 if hasattr( listener, "enterCollection_initializer" ):

6395 listener.enterCollection_initializer(self)

6396

6397 def exitRule(self, listener:ParseTreeListener):

6398 if hasattr( listener, "exitCollection_initializer" ):

6399 listener.exitCollection_initializer(self)

6404 def collection_initializer(self):

6405

6406 localctx = CSharpParser.Collection_initializerContext(self, self._ctx, self.state)

6407 self.enterRule(localctx, 98, self.RULE_collection_initializer)

6408 self._la = 0 # Token type

6409 try:

6410 self.enterOuterAlt(localctx, 1)

6411 self.state = 999

6412 self.match(CSharpParser.OPEN_BRACE)

6413 self.state = 1000

6414 self.element_initializer()

6415 self.state = 1005

6416 self._errHandler.sync(self)

6417 _alt = self._interp.adaptivePredict(self._input,87,self._ctx)

6418 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

6419 if _alt==1:

6420 self.state = 1001

6421 self.match(CSharpParser.COMMA)

6422 self.state = 1002

6423 self.element_initializer()

6424 self.state = 1007

6425 self._errHandler.sync(self)

6426 _alt = self._interp.adaptivePredict(self._input,87,self._ctx)

6427

6428 self.state = 1009

6429 self._errHandler.sync(self)

6430 _la = self._input.LA(1)

6431 if _la==CSharpParser.COMMA:

6432 self.state = 1008

6433 self.match(CSharpParser.COMMA)

6434

6435

6436 self.state = 1011

6437 self.match(CSharpParser.CLOSE_BRACE)

6438 except RecognitionException as re:

6439 localctx.exception = re

6440 self._errHandler.reportError(self, re)

6441 self._errHandler.recover(self, re)

6442 finally:

6443 self.exitRule()

6444 return localctx

6445

6446

6447 class Element_initializerContext(ParserRuleContext):

6448 __slots__ = 'parser'

6449

6450 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

6451 super().__init__(parent, invokingState)

6452 self.parser = parser

6453

6454 def non_assignment_expression(self):

6455 return self.getTypedRuleContext(CSharpParser.Non_assignment_expressionContext,0)

6456

6457

6458 def OPEN_BRACE(self):

6459 return self.getToken(CSharpParser.OPEN_BRACE, 0)

6460

6461 def expression_list(self):

6462 return self.getTypedRuleContext(CSharpParser.Expression_listContext,0)

6463

6464

6465 def CLOSE_BRACE(self):

6466 return self.getToken(CSharpParser.CLOSE_BRACE, 0)

6467

6468 def getRuleIndex(self):

6469 return CSharpParser.RULE_element_initializer

6470

6471 def enterRule(self, listener:ParseTreeListener):

6472 if hasattr( listener, "enterElement_initializer" ):

6473 listener.enterElement_initializer(self)

6474

6475 def exitRule(self, listener:ParseTreeListener):

6476 if hasattr( listener, "exitElement_initializer" ):

6477 listener.exitElement_initializer(self)

6482 def element_initializer(self):

6483

6484 localctx = CSharpParser.Element_initializerContext(self, self._ctx, self.state)

6485 self.enterRule(localctx, 100, self.RULE_element_initializer)

6486 try:

6487 self.state = 1018

6488 self._errHandler.sync(self)

6489 token = self._input.LA(1)

6490 if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:

6491 self.enterOuterAlt(localctx, 1)

6492 self.state = 1013

6493 self.non_assignment_expression()

6494 pass

6495 elif token in [CSharpParser.OPEN_BRACE]:

6496 self.enterOuterAlt(localctx, 2)

6497 self.state = 1014

6498 self.match(CSharpParser.OPEN_BRACE)

6499 self.state = 1015

6500 self.expression_list()

6501 self.state = 1016

6502 self.match(CSharpParser.CLOSE_BRACE)

6503 pass

6504 else:

6505 raise NoViableAltException(self)

6506

6507 except RecognitionException as re:

6508 localctx.exception = re

6509 self._errHandler.reportError(self, re)

6510 self._errHandler.recover(self, re)

6511 finally:

6512 self.exitRule()

6513 return localctx

6514

6515

6516 class Anonymous_object_initializerContext(ParserRuleContext):

6517 __slots__ = 'parser'

6518

6519 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

6520 super().__init__(parent, invokingState)

6521 self.parser = parser

6522

6523 def OPEN_BRACE(self):

6524 return self.getToken(CSharpParser.OPEN_BRACE, 0)

6525

6526 def CLOSE_BRACE(self):

6527 return self.getToken(CSharpParser.CLOSE_BRACE, 0)

6528

6529 def member_declarator_list(self):

6530 return self.getTypedRuleContext(CSharpParser.Member_declarator_listContext,0)

6531

6532

6533 def COMMA(self):

6534 return self.getToken(CSharpParser.COMMA, 0)

6535

6536 def getRuleIndex(self):

6537 return CSharpParser.RULE_anonymous_object_initializer

6538

6539 def enterRule(self, listener:ParseTreeListener):

6540 if hasattr( listener, "enterAnonymous_object_initializer" ):

6541 listener.enterAnonymous_object_initializer(self)

6542

6543 def exitRule(self, listener:ParseTreeListener):

6544 if hasattr( listener, "exitAnonymous_object_initializer" ):

6545 listener.exitAnonymous_object_initializer(self)

6550 def anonymous_object_initializer(self):

6551

6552 localctx = CSharpParser.Anonymous_object_initializerContext(self, self._ctx, self.state)

6553 self.enterRule(localctx, 102, self.RULE_anonymous_object_initializer)

6554 self._la = 0 # Token type

6555 try:

6556 self.enterOuterAlt(localctx, 1)

6557 self.state = 1020

6558 self.match(CSharpParser.OPEN_BRACE)

6559 self.state = 1025

6560 self._errHandler.sync(self)

6561 _la = self._input.LA(1)

6563 self.state = 1021

6564 self.member_declarator_list()

6565 self.state = 1023

6566 self._errHandler.sync(self)

6567 _la = self._input.LA(1)

6568 if _la==CSharpParser.COMMA:

6569 self.state = 1022

6570 self.match(CSharpParser.COMMA)

6575 self.state = 1027

6576 self.match(CSharpParser.CLOSE_BRACE)

6577 except RecognitionException as re:

6578 localctx.exception = re

6579 self._errHandler.reportError(self, re)

6580 self._errHandler.recover(self, re)

6581 finally:

6582 self.exitRule()

6583 return localctx

6584

6585

6586 class Member_declarator_listContext(ParserRuleContext):

6587 __slots__ = 'parser'

6588

6589 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

6590 super().__init__(parent, invokingState)

6591 self.parser = parser

6592

6593 def member_declarator(self, i:int=None):

6594 if i is None:

6595 return self.getTypedRuleContexts(CSharpParser.Member_declaratorContext)

6596 else:

6597 return self.getTypedRuleContext(CSharpParser.Member_declaratorContext,i)

6598

6599

6600 def COMMA(self, i:int=None):

6601 if i is None:

6602 return self.getTokens(CSharpParser.COMMA)

6603 else:

6604 return self.getToken(CSharpParser.COMMA, i)

6605

6606 def getRuleIndex(self):

6607 return CSharpParser.RULE_member_declarator_list

6608

6609 def enterRule(self, listener:ParseTreeListener):

6610 if hasattr( listener, "enterMember_declarator_list" ):

6611 listener.enterMember_declarator_list(self)

6612

6613 def exitRule(self, listener:ParseTreeListener):

6614 if hasattr( listener, "exitMember_declarator_list" ):

6615 listener.exitMember_declarator_list(self)

6620 def member_declarator_list(self):

6621

6622 localctx = CSharpParser.Member_declarator_listContext(self, self._ctx, self.state)

6623 self.enterRule(localctx, 104, self.RULE_member_declarator_list)

6624 try:

6625 self.enterOuterAlt(localctx, 1)

6626 self.state = 1029

6627 self.member_declarator()

6628 self.state = 1034

6629 self._errHandler.sync(self)

6630 _alt = self._interp.adaptivePredict(self._input,92,self._ctx)

6631 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

6632 if _alt==1:

6633 self.state = 1030

6634 self.match(CSharpParser.COMMA)

6635 self.state = 1031

6636 self.member_declarator()

6637 self.state = 1036

6638 self._errHandler.sync(self)

6639 _alt = self._interp.adaptivePredict(self._input,92,self._ctx)

6640

6641 except RecognitionException as re:

6642 localctx.exception = re

6643 self._errHandler.reportError(self, re)

6644 self._errHandler.recover(self, re)

6645 finally:

6646 self.exitRule()

6647 return localctx

6648

6649

6650 class Member_declaratorContext(ParserRuleContext):

6651 __slots__ = 'parser'

6652

6653 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

6654 super().__init__(parent, invokingState)

6655 self.parser = parser

6656

6657 def primary_expression(self):

6658 return self.getTypedRuleContext(CSharpParser.Primary_expressionContext,0)

6659

6660

6661 def identifier(self):

6662 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

6663

6664

6665 def ASSIGNMENT(self):

6666 return self.getToken(CSharpParser.ASSIGNMENT, 0)

6667

6668 def expression(self):

6669 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

6670

6671

6672 def getRuleIndex(self):

6673 return CSharpParser.RULE_member_declarator

6674

6675 def enterRule(self, listener:ParseTreeListener):

6676 if hasattr( listener, "enterMember_declarator" ):

6677 listener.enterMember_declarator(self)

6678

6679 def exitRule(self, listener:ParseTreeListener):

6680 if hasattr( listener, "exitMember_declarator" ):

6681 listener.exitMember_declarator(self)

6686 def member_declarator(self):

6687

6688 localctx = CSharpParser.Member_declaratorContext(self, self._ctx, self.state)

6689 self.enterRule(localctx, 106, self.RULE_member_declarator)

6690 try:

6691 self.state = 1042

6692 self._errHandler.sync(self)

6693 la_ = self._interp.adaptivePredict(self._input,93,self._ctx)

6694 if la_ == 1:

6695 self.enterOuterAlt(localctx, 1)

6696 self.state = 1037

6697 self.primary_expression()

6698 pass

6699

6700 elif la_ == 2:

6701 self.enterOuterAlt(localctx, 2)

6702 self.state = 1038

6703 self.identifier()

6704 self.state = 1039

6705 self.match(CSharpParser.ASSIGNMENT)

6706 self.state = 1040

6707 self.expression()

6708 pass

6709

6710

6711 except RecognitionException as re:

6712 localctx.exception = re

6713 self._errHandler.reportError(self, re)

6714 self._errHandler.recover(self, re)

6715 finally:

6716 self.exitRule()

6717 return localctx

6718

6719

6720 class Unbound_type_nameContext(ParserRuleContext):

6721 __slots__ = 'parser'

6722

6723 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

6724 super().__init__(parent, invokingState)

6725 self.parser = parser

6726

6727 def identifier(self, i:int=None):

6728 if i is None:

6729 return self.getTypedRuleContexts(CSharpParser.IdentifierContext)

6730 else:

6731 return self.getTypedRuleContext(CSharpParser.IdentifierContext,i)

6732

6733

6734 def DOUBLE_COLON(self):

6735 return self.getToken(CSharpParser.DOUBLE_COLON, 0)

6736

6737 def DOT(self, i:int=None):

6738 if i is None:

6739 return self.getTokens(CSharpParser.DOT)

6740 else:

6741 return self.getToken(CSharpParser.DOT, i)

6742

6743 def generic_dimension_specifier(self, i:int=None):

6744 if i is None:

6745 return self.getTypedRuleContexts(CSharpParser.Generic_dimension_specifierContext)

6746 else:

6747 return self.getTypedRuleContext(CSharpParser.Generic_dimension_specifierContext,i)

6748

6749

6750 def getRuleIndex(self):

6751 return CSharpParser.RULE_unbound_type_name

6752

6753 def enterRule(self, listener:ParseTreeListener):

6754 if hasattr( listener, "enterUnbound_type_name" ):

6755 listener.enterUnbound_type_name(self)

6756

6757 def exitRule(self, listener:ParseTreeListener):

6758 if hasattr( listener, "exitUnbound_type_name" ):

6759 listener.exitUnbound_type_name(self)

6764 def unbound_type_name(self):

6765

6766 localctx = CSharpParser.Unbound_type_nameContext(self, self._ctx, self.state)

6767 self.enterRule(localctx, 108, self.RULE_unbound_type_name)

6768 self._la = 0 # Token type

6769 try:

6770 self.enterOuterAlt(localctx, 1)

6771 self.state = 1044

6772 self.identifier()

6773 self.state = 1053

6774 self._errHandler.sync(self)

6775 token = self._input.LA(1)

6776 if token in [CSharpParser.CLOSE_PARENS, CSharpParser.DOT, CSharpParser.LT]:

6777 self.state = 1046

6778 self._errHandler.sync(self)

6779 _la = self._input.LA(1)

6780 if _la==CSharpParser.LT:

6781 self.state = 1045

6782 self.generic_dimension_specifier()

6783

6784

6785 pass

6786 elif token in [CSharpParser.DOUBLE_COLON]:

6787 self.state = 1048

6788 self.match(CSharpParser.DOUBLE_COLON)

6789 self.state = 1049

6790 self.identifier()

6791 self.state = 1051

6792 self._errHandler.sync(self)

6793 _la = self._input.LA(1)

6794 if _la==CSharpParser.LT:

6795 self.state = 1050

6796 self.generic_dimension_specifier()

6797

6798

6799 pass

6800 else:

6801 raise NoViableAltException(self)

6802

6803 self.state = 1062

6804 self._errHandler.sync(self)

6805 _la = self._input.LA(1)

6806 while _la==CSharpParser.DOT:

6807 self.state = 1055

6808 self.match(CSharpParser.DOT)

6809 self.state = 1056

6810 self.identifier()

6811 self.state = 1058

6812 self._errHandler.sync(self)

6813 _la = self._input.LA(1)

6814 if _la==CSharpParser.LT:

6815 self.state = 1057

6816 self.generic_dimension_specifier()

6817

6818

6819 self.state = 1064

6820 self._errHandler.sync(self)

6821 _la = self._input.LA(1)

6822

6823 except RecognitionException as re:

6824 localctx.exception = re

6825 self._errHandler.reportError(self, re)

6826 self._errHandler.recover(self, re)

6827 finally:

6828 self.exitRule()

6829 return localctx

6830

6831

6832 class Generic_dimension_specifierContext(ParserRuleContext):

6833 __slots__ = 'parser'

6834

6835 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

6836 super().__init__(parent, invokingState)

6837 self.parser = parser

6838

6839 def LT(self):

6840 return self.getToken(CSharpParser.LT, 0)

6841

6842 def GT(self):

6843 return self.getToken(CSharpParser.GT, 0)

6844

6845 def COMMA(self, i:int=None):

6846 if i is None:

6847 return self.getTokens(CSharpParser.COMMA)

6848 else:

6849 return self.getToken(CSharpParser.COMMA, i)

6850

6851 def getRuleIndex(self):

6852 return CSharpParser.RULE_generic_dimension_specifier

6853

6854 def enterRule(self, listener:ParseTreeListener):

6855 if hasattr( listener, "enterGeneric_dimension_specifier" ):

6856 listener.enterGeneric_dimension_specifier(self)

6857

6858 def exitRule(self, listener:ParseTreeListener):

6859 if hasattr( listener, "exitGeneric_dimension_specifier" ):

6860 listener.exitGeneric_dimension_specifier(self)

6865 def generic_dimension_specifier(self):

6866

6867 localctx = CSharpParser.Generic_dimension_specifierContext(self, self._ctx, self.state)

6868 self.enterRule(localctx, 110, self.RULE_generic_dimension_specifier)

6869 self._la = 0 # Token type

6870 try:

6871 self.enterOuterAlt(localctx, 1)

6872 self.state = 1065

6873 self.match(CSharpParser.LT)

6874 self.state = 1069

6875 self._errHandler.sync(self)

6876 _la = self._input.LA(1)

6877 while _la==CSharpParser.COMMA:

6878 self.state = 1066

6879 self.match(CSharpParser.COMMA)

6880 self.state = 1071

6881 self._errHandler.sync(self)

6882 _la = self._input.LA(1)

6883

6884 self.state = 1072

6885 self.match(CSharpParser.GT)

6886 except RecognitionException as re:

6887 localctx.exception = re

6888 self._errHandler.reportError(self, re)

6889 self._errHandler.recover(self, re)

6890 finally:

6891 self.exitRule()

6892 return localctx

6893

6894

6895 class IsTypeContext(ParserRuleContext):

6896 __slots__ = 'parser'

6897

6898 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

6899 super().__init__(parent, invokingState)

6900 self.parser = parser

6901

6902 def base_type(self):

6903 return self.getTypedRuleContext(CSharpParser.Base_typeContext,0)

6904

6905

6906 def rank_specifier(self, i:int=None):

6907 if i is None:

6908 return self.getTypedRuleContexts(CSharpParser.Rank_specifierContext)

6909 else:

6910 return self.getTypedRuleContext(CSharpParser.Rank_specifierContext,i)

6911

6912

6913 def STAR(self, i:int=None):

6914 if i is None:

6915 return self.getTokens(CSharpParser.STAR)

6916 else:

6917 return self.getToken(CSharpParser.STAR, i)

6918

6919 def INTERR(self):

6920 return self.getToken(CSharpParser.INTERR, 0)

6921

6922 def isTypePatternArms(self):

6923 return self.getTypedRuleContext(CSharpParser.IsTypePatternArmsContext,0)

6924

6925

6926 def identifier(self):

6927 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

6928

6929

6930 def getRuleIndex(self):

6931 return CSharpParser.RULE_isType

6932

6933 def enterRule(self, listener:ParseTreeListener):

6934 if hasattr( listener, "enterIsType" ):

6935 listener.enterIsType(self)

6936

6937 def exitRule(self, listener:ParseTreeListener):

6938 if hasattr( listener, "exitIsType" ):

6939 listener.exitIsType(self)

6944 def isType(self):

6945

6946 localctx = CSharpParser.IsTypeContext(self, self._ctx, self.state)

6947 self.enterRule(localctx, 112, self.RULE_isType)

6948 try:

6949 self.enterOuterAlt(localctx, 1)

6950 self.state = 1074

6951 self.base_type()

6952 self.state = 1079

6953 self._errHandler.sync(self)

6954 _alt = self._interp.adaptivePredict(self._input,101,self._ctx)

6955 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

6956 if _alt==1:

6957 self.state = 1077

6958 self._errHandler.sync(self)

6959 token = self._input.LA(1)

6960 if token in [CSharpParser.OPEN_BRACKET]:

6961 self.state = 1075

6962 self.rank_specifier()

6963 pass

6964 elif token in [CSharpParser.STAR]:

6965 self.state = 1076

6966 self.match(CSharpParser.STAR)

6967 pass

6968 else:

6969 raise NoViableAltException(self)

6970

6971 self.state = 1081

6972 self._errHandler.sync(self)

6973 _alt = self._interp.adaptivePredict(self._input,101,self._ctx)

6974

6975 self.state = 1083

6976 self._errHandler.sync(self)

6977 la_ = self._interp.adaptivePredict(self._input,102,self._ctx)

6978 if la_ == 1:

6979 self.state = 1082

6980 self.match(CSharpParser.INTERR)

6981

6982

6983 self.state = 1086

6984 self._errHandler.sync(self)

6985 la_ = self._interp.adaptivePredict(self._input,103,self._ctx)

6986 if la_ == 1:

6987 self.state = 1085

6988 self.isTypePatternArms()

6989

6990

6991 self.state = 1089

6992 self._errHandler.sync(self)

6993 la_ = self._interp.adaptivePredict(self._input,104,self._ctx)

6994 if la_ == 1:

6995 self.state = 1088

6996 self.identifier()

6997

6998

6999 except RecognitionException as re:

7000 localctx.exception = re

7001 self._errHandler.reportError(self, re)

7002 self._errHandler.recover(self, re)

7003 finally:

7004 self.exitRule()

7005 return localctx

7006

7007

7008 class IsTypePatternArmsContext(ParserRuleContext):

7009 __slots__ = 'parser'

7010

7011 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

7012 super().__init__(parent, invokingState)

7013 self.parser = parser

7014

7015 def OPEN_BRACE(self):

7016 return self.getToken(CSharpParser.OPEN_BRACE, 0)

7017

7018 def isTypePatternArm(self, i:int=None):

7019 if i is None:

7020 return self.getTypedRuleContexts(CSharpParser.IsTypePatternArmContext)

7021 else:

7022 return self.getTypedRuleContext(CSharpParser.IsTypePatternArmContext,i)

7023

7024

7025 def CLOSE_BRACE(self):

7026 return self.getToken(CSharpParser.CLOSE_BRACE, 0)

7027

7028 def COMMA(self, i:int=None):

7029 if i is None:

7030 return self.getTokens(CSharpParser.COMMA)

7031 else:

7032 return self.getToken(CSharpParser.COMMA, i)

7033

7034 def getRuleIndex(self):

7035 return CSharpParser.RULE_isTypePatternArms

7036

7037 def enterRule(self, listener:ParseTreeListener):

7038 if hasattr( listener, "enterIsTypePatternArms" ):

7039 listener.enterIsTypePatternArms(self)

7040

7041 def exitRule(self, listener:ParseTreeListener):

7042 if hasattr( listener, "exitIsTypePatternArms" ):

7043 listener.exitIsTypePatternArms(self)

7048 def isTypePatternArms(self):

7049

7050 localctx = CSharpParser.IsTypePatternArmsContext(self, self._ctx, self.state)

7051 self.enterRule(localctx, 114, self.RULE_isTypePatternArms)

7052 self._la = 0 # Token type

7053 try:

7054 self.enterOuterAlt(localctx, 1)

7055 self.state = 1091

7056 self.match(CSharpParser.OPEN_BRACE)

7057 self.state = 1092

7058 self.isTypePatternArm()

7059 self.state = 1097

7060 self._errHandler.sync(self)

7061 _la = self._input.LA(1)

7062 while _la==CSharpParser.COMMA:

7063 self.state = 1093

7064 self.match(CSharpParser.COMMA)

7065 self.state = 1094

7066 self.isTypePatternArm()

7067 self.state = 1099

7068 self._errHandler.sync(self)

7069 _la = self._input.LA(1)

7070

7071 self.state = 1100

7072 self.match(CSharpParser.CLOSE_BRACE)

7073 except RecognitionException as re:

7074 localctx.exception = re

7075 self._errHandler.reportError(self, re)

7076 self._errHandler.recover(self, re)

7077 finally:

7078 self.exitRule()

7079 return localctx

7080

7081

7082 class IsTypePatternArmContext(ParserRuleContext):

7083 __slots__ = 'parser'

7084

7085 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

7086 super().__init__(parent, invokingState)

7087 self.parser = parser

7088

7089 def identifier(self):

7090 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

7091

7092

7093 def COLON(self):

7094 return self.getToken(CSharpParser.COLON, 0)

7095

7096 def expression(self):

7097 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

7098

7099

7100 def getRuleIndex(self):

7101 return CSharpParser.RULE_isTypePatternArm

7102

7103 def enterRule(self, listener:ParseTreeListener):

7104 if hasattr( listener, "enterIsTypePatternArm" ):

7105 listener.enterIsTypePatternArm(self)

7106

7107 def exitRule(self, listener:ParseTreeListener):

7108 if hasattr( listener, "exitIsTypePatternArm" ):

7109 listener.exitIsTypePatternArm(self)

7114 def isTypePatternArm(self):

7115

7116 localctx = CSharpParser.IsTypePatternArmContext(self, self._ctx, self.state)

7117 self.enterRule(localctx, 116, self.RULE_isTypePatternArm)

7118 try:

7119 self.enterOuterAlt(localctx, 1)

7120 self.state = 1102

7121 self.identifier()

7122 self.state = 1103

7123 self.match(CSharpParser.COLON)

7124 self.state = 1104

7125 self.expression()

7126 except RecognitionException as re:

7127 localctx.exception = re

7128 self._errHandler.reportError(self, re)

7129 self._errHandler.recover(self, re)

7130 finally:

7131 self.exitRule()

7132 return localctx

7133

7134

7135 class Lambda_expressionContext(ParserRuleContext):

7136 __slots__ = 'parser'

7137

7138 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

7139 super().__init__(parent, invokingState)

7140 self.parser = parser

7141

7142 def anonymous_function_signature(self):

7143 return self.getTypedRuleContext(CSharpParser.Anonymous_function_signatureContext,0)

7144

7145

7146 def right_arrow(self):

7147 return self.getTypedRuleContext(CSharpParser.Right_arrowContext,0)

7148

7149

7150 def anonymous_function_body(self):

7151 return self.getTypedRuleContext(CSharpParser.Anonymous_function_bodyContext,0)

7152

7153

7154 def ASYNC(self):

7155 return self.getToken(CSharpParser.ASYNC, 0)

7156

7157 def getRuleIndex(self):

7158 return CSharpParser.RULE_lambda_expression

7159

7160 def enterRule(self, listener:ParseTreeListener):

7161 if hasattr( listener, "enterLambda_expression" ):

7162 listener.enterLambda_expression(self)

7163

7164 def exitRule(self, listener:ParseTreeListener):

7165 if hasattr( listener, "exitLambda_expression" ):

7166 listener.exitLambda_expression(self)

7171 def lambda_expression(self):

7172

7173 localctx = CSharpParser.Lambda_expressionContext(self, self._ctx, self.state)

7174 self.enterRule(localctx, 118, self.RULE_lambda_expression)

7175 try:

7176 self.enterOuterAlt(localctx, 1)

7177 self.state = 1107

7178 self._errHandler.sync(self)

7179 la_ = self._interp.adaptivePredict(self._input,106,self._ctx)

7180 if la_ == 1:

7181 self.state = 1106

7182 self.match(CSharpParser.ASYNC)

7183

7184

7185 self.state = 1109

7186 self.anonymous_function_signature()

7187 self.state = 1110

7188 self.right_arrow()

7189 self.state = 1111

7190 self.anonymous_function_body()

7191 except RecognitionException as re:

7192 localctx.exception = re

7193 self._errHandler.reportError(self, re)

7194 self._errHandler.recover(self, re)

7195 finally:

7196 self.exitRule()

7197 return localctx

7198

7199

7200 class Anonymous_function_signatureContext(ParserRuleContext):

7201 __slots__ = 'parser'

7202

7203 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

7204 super().__init__(parent, invokingState)

7205 self.parser = parser

7206

7207 def OPEN_PARENS(self):

7208 return self.getToken(CSharpParser.OPEN_PARENS, 0)

7209

7210 def CLOSE_PARENS(self):

7211 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

7212

7213 def explicit_anonymous_function_parameter_list(self):

7214 return self.getTypedRuleContext(CSharpParser.Explicit_anonymous_function_parameter_listContext,0)

7215

7216

7217 def implicit_anonymous_function_parameter_list(self):

7218 return self.getTypedRuleContext(CSharpParser.Implicit_anonymous_function_parameter_listContext,0)

7219

7220

7221 def identifier(self):

7222 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

7223

7224

7225 def getRuleIndex(self):

7226 return CSharpParser.RULE_anonymous_function_signature

7227

7228 def enterRule(self, listener:ParseTreeListener):

7229 if hasattr( listener, "enterAnonymous_function_signature" ):

7230 listener.enterAnonymous_function_signature(self)

7231

7232 def exitRule(self, listener:ParseTreeListener):

7233 if hasattr( listener, "exitAnonymous_function_signature" ):

7234 listener.exitAnonymous_function_signature(self)

7239 def anonymous_function_signature(self):

7240

7241 localctx = CSharpParser.Anonymous_function_signatureContext(self, self._ctx, self.state)

7242 self.enterRule(localctx, 120, self.RULE_anonymous_function_signature)

7243 try:

7244 self.state = 1124

7245 self._errHandler.sync(self)

7246 la_ = self._interp.adaptivePredict(self._input,107,self._ctx)

7247 if la_ == 1:

7248 self.enterOuterAlt(localctx, 1)

7249 self.state = 1113

7250 self.match(CSharpParser.OPEN_PARENS)

7251 self.state = 1114

7252 self.match(CSharpParser.CLOSE_PARENS)

7253 pass

7254

7255 elif la_ == 2:

7256 self.enterOuterAlt(localctx, 2)

7257 self.state = 1115

7258 self.match(CSharpParser.OPEN_PARENS)

7259 self.state = 1116

7260 self.explicit_anonymous_function_parameter_list()

7261 self.state = 1117

7262 self.match(CSharpParser.CLOSE_PARENS)

7263 pass

7264

7265 elif la_ == 3:

7266 self.enterOuterAlt(localctx, 3)

7267 self.state = 1119

7268 self.match(CSharpParser.OPEN_PARENS)

7269 self.state = 1120

7270 self.implicit_anonymous_function_parameter_list()

7271 self.state = 1121

7272 self.match(CSharpParser.CLOSE_PARENS)

7273 pass

7274

7275 elif la_ == 4:

7276 self.enterOuterAlt(localctx, 4)

7277 self.state = 1123

7278 self.identifier()

7279 pass

7280

7281

7282 except RecognitionException as re:

7283 localctx.exception = re

7284 self._errHandler.reportError(self, re)

7285 self._errHandler.recover(self, re)

7286 finally:

7287 self.exitRule()

7288 return localctx

7289

7290

7291 class Explicit_anonymous_function_parameter_listContext(ParserRuleContext):

7292 __slots__ = 'parser'

7293

7294 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

7295 super().__init__(parent, invokingState)

7296 self.parser = parser

7297

7298 def explicit_anonymous_function_parameter(self, i:int=None):

7299 if i is None:

7300 return self.getTypedRuleContexts(CSharpParser.Explicit_anonymous_function_parameterContext)

7301 else:

7302 return self.getTypedRuleContext(CSharpParser.Explicit_anonymous_function_parameterContext,i)

7303

7304

7305 def COMMA(self, i:int=None):

7306 if i is None:

7307 return self.getTokens(CSharpParser.COMMA)

7308 else:

7309 return self.getToken(CSharpParser.COMMA, i)

7310

7311 def getRuleIndex(self):

7312 return CSharpParser.RULE_explicit_anonymous_function_parameter_list

7313

7314 def enterRule(self, listener:ParseTreeListener):

7315 if hasattr( listener, "enterExplicit_anonymous_function_parameter_list" ):

7316 listener.enterExplicit_anonymous_function_parameter_list(self)

7317

7318 def exitRule(self, listener:ParseTreeListener):

7319 if hasattr( listener, "exitExplicit_anonymous_function_parameter_list" ):

7320 listener.exitExplicit_anonymous_function_parameter_list(self)

7325 def explicit_anonymous_function_parameter_list(self):

7326

7327 localctx = CSharpParser.Explicit_anonymous_function_parameter_listContext(self, self._ctx, self.state)

7328 self.enterRule(localctx, 122, self.RULE_explicit_anonymous_function_parameter_list)

7329 self._la = 0 # Token type

7330 try:

7331 self.enterOuterAlt(localctx, 1)

7332 self.state = 1126

7333 self.explicit_anonymous_function_parameter()

7334 self.state = 1131

7335 self._errHandler.sync(self)

7336 _la = self._input.LA(1)

7337 while _la==CSharpParser.COMMA:

7338 self.state = 1127

7339 self.match(CSharpParser.COMMA)

7340 self.state = 1128

7341 self.explicit_anonymous_function_parameter()

7342 self.state = 1133

7343 self._errHandler.sync(self)

7344 _la = self._input.LA(1)

7345

7346 except RecognitionException as re:

7347 localctx.exception = re

7348 self._errHandler.reportError(self, re)

7349 self._errHandler.recover(self, re)

7350 finally:

7351 self.exitRule()

7352 return localctx

7353

7354

7355 class Explicit_anonymous_function_parameterContext(ParserRuleContext):

7356 __slots__ = 'parser'

7357

7358 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

7359 super().__init__(parent, invokingState)

7360 self.parser = parser

7361 self.refout = None # Token

7362

7363 def type_(self):

7364 return self.getTypedRuleContext(CSharpParser.Type_Context,0)

7365

7366

7367 def identifier(self):

7368 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

7369

7370

7371 def REF(self):

7372 return self.getToken(CSharpParser.REF, 0)

7373

7374 def OUT(self):

7375 return self.getToken(CSharpParser.OUT, 0)

7376

7377 def IN(self):

7378 return self.getToken(CSharpParser.IN, 0)

7379

7380 def getRuleIndex(self):

7381 return CSharpParser.RULE_explicit_anonymous_function_parameter

7382

7383 def enterRule(self, listener:ParseTreeListener):

7384 if hasattr( listener, "enterExplicit_anonymous_function_parameter" ):

7385 listener.enterExplicit_anonymous_function_parameter(self)

7386

7387 def exitRule(self, listener:ParseTreeListener):

7388 if hasattr( listener, "exitExplicit_anonymous_function_parameter" ):

7389 listener.exitExplicit_anonymous_function_parameter(self)

7394 def explicit_anonymous_function_parameter(self):

7395

7396 localctx = CSharpParser.Explicit_anonymous_function_parameterContext(self, self._ctx, self.state)

7397 self.enterRule(localctx, 124, self.RULE_explicit_anonymous_function_parameter)

7398 self._la = 0 # Token type

7399 try:

7400 self.enterOuterAlt(localctx, 1)

7401 self.state = 1135

7402 self._errHandler.sync(self)

7403 _la = self._input.LA(1)

7404 if ((((_la - 54)) & ~0x3f) == 0 and ((1 << (_la - 54)) & ((1 << (CSharpParser.IN - 54)) | (1 << (CSharpParser.OUT - 54)) | (1 << (CSharpParser.REF - 54)))) != 0):

7405 self.state = 1134

7406 localctx.refout = self._input.LT(1)

7407 _la = self._input.LA(1)

7408 if not(((((_la - 54)) & ~0x3f) == 0 and ((1 << (_la - 54)) & ((1 << (CSharpParser.IN - 54)) | (1 << (CSharpParser.OUT - 54)) | (1 << (CSharpParser.REF - 54)))) != 0)):

7409 localctx.refout = self._errHandler.recoverInline(self)

7410 else:

7411 self._errHandler.reportMatch(self)

7412 self.consume()

7413

7414

7415 self.state = 1137

7416 self.type_()

7417 self.state = 1138

7418 self.identifier()

7419 except RecognitionException as re:

7420 localctx.exception = re

7421 self._errHandler.reportError(self, re)

7422 self._errHandler.recover(self, re)

7423 finally:

7424 self.exitRule()

7425 return localctx

7426

7427

7428 class Implicit_anonymous_function_parameter_listContext(ParserRuleContext):

7429 __slots__ = 'parser'

7430

7431 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

7432 super().__init__(parent, invokingState)

7433 self.parser = parser

7434

7435 def identifier(self, i:int=None):

7436 if i is None:

7437 return self.getTypedRuleContexts(CSharpParser.IdentifierContext)

7438 else:

7439 return self.getTypedRuleContext(CSharpParser.IdentifierContext,i)

7440

7441

7442 def COMMA(self, i:int=None):

7443 if i is None:

7444 return self.getTokens(CSharpParser.COMMA)

7445 else:

7446 return self.getToken(CSharpParser.COMMA, i)

7447

7448 def getRuleIndex(self):

7449 return CSharpParser.RULE_implicit_anonymous_function_parameter_list

7450

7451 def enterRule(self, listener:ParseTreeListener):

7452 if hasattr( listener, "enterImplicit_anonymous_function_parameter_list" ):

7453 listener.enterImplicit_anonymous_function_parameter_list(self)

7454

7455 def exitRule(self, listener:ParseTreeListener):

7456 if hasattr( listener, "exitImplicit_anonymous_function_parameter_list" ):

7457 listener.exitImplicit_anonymous_function_parameter_list(self)

7462 def implicit_anonymous_function_parameter_list(self):

7463

7464 localctx = CSharpParser.Implicit_anonymous_function_parameter_listContext(self, self._ctx, self.state)

7465 self.enterRule(localctx, 126, self.RULE_implicit_anonymous_function_parameter_list)

7466 self._la = 0 # Token type

7467 try:

7468 self.enterOuterAlt(localctx, 1)

7469 self.state = 1140

7470 self.identifier()

7471 self.state = 1145

7472 self._errHandler.sync(self)

7473 _la = self._input.LA(1)

7474 while _la==CSharpParser.COMMA:

7475 self.state = 1141

7476 self.match(CSharpParser.COMMA)

7477 self.state = 1142

7478 self.identifier()

7479 self.state = 1147

7480 self._errHandler.sync(self)

7481 _la = self._input.LA(1)

7482

7483 except RecognitionException as re:

7484 localctx.exception = re

7485 self._errHandler.reportError(self, re)

7486 self._errHandler.recover(self, re)

7487 finally:

7488 self.exitRule()

7489 return localctx

7490

7491

7492 class Anonymous_function_bodyContext(ParserRuleContext):

7493 __slots__ = 'parser'

7494

7495 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

7496 super().__init__(parent, invokingState)

7497 self.parser = parser

7498

7499 def throwable_expression(self):

7500 return self.getTypedRuleContext(CSharpParser.Throwable_expressionContext,0)

7501

7502

7503 def block(self):

7504 return self.getTypedRuleContext(CSharpParser.BlockContext,0)

7505

7506

7507 def getRuleIndex(self):

7508 return CSharpParser.RULE_anonymous_function_body

7509

7510 def enterRule(self, listener:ParseTreeListener):

7511 if hasattr( listener, "enterAnonymous_function_body" ):

7512 listener.enterAnonymous_function_body(self)

7513

7514 def exitRule(self, listener:ParseTreeListener):

7515 if hasattr( listener, "exitAnonymous_function_body" ):

7516 listener.exitAnonymous_function_body(self)

7521 def anonymous_function_body(self):

7522

7523 localctx = CSharpParser.Anonymous_function_bodyContext(self, self._ctx, self.state)

7524 self.enterRule(localctx, 128, self.RULE_anonymous_function_body)

7525 try:

7526 self.state = 1150

7527 self._errHandler.sync(self)

7528 token = self._input.LA(1)

7529 if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.THROW, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:

7530 self.enterOuterAlt(localctx, 1)

7531 self.state = 1148

7532 self.throwable_expression()

7533 pass

7534 elif token in [CSharpParser.OPEN_BRACE]:

7535 self.enterOuterAlt(localctx, 2)

7536 self.state = 1149

7537 self.block()

7538 pass

7539 else:

7540 raise NoViableAltException(self)

7541

7542 except RecognitionException as re:

7543 localctx.exception = re

7544 self._errHandler.reportError(self, re)

7545 self._errHandler.recover(self, re)

7546 finally:

7547 self.exitRule()

7548 return localctx

7549

7550

7551 class Query_expressionContext(ParserRuleContext):

7552 __slots__ = 'parser'

7553

7554 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

7555 super().__init__(parent, invokingState)

7556 self.parser = parser

7557

7558 def from_clause(self):

7559 return self.getTypedRuleContext(CSharpParser.From_clauseContext,0)

7560

7561

7562 def query_body(self):

7563 return self.getTypedRuleContext(CSharpParser.Query_bodyContext,0)

7564

7565

7566 def getRuleIndex(self):

7567 return CSharpParser.RULE_query_expression

7568

7569 def enterRule(self, listener:ParseTreeListener):

7570 if hasattr( listener, "enterQuery_expression" ):

7571 listener.enterQuery_expression(self)

7572

7573 def exitRule(self, listener:ParseTreeListener):

7574 if hasattr( listener, "exitQuery_expression" ):

7575 listener.exitQuery_expression(self)

7580 def query_expression(self):

7581

7582 localctx = CSharpParser.Query_expressionContext(self, self._ctx, self.state)

7583 self.enterRule(localctx, 130, self.RULE_query_expression)

7584 try:

7585 self.enterOuterAlt(localctx, 1)

7586 self.state = 1152

7587 self.from_clause()

7588 self.state = 1153

7589 self.query_body()

7590 except RecognitionException as re:

7591 localctx.exception = re

7592 self._errHandler.reportError(self, re)

7593 self._errHandler.recover(self, re)

7594 finally:

7595 self.exitRule()

7596 return localctx

7597

7598

7599 class From_clauseContext(ParserRuleContext):

7600 __slots__ = 'parser'

7601

7602 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

7603 super().__init__(parent, invokingState)

7604 self.parser = parser

7605

7606 def FROM(self):

7607 return self.getToken(CSharpParser.FROM, 0)

7608

7609 def identifier(self):

7610 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

7611

7612

7613 def IN(self):

7614 return self.getToken(CSharpParser.IN, 0)

7615

7616 def expression(self):

7617 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

7618

7619

7620 def type_(self):

7621 return self.getTypedRuleContext(CSharpParser.Type_Context,0)

7622

7623

7624 def getRuleIndex(self):

7625 return CSharpParser.RULE_from_clause

7626

7627 def enterRule(self, listener:ParseTreeListener):

7628 if hasattr( listener, "enterFrom_clause" ):

7629 listener.enterFrom_clause(self)

7630

7631 def exitRule(self, listener:ParseTreeListener):

7632 if hasattr( listener, "exitFrom_clause" ):

7633 listener.exitFrom_clause(self)

7638 def from_clause(self):

7639

7640 localctx = CSharpParser.From_clauseContext(self, self._ctx, self.state)

7641 self.enterRule(localctx, 132, self.RULE_from_clause)

7642 try:

7643 self.enterOuterAlt(localctx, 1)

7644 self.state = 1155

7645 self.match(CSharpParser.FROM)

7646 self.state = 1157

7647 self._errHandler.sync(self)

7648 la_ = self._interp.adaptivePredict(self._input,112,self._ctx)

7649 if la_ == 1:

7650 self.state = 1156

7651 self.type_()

7652

7653

7654 self.state = 1159

7655 self.identifier()

7656 self.state = 1160

7657 self.match(CSharpParser.IN)

7658 self.state = 1161

7659 self.expression()

7660 except RecognitionException as re:

7661 localctx.exception = re

7662 self._errHandler.reportError(self, re)

7663 self._errHandler.recover(self, re)

7664 finally:

7665 self.exitRule()

7666 return localctx

7667

7668

7669 class Query_bodyContext(ParserRuleContext):

7670 __slots__ = 'parser'

7671

7672 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

7673 super().__init__(parent, invokingState)

7674 self.parser = parser

7675

7676 def select_or_group_clause(self):

7677 return self.getTypedRuleContext(CSharpParser.Select_or_group_clauseContext,0)

7678

7679

7680 def query_body_clause(self, i:int=None):

7681 if i is None:

7682 return self.getTypedRuleContexts(CSharpParser.Query_body_clauseContext)

7683 else:

7684 return self.getTypedRuleContext(CSharpParser.Query_body_clauseContext,i)

7685

7686

7687 def query_continuation(self):

7688 return self.getTypedRuleContext(CSharpParser.Query_continuationContext,0)

7689

7690

7691 def getRuleIndex(self):

7692 return CSharpParser.RULE_query_body

7693

7694 def enterRule(self, listener:ParseTreeListener):

7695 if hasattr( listener, "enterQuery_body" ):

7696 listener.enterQuery_body(self)

7697

7698 def exitRule(self, listener:ParseTreeListener):

7699 if hasattr( listener, "exitQuery_body" ):

7700 listener.exitQuery_body(self)

7705 def query_body(self):

7706

7707 localctx = CSharpParser.Query_bodyContext(self, self._ctx, self.state)

7708 self.enterRule(localctx, 134, self.RULE_query_body)

7709 self._la = 0 # Token type

7710 try:

7711 self.enterOuterAlt(localctx, 1)

7712 self.state = 1166

7713 self._errHandler.sync(self)

7714 _la = self._input.LA(1)

7715 while ((((_la - 48)) & ~0x3f) == 0 and ((1 << (_la - 48)) & ((1 << (CSharpParser.FROM - 48)) | (1 << (CSharpParser.JOIN - 48)) | (1 << (CSharpParser.LET - 48)) | (1 << (CSharpParser.ORDERBY - 48)) | (1 << (CSharpParser.WHERE - 48)))) != 0):

7716 self.state = 1163

7717 self.query_body_clause()

7718 self.state = 1168

7719 self._errHandler.sync(self)

7720 _la = self._input.LA(1)

7721

7722 self.state = 1169

7723 self.select_or_group_clause()

7724 self.state = 1171

7725 self._errHandler.sync(self)

7726 la_ = self._interp.adaptivePredict(self._input,114,self._ctx)

7727 if la_ == 1:

7728 self.state = 1170

7729 self.query_continuation()

7730

7731

7732 except RecognitionException as re:

7733 localctx.exception = re

7734 self._errHandler.reportError(self, re)

7735 self._errHandler.recover(self, re)

7736 finally:

7737 self.exitRule()

7738 return localctx

7739

7740

7741 class Query_body_clauseContext(ParserRuleContext):

7742 __slots__ = 'parser'

7743

7744 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

7745 super().__init__(parent, invokingState)

7746 self.parser = parser

7747

7748 def from_clause(self):

7749 return self.getTypedRuleContext(CSharpParser.From_clauseContext,0)

7750

7751

7752 def let_clause(self):

7753 return self.getTypedRuleContext(CSharpParser.Let_clauseContext,0)

7754

7755

7756 def where_clause(self):

7757 return self.getTypedRuleContext(CSharpParser.Where_clauseContext,0)

7758

7759

7760 def combined_join_clause(self):

7761 return self.getTypedRuleContext(CSharpParser.Combined_join_clauseContext,0)

7762

7763

7764 def orderby_clause(self):

7765 return self.getTypedRuleContext(CSharpParser.Orderby_clauseContext,0)

7766

7767

7768 def getRuleIndex(self):

7769 return CSharpParser.RULE_query_body_clause

7770

7771 def enterRule(self, listener:ParseTreeListener):

7772 if hasattr( listener, "enterQuery_body_clause" ):

7773 listener.enterQuery_body_clause(self)

7774

7775 def exitRule(self, listener:ParseTreeListener):

7776 if hasattr( listener, "exitQuery_body_clause" ):

7777 listener.exitQuery_body_clause(self)

7782 def query_body_clause(self):

7783

7784 localctx = CSharpParser.Query_body_clauseContext(self, self._ctx, self.state)

7785 self.enterRule(localctx, 136, self.RULE_query_body_clause)

7786 try:

7787 self.state = 1178

7788 self._errHandler.sync(self)

7789 token = self._input.LA(1)

7790 if token in [CSharpParser.FROM]:

7791 self.enterOuterAlt(localctx, 1)

7792 self.state = 1173

7793 self.from_clause()

7794 pass

7795 elif token in [CSharpParser.LET]:

7796 self.enterOuterAlt(localctx, 2)

7797 self.state = 1174

7798 self.let_clause()

7799 pass

7800 elif token in [CSharpParser.WHERE]:

7801 self.enterOuterAlt(localctx, 3)

7802 self.state = 1175

7803 self.where_clause()

7804 pass

7805 elif token in [CSharpParser.JOIN]:

7806 self.enterOuterAlt(localctx, 4)

7807 self.state = 1176

7808 self.combined_join_clause()

7809 pass

7810 elif token in [CSharpParser.ORDERBY]:

7811 self.enterOuterAlt(localctx, 5)

7812 self.state = 1177

7813 self.orderby_clause()

7814 pass

7815 else:

7816 raise NoViableAltException(self)

7817

7818 except RecognitionException as re:

7819 localctx.exception = re

7820 self._errHandler.reportError(self, re)

7821 self._errHandler.recover(self, re)

7822 finally:

7823 self.exitRule()

7824 return localctx

7825

7826

7827 class Let_clauseContext(ParserRuleContext):

7828 __slots__ = 'parser'

7829

7830 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

7831 super().__init__(parent, invokingState)

7832 self.parser = parser

7833

7834 def LET(self):

7835 return self.getToken(CSharpParser.LET, 0)

7836

7837 def identifier(self):

7838 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

7839

7840

7841 def ASSIGNMENT(self):

7842 return self.getToken(CSharpParser.ASSIGNMENT, 0)

7843

7844 def expression(self):

7845 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

7846

7847

7848 def getRuleIndex(self):

7849 return CSharpParser.RULE_let_clause

7850

7851 def enterRule(self, listener:ParseTreeListener):

7852 if hasattr( listener, "enterLet_clause" ):

7853 listener.enterLet_clause(self)

7854

7855 def exitRule(self, listener:ParseTreeListener):

7856 if hasattr( listener, "exitLet_clause" ):

7857 listener.exitLet_clause(self)

7862 def let_clause(self):

7863

7864 localctx = CSharpParser.Let_clauseContext(self, self._ctx, self.state)

7865 self.enterRule(localctx, 138, self.RULE_let_clause)

7866 try:

7867 self.enterOuterAlt(localctx, 1)

7868 self.state = 1180

7869 self.match(CSharpParser.LET)

7870 self.state = 1181

7871 self.identifier()

7872 self.state = 1182

7873 self.match(CSharpParser.ASSIGNMENT)

7874 self.state = 1183

7875 self.expression()

7876 except RecognitionException as re:

7877 localctx.exception = re

7878 self._errHandler.reportError(self, re)

7879 self._errHandler.recover(self, re)

7880 finally:

7881 self.exitRule()

7882 return localctx

7883

7884

7885 class Where_clauseContext(ParserRuleContext):

7886 __slots__ = 'parser'

7887

7888 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

7889 super().__init__(parent, invokingState)

7890 self.parser = parser

7891

7892 def WHERE(self):

7893 return self.getToken(CSharpParser.WHERE, 0)

7894

7895 def expression(self):

7896 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

7897

7898

7899 def getRuleIndex(self):

7900 return CSharpParser.RULE_where_clause

7901

7902 def enterRule(self, listener:ParseTreeListener):

7903 if hasattr( listener, "enterWhere_clause" ):

7904 listener.enterWhere_clause(self)

7905

7906 def exitRule(self, listener:ParseTreeListener):

7907 if hasattr( listener, "exitWhere_clause" ):

7908 listener.exitWhere_clause(self)

7913 def where_clause(self):

7914

7915 localctx = CSharpParser.Where_clauseContext(self, self._ctx, self.state)

7916 self.enterRule(localctx, 140, self.RULE_where_clause)

7917 try:

7918 self.enterOuterAlt(localctx, 1)

7919 self.state = 1185

7920 self.match(CSharpParser.WHERE)

7921 self.state = 1186

7922 self.expression()

7923 except RecognitionException as re:

7924 localctx.exception = re

7925 self._errHandler.reportError(self, re)

7926 self._errHandler.recover(self, re)

7927 finally:

7928 self.exitRule()

7929 return localctx

7930

7931

7932 class Combined_join_clauseContext(ParserRuleContext):

7933 __slots__ = 'parser'

7934

7935 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

7936 super().__init__(parent, invokingState)

7937 self.parser = parser

7938

7939 def JOIN(self):

7940 return self.getToken(CSharpParser.JOIN, 0)

7941

7942 def identifier(self, i:int=None):

7943 if i is None:

7944 return self.getTypedRuleContexts(CSharpParser.IdentifierContext)

7945 else:

7946 return self.getTypedRuleContext(CSharpParser.IdentifierContext,i)

7947

7948

7949 def IN(self):

7950 return self.getToken(CSharpParser.IN, 0)

7951

7952 def expression(self, i:int=None):

7953 if i is None:

7954 return self.getTypedRuleContexts(CSharpParser.ExpressionContext)

7955 else:

7956 return self.getTypedRuleContext(CSharpParser.ExpressionContext,i)

7957

7958

7959 def ON(self):

7960 return self.getToken(CSharpParser.ON, 0)

7961

7962 def EQUALS(self):

7963 return self.getToken(CSharpParser.EQUALS, 0)

7964

7965 def type_(self):

7966 return self.getTypedRuleContext(CSharpParser.Type_Context,0)

7967

7968

7969 def INTO(self):

7970 return self.getToken(CSharpParser.INTO, 0)

7971

7972 def getRuleIndex(self):

7973 return CSharpParser.RULE_combined_join_clause

7974

7975 def enterRule(self, listener:ParseTreeListener):

7976 if hasattr( listener, "enterCombined_join_clause" ):

7977 listener.enterCombined_join_clause(self)

7978

7979 def exitRule(self, listener:ParseTreeListener):

7980 if hasattr( listener, "exitCombined_join_clause" ):

7981 listener.exitCombined_join_clause(self)

7986 def combined_join_clause(self):

7987

7988 localctx = CSharpParser.Combined_join_clauseContext(self, self._ctx, self.state)

7989 self.enterRule(localctx, 142, self.RULE_combined_join_clause)

7990 self._la = 0 # Token type

7991 try:

7992 self.enterOuterAlt(localctx, 1)

7993 self.state = 1188

7994 self.match(CSharpParser.JOIN)

7995 self.state = 1190

7996 self._errHandler.sync(self)

7997 la_ = self._interp.adaptivePredict(self._input,116,self._ctx)

7998 if la_ == 1:

7999 self.state = 1189

8000 self.type_()

8001

8002

8003 self.state = 1192

8004 self.identifier()

8005 self.state = 1193

8006 self.match(CSharpParser.IN)

8007 self.state = 1194

8008 self.expression()

8009 self.state = 1195

8010 self.match(CSharpParser.ON)

8011 self.state = 1196

8012 self.expression()

8013 self.state = 1197

8014 self.match(CSharpParser.EQUALS)

8015 self.state = 1198

8016 self.expression()

8017 self.state = 1201

8018 self._errHandler.sync(self)

8019 _la = self._input.LA(1)

8020 if _la==CSharpParser.INTO:

8021 self.state = 1199

8022 self.match(CSharpParser.INTO)

8023 self.state = 1200

8024 self.identifier()

8025

8026

8027 except RecognitionException as re:

8028 localctx.exception = re

8029 self._errHandler.reportError(self, re)

8030 self._errHandler.recover(self, re)

8031 finally:

8032 self.exitRule()

8033 return localctx

8034

8035

8036 class Orderby_clauseContext(ParserRuleContext):

8037 __slots__ = 'parser'

8038

8039 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

8040 super().__init__(parent, invokingState)

8041 self.parser = parser

8042

8043 def ORDERBY(self):

8044 return self.getToken(CSharpParser.ORDERBY, 0)

8045

8046 def ordering(self, i:int=None):

8047 if i is None:

8048 return self.getTypedRuleContexts(CSharpParser.OrderingContext)

8049 else:

8050 return self.getTypedRuleContext(CSharpParser.OrderingContext,i)

8051

8052

8053 def COMMA(self, i:int=None):

8054 if i is None:

8055 return self.getTokens(CSharpParser.COMMA)

8056 else:

8057 return self.getToken(CSharpParser.COMMA, i)

8058

8059 def getRuleIndex(self):

8060 return CSharpParser.RULE_orderby_clause

8061

8062 def enterRule(self, listener:ParseTreeListener):

8063 if hasattr( listener, "enterOrderby_clause" ):

8064 listener.enterOrderby_clause(self)

8065

8066 def exitRule(self, listener:ParseTreeListener):

8067 if hasattr( listener, "exitOrderby_clause" ):

8068 listener.exitOrderby_clause(self)

8073 def orderby_clause(self):

8074

8075 localctx = CSharpParser.Orderby_clauseContext(self, self._ctx, self.state)

8076 self.enterRule(localctx, 144, self.RULE_orderby_clause)

8077 self._la = 0 # Token type

8078 try:

8079 self.enterOuterAlt(localctx, 1)

8080 self.state = 1203

8081 self.match(CSharpParser.ORDERBY)

8082 self.state = 1204

8083 self.ordering()

8084 self.state = 1209

8085 self._errHandler.sync(self)

8086 _la = self._input.LA(1)

8087 while _la==CSharpParser.COMMA:

8088 self.state = 1205

8089 self.match(CSharpParser.COMMA)

8090 self.state = 1206

8091 self.ordering()

8092 self.state = 1211

8093 self._errHandler.sync(self)

8094 _la = self._input.LA(1)

8095

8096 except RecognitionException as re:

8097 localctx.exception = re

8098 self._errHandler.reportError(self, re)

8099 self._errHandler.recover(self, re)

8100 finally:

8101 self.exitRule()

8102 return localctx

8103

8104

8105 class OrderingContext(ParserRuleContext):

8106 __slots__ = 'parser'

8107

8108 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

8109 super().__init__(parent, invokingState)

8110 self.parser = parser

8111 self.dir_ = None # Token

8112

8113 def expression(self):

8114 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

8115

8116

8117 def ASCENDING(self):

8118 return self.getToken(CSharpParser.ASCENDING, 0)

8119

8120 def DESCENDING(self):

8121 return self.getToken(CSharpParser.DESCENDING, 0)

8122

8123 def getRuleIndex(self):

8124 return CSharpParser.RULE_ordering

8125

8126 def enterRule(self, listener:ParseTreeListener):

8127 if hasattr( listener, "enterOrdering" ):

8128 listener.enterOrdering(self)

8129

8130 def exitRule(self, listener:ParseTreeListener):

8131 if hasattr( listener, "exitOrdering" ):

8132 listener.exitOrdering(self)

8137 def ordering(self):

8138

8139 localctx = CSharpParser.OrderingContext(self, self._ctx, self.state)

8140 self.enterRule(localctx, 146, self.RULE_ordering)

8141 self._la = 0 # Token type

8142 try:

8143 self.enterOuterAlt(localctx, 1)

8144 self.state = 1212

8145 self.expression()

8146 self.state = 1214

8147 self._errHandler.sync(self)

8148 _la = self._input.LA(1)

8149 if _la==CSharpParser.ASCENDING or _la==CSharpParser.DESCENDING:

8150 self.state = 1213

8151 localctx.dir_ = self._input.LT(1)

8152 _la = self._input.LA(1)

8153 if not(_la==CSharpParser.ASCENDING or _la==CSharpParser.DESCENDING):

8154 localctx.dir_ = self._errHandler.recoverInline(self)

8155 else:

8156 self._errHandler.reportMatch(self)

8157 self.consume()

8158

8159

8160 except RecognitionException as re:

8161 localctx.exception = re

8162 self._errHandler.reportError(self, re)

8163 self._errHandler.recover(self, re)

8164 finally:

8165 self.exitRule()

8166 return localctx

8167

8168

8169 class Select_or_group_clauseContext(ParserRuleContext):

8170 __slots__ = 'parser'

8171

8172 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

8173 super().__init__(parent, invokingState)

8174 self.parser = parser

8175

8176 def SELECT(self):

8177 return self.getToken(CSharpParser.SELECT, 0)

8178

8179 def expression(self, i:int=None):

8180 if i is None:

8181 return self.getTypedRuleContexts(CSharpParser.ExpressionContext)

8182 else:

8183 return self.getTypedRuleContext(CSharpParser.ExpressionContext,i)

8184

8185

8186 def GROUP(self):

8187 return self.getToken(CSharpParser.GROUP, 0)

8188

8189 def BY(self):

8190 return self.getToken(CSharpParser.BY, 0)

8191

8192 def getRuleIndex(self):

8193 return CSharpParser.RULE_select_or_group_clause

8194

8195 def enterRule(self, listener:ParseTreeListener):

8196 if hasattr( listener, "enterSelect_or_group_clause" ):

8197 listener.enterSelect_or_group_clause(self)

8198

8199 def exitRule(self, listener:ParseTreeListener):

8200 if hasattr( listener, "exitSelect_or_group_clause" ):

8201 listener.exitSelect_or_group_clause(self)

8206 def select_or_group_clause(self):

8207

8208 localctx = CSharpParser.Select_or_group_clauseContext(self, self._ctx, self.state)

8209 self.enterRule(localctx, 148, self.RULE_select_or_group_clause)

8210 try:

8211 self.state = 1223

8212 self._errHandler.sync(self)

8213 token = self._input.LA(1)

8214 if token in [CSharpParser.SELECT]:

8215 self.enterOuterAlt(localctx, 1)

8216 self.state = 1216

8217 self.match(CSharpParser.SELECT)

8218 self.state = 1217

8219 self.expression()

8220 pass

8221 elif token in [CSharpParser.GROUP]:

8222 self.enterOuterAlt(localctx, 2)

8223 self.state = 1218

8224 self.match(CSharpParser.GROUP)

8225 self.state = 1219

8226 self.expression()

8227 self.state = 1220

8228 self.match(CSharpParser.BY)

8229 self.state = 1221

8230 self.expression()

8231 pass

8232 else:

8233 raise NoViableAltException(self)

8234

8235 except RecognitionException as re:

8236 localctx.exception = re

8237 self._errHandler.reportError(self, re)

8238 self._errHandler.recover(self, re)

8239 finally:

8240 self.exitRule()

8241 return localctx

8242

8243

8244 class Query_continuationContext(ParserRuleContext):

8245 __slots__ = 'parser'

8246

8247 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

8248 super().__init__(parent, invokingState)

8249 self.parser = parser

8250

8251 def INTO(self):

8252 return self.getToken(CSharpParser.INTO, 0)

8253

8254 def identifier(self):

8255 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

8256

8257

8258 def query_body(self):

8259 return self.getTypedRuleContext(CSharpParser.Query_bodyContext,0)

8260

8261

8262 def getRuleIndex(self):

8263 return CSharpParser.RULE_query_continuation

8264

8265 def enterRule(self, listener:ParseTreeListener):

8266 if hasattr( listener, "enterQuery_continuation" ):

8267 listener.enterQuery_continuation(self)

8268

8269 def exitRule(self, listener:ParseTreeListener):

8270 if hasattr( listener, "exitQuery_continuation" ):

8271 listener.exitQuery_continuation(self)

8276 def query_continuation(self):

8277

8278 localctx = CSharpParser.Query_continuationContext(self, self._ctx, self.state)

8279 self.enterRule(localctx, 150, self.RULE_query_continuation)

8280 try:

8281 self.enterOuterAlt(localctx, 1)

8282 self.state = 1225

8283 self.match(CSharpParser.INTO)

8284 self.state = 1226

8285 self.identifier()

8286 self.state = 1227

8287 self.query_body()

8288 except RecognitionException as re:

8289 localctx.exception = re

8290 self._errHandler.reportError(self, re)

8291 self._errHandler.recover(self, re)

8292 finally:

8293 self.exitRule()

8294 return localctx

8295

8296

8297 class StatementContext(ParserRuleContext):

8298 __slots__ = 'parser'

8299

8300 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

8301 super().__init__(parent, invokingState)

8302 self.parser = parser

8303

8304 def labeled_Statement(self):

8305 return self.getTypedRuleContext(CSharpParser.Labeled_StatementContext,0)

8306

8307

8308 def declarationStatement(self):

8309 return self.getTypedRuleContext(CSharpParser.DeclarationStatementContext,0)

8310

8311

8312 def embedded_statement(self):

8313 return self.getTypedRuleContext(CSharpParser.Embedded_statementContext,0)

8314

8315

8316 def getRuleIndex(self):

8317 return CSharpParser.RULE_statement

8318

8319 def enterRule(self, listener:ParseTreeListener):

8320 if hasattr( listener, "enterStatement" ):

8321 listener.enterStatement(self)

8322

8323 def exitRule(self, listener:ParseTreeListener):

8324 if hasattr( listener, "exitStatement" ):

8325 listener.exitStatement(self)

8330 def statement(self):

8331

8332 localctx = CSharpParser.StatementContext(self, self._ctx, self.state)

8333 self.enterRule(localctx, 152, self.RULE_statement)

8334 try:

8335 self.state = 1232

8336 self._errHandler.sync(self)

8337 la_ = self._interp.adaptivePredict(self._input,121,self._ctx)

8338 if la_ == 1:

8339 self.enterOuterAlt(localctx, 1)

8340 self.state = 1229

8341 self.labeled_Statement()

8342 pass

8343

8344 elif la_ == 2:

8345 self.enterOuterAlt(localctx, 2)

8346 self.state = 1230

8347 self.declarationStatement()

8348 pass

8349

8350 elif la_ == 3:

8351 self.enterOuterAlt(localctx, 3)

8352 self.state = 1231

8353 self.embedded_statement()

8354 pass

8355

8356

8357 except RecognitionException as re:

8358 localctx.exception = re

8359 self._errHandler.reportError(self, re)

8360 self._errHandler.recover(self, re)

8361 finally:

8362 self.exitRule()

8363 return localctx

8364

8365

8366 class DeclarationStatementContext(ParserRuleContext):

8367 __slots__ = 'parser'

8368

8369 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

8370 super().__init__(parent, invokingState)

8371 self.parser = parser

8372

8373 def local_variable_declaration(self):

8374 return self.getTypedRuleContext(CSharpParser.Local_variable_declarationContext,0)

8375

8376

8377 def SEMICOLON(self):

8378 return self.getToken(CSharpParser.SEMICOLON, 0)

8379

8380 def local_constant_declaration(self):

8381 return self.getTypedRuleContext(CSharpParser.Local_constant_declarationContext,0)

8382

8383

8384 def local_function_declaration(self):

8385 return self.getTypedRuleContext(CSharpParser.Local_function_declarationContext,0)

8386

8387

8388 def getRuleIndex(self):

8389 return CSharpParser.RULE_declarationStatement

8390

8391 def enterRule(self, listener:ParseTreeListener):

8392 if hasattr( listener, "enterDeclarationStatement" ):

8393 listener.enterDeclarationStatement(self)

8394

8395 def exitRule(self, listener:ParseTreeListener):

8396 if hasattr( listener, "exitDeclarationStatement" ):

8397 listener.exitDeclarationStatement(self)

8402 def declarationStatement(self):

8403

8404 localctx = CSharpParser.DeclarationStatementContext(self, self._ctx, self.state)

8405 self.enterRule(localctx, 154, self.RULE_declarationStatement)

8406 try:

8407 self.state = 1241

8408 self._errHandler.sync(self)

8409 la_ = self._interp.adaptivePredict(self._input,122,self._ctx)

8410 if la_ == 1:

8411 self.enterOuterAlt(localctx, 1)

8412 self.state = 1234

8413 self.local_variable_declaration()

8414 self.state = 1235

8415 self.match(CSharpParser.SEMICOLON)

8416 pass

8417

8418 elif la_ == 2:

8419 self.enterOuterAlt(localctx, 2)

8420 self.state = 1237

8421 self.local_constant_declaration()

8422 self.state = 1238

8423 self.match(CSharpParser.SEMICOLON)

8424 pass

8425

8426 elif la_ == 3:

8427 self.enterOuterAlt(localctx, 3)

8428 self.state = 1240

8429 self.local_function_declaration()

8430 pass

8431

8432

8433 except RecognitionException as re:

8434 localctx.exception = re

8435 self._errHandler.reportError(self, re)

8436 self._errHandler.recover(self, re)

8437 finally:

8438 self.exitRule()

8439 return localctx

8440

8441

8442 class Local_function_declarationContext(ParserRuleContext):

8443 __slots__ = 'parser'

8444

8445 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

8446 super().__init__(parent, invokingState)

8447 self.parser = parser

8448

8449 def local_function_header(self):

8450 return self.getTypedRuleContext(CSharpParser.Local_function_headerContext,0)

8451

8452

8453 def local_function_body(self):

8454 return self.getTypedRuleContext(CSharpParser.Local_function_bodyContext,0)

8455

8456

8457 def getRuleIndex(self):

8458 return CSharpParser.RULE_local_function_declaration

8459

8460 def enterRule(self, listener:ParseTreeListener):

8461 if hasattr( listener, "enterLocal_function_declaration" ):

8462 listener.enterLocal_function_declaration(self)

8463

8464 def exitRule(self, listener:ParseTreeListener):

8465 if hasattr( listener, "exitLocal_function_declaration" ):

8466 listener.exitLocal_function_declaration(self)

8471 def local_function_declaration(self):

8472

8473 localctx = CSharpParser.Local_function_declarationContext(self, self._ctx, self.state)

8474 self.enterRule(localctx, 156, self.RULE_local_function_declaration)

8475 try:

8476 self.enterOuterAlt(localctx, 1)

8477 self.state = 1243

8478 self.local_function_header()

8479 self.state = 1244

8480 self.local_function_body()

8481 except RecognitionException as re:

8482 localctx.exception = re

8483 self._errHandler.reportError(self, re)

8484 self._errHandler.recover(self, re)

8485 finally:

8486 self.exitRule()

8487 return localctx

8488

8489

8490 class Local_function_headerContext(ParserRuleContext):

8491 __slots__ = 'parser'

8492

8493 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

8494 super().__init__(parent, invokingState)

8495 self.parser = parser

8496

8497 def return_type(self):

8498 return self.getTypedRuleContext(CSharpParser.Return_typeContext,0)

8499

8500

8501 def identifier(self):

8502 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

8503

8504

8505 def OPEN_PARENS(self):

8506 return self.getToken(CSharpParser.OPEN_PARENS, 0)

8507

8508 def CLOSE_PARENS(self):

8509 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

8510

8511 def local_function_modifiers(self):

8512 return self.getTypedRuleContext(CSharpParser.Local_function_modifiersContext,0)

8513

8514

8515 def type_parameter_list(self):

8516 return self.getTypedRuleContext(CSharpParser.Type_parameter_listContext,0)

8517

8518

8519 def formal_parameter_list(self):

8520 return self.getTypedRuleContext(CSharpParser.Formal_parameter_listContext,0)

8521

8522

8523 def type_parameter_constraints_clauses(self):

8524 return self.getTypedRuleContext(CSharpParser.Type_parameter_constraints_clausesContext,0)

8525

8526

8527 def getRuleIndex(self):

8528 return CSharpParser.RULE_local_function_header

8529

8530 def enterRule(self, listener:ParseTreeListener):

8531 if hasattr( listener, "enterLocal_function_header" ):

8532 listener.enterLocal_function_header(self)

8533

8534 def exitRule(self, listener:ParseTreeListener):

8535 if hasattr( listener, "exitLocal_function_header" ):

8536 listener.exitLocal_function_header(self)

8541 def local_function_header(self):

8542

8543 localctx = CSharpParser.Local_function_headerContext(self, self._ctx, self.state)

8544 self.enterRule(localctx, 158, self.RULE_local_function_header)

8545 self._la = 0 # Token type

8546 try:

8547 self.enterOuterAlt(localctx, 1)

8548 self.state = 1247

8549 self._errHandler.sync(self)

8550 la_ = self._interp.adaptivePredict(self._input,123,self._ctx)

8551 if la_ == 1:

8552 self.state = 1246

8553 self.local_function_modifiers()

8554

8555

8556 self.state = 1249

8557 self.return_type()

8558 self.state = 1250

8559 self.identifier()

8560 self.state = 1252

8561 self._errHandler.sync(self)

8562 _la = self._input.LA(1)

8563 if _la==CSharpParser.LT:

8564 self.state = 1251

8565 self.type_parameter_list()

8566

8567

8568 self.state = 1254

8569 self.match(CSharpParser.OPEN_PARENS)

8570 self.state = 1256

8571 self._errHandler.sync(self)

8572 _la = self._input.LA(1)

8574 self.state = 1255

8575 self.formal_parameter_list()

8576

8577

8578 self.state = 1258

8579 self.match(CSharpParser.CLOSE_PARENS)

8580 self.state = 1260

8581 self._errHandler.sync(self)

8582 _la = self._input.LA(1)

8583 if _la==CSharpParser.WHERE:

8584 self.state = 1259

8585 self.type_parameter_constraints_clauses()

8586

8587

8588 except RecognitionException as re:

8589 localctx.exception = re

8590 self._errHandler.reportError(self, re)

8591 self._errHandler.recover(self, re)

8592 finally:

8593 self.exitRule()

8594 return localctx

8595

8596

8597 class Local_function_modifiersContext(ParserRuleContext):

8598 __slots__ = 'parser'

8599

8600 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

8601 super().__init__(parent, invokingState)

8602 self.parser = parser

8603

8604 def ASYNC(self):

8605 return self.getToken(CSharpParser.ASYNC, 0)

8606

8607 def UNSAFE(self):

8608 return self.getToken(CSharpParser.UNSAFE, 0)

8609

8610 def STATIC(self):

8611 return self.getToken(CSharpParser.STATIC, 0)

8612

8613 def getRuleIndex(self):

8614 return CSharpParser.RULE_local_function_modifiers

8615

8616 def enterRule(self, listener:ParseTreeListener):

8617 if hasattr( listener, "enterLocal_function_modifiers" ):

8618 listener.enterLocal_function_modifiers(self)

8619

8620 def exitRule(self, listener:ParseTreeListener):

8621 if hasattr( listener, "exitLocal_function_modifiers" ):

8622 listener.exitLocal_function_modifiers(self)

8627 def local_function_modifiers(self):

8628

8629 localctx = CSharpParser.Local_function_modifiersContext(self, self._ctx, self.state)

8630 self.enterRule(localctx, 160, self.RULE_local_function_modifiers)

8631 self._la = 0 # Token type

8632 try:

8633 self.state = 1268

8634 self._errHandler.sync(self)

8635 token = self._input.LA(1)

8636 if token in [CSharpParser.ASYNC, CSharpParser.UNSAFE]:

8637 self.enterOuterAlt(localctx, 1)

8638 self.state = 1262

8639 _la = self._input.LA(1)

8640 if not(_la==CSharpParser.ASYNC or _la==CSharpParser.UNSAFE):

8641 self._errHandler.recoverInline(self)

8642 else:

8643 self._errHandler.reportMatch(self)

8644 self.consume()

8645 self.state = 1264

8646 self._errHandler.sync(self)

8647 _la = self._input.LA(1)

8648 if _la==CSharpParser.STATIC:

8649 self.state = 1263

8650 self.match(CSharpParser.STATIC)

8651

8652

8653 pass

8654 elif token in [CSharpParser.STATIC]:

8655 self.enterOuterAlt(localctx, 2)

8656 self.state = 1266

8657 self.match(CSharpParser.STATIC)

8658 self.state = 1267

8659 _la = self._input.LA(1)

8660 if not(_la==CSharpParser.ASYNC or _la==CSharpParser.UNSAFE):

8661 self._errHandler.recoverInline(self)

8662 else:

8663 self._errHandler.reportMatch(self)

8664 self.consume()

8665 pass

8666 else:

8667 raise NoViableAltException(self)

8668

8669 except RecognitionException as re:

8670 localctx.exception = re

8671 self._errHandler.reportError(self, re)

8672 self._errHandler.recover(self, re)

8673 finally:

8674 self.exitRule()

8675 return localctx

8676

8677

8678 class Local_function_bodyContext(ParserRuleContext):

8679 __slots__ = 'parser'

8680

8681 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

8682 super().__init__(parent, invokingState)

8683 self.parser = parser

8684

8685 def block(self):

8686 return self.getTypedRuleContext(CSharpParser.BlockContext,0)

8687

8688

8689 def right_arrow(self):

8690 return self.getTypedRuleContext(CSharpParser.Right_arrowContext,0)

8691

8692

8693 def throwable_expression(self):

8694 return self.getTypedRuleContext(CSharpParser.Throwable_expressionContext,0)

8695

8696

8697 def SEMICOLON(self):

8698 return self.getToken(CSharpParser.SEMICOLON, 0)

8699

8700 def getRuleIndex(self):

8701 return CSharpParser.RULE_local_function_body

8702

8703 def enterRule(self, listener:ParseTreeListener):

8704 if hasattr( listener, "enterLocal_function_body" ):

8705 listener.enterLocal_function_body(self)

8706

8707 def exitRule(self, listener:ParseTreeListener):

8708 if hasattr( listener, "exitLocal_function_body" ):

8709 listener.exitLocal_function_body(self)

8714 def local_function_body(self):

8715

8716 localctx = CSharpParser.Local_function_bodyContext(self, self._ctx, self.state)

8717 self.enterRule(localctx, 162, self.RULE_local_function_body)

8718 try:

8719 self.state = 1275

8720 self._errHandler.sync(self)

8721 token = self._input.LA(1)

8722 if token in [CSharpParser.OPEN_BRACE]:

8723 self.enterOuterAlt(localctx, 1)

8724 self.state = 1270

8725 self.block()

8726 pass

8727 elif token in [CSharpParser.ASSIGNMENT]:

8728 self.enterOuterAlt(localctx, 2)

8729 self.state = 1271

8730 self.right_arrow()

8731 self.state = 1272

8732 self.throwable_expression()

8733 self.state = 1273

8734 self.match(CSharpParser.SEMICOLON)

8735 pass

8736 else:

8737 raise NoViableAltException(self)

8738

8739 except RecognitionException as re:

8740 localctx.exception = re

8741 self._errHandler.reportError(self, re)

8742 self._errHandler.recover(self, re)

8743 finally:

8744 self.exitRule()

8745 return localctx

8746

8747

8748 class Labeled_StatementContext(ParserRuleContext):

8749 __slots__ = 'parser'

8750

8751 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

8752 super().__init__(parent, invokingState)

8753 self.parser = parser

8754

8755 def identifier(self):

8756 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

8757

8758

8759 def COLON(self):

8760 return self.getToken(CSharpParser.COLON, 0)

8761

8762 def statement(self):

8763 return self.getTypedRuleContext(CSharpParser.StatementContext,0)

8764

8765

8766 def getRuleIndex(self):

8767 return CSharpParser.RULE_labeled_Statement

8768

8769 def enterRule(self, listener:ParseTreeListener):

8770 if hasattr( listener, "enterLabeled_Statement" ):

8771 listener.enterLabeled_Statement(self)

8772

8773 def exitRule(self, listener:ParseTreeListener):

8774 if hasattr( listener, "exitLabeled_Statement" ):

8775 listener.exitLabeled_Statement(self)

8780 def labeled_Statement(self):

8781

8782 localctx = CSharpParser.Labeled_StatementContext(self, self._ctx, self.state)

8783 self.enterRule(localctx, 164, self.RULE_labeled_Statement)

8784 try:

8785 self.enterOuterAlt(localctx, 1)

8786 self.state = 1277

8787 self.identifier()

8788 self.state = 1278

8789 self.match(CSharpParser.COLON)

8790 self.state = 1279

8791 self.statement()

8792 except RecognitionException as re:

8793 localctx.exception = re

8794 self._errHandler.reportError(self, re)

8795 self._errHandler.recover(self, re)

8796 finally:

8797 self.exitRule()

8798 return localctx

8799

8800

8801 class Embedded_statementContext(ParserRuleContext):

8802 __slots__ = 'parser'

8803

8804 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

8805 super().__init__(parent, invokingState)

8806 self.parser = parser

8807

8808 def block(self):

8809 return self.getTypedRuleContext(CSharpParser.BlockContext,0)

8810

8811

8812 def simple_embedded_statement(self):

8813 return self.getTypedRuleContext(CSharpParser.Simple_embedded_statementContext,0)

8814

8815

8816 def getRuleIndex(self):

8817 return CSharpParser.RULE_embedded_statement

8818

8819 def enterRule(self, listener:ParseTreeListener):

8820 if hasattr( listener, "enterEmbedded_statement" ):

8821 listener.enterEmbedded_statement(self)

8822

8823 def exitRule(self, listener:ParseTreeListener):

8824 if hasattr( listener, "exitEmbedded_statement" ):

8825 listener.exitEmbedded_statement(self)

8830 def embedded_statement(self):

8831

8832 localctx = CSharpParser.Embedded_statementContext(self, self._ctx, self.state)

8833 self.enterRule(localctx, 166, self.RULE_embedded_statement)

8834 try:

8835 self.state = 1283

8836 self._errHandler.sync(self)

8837 token = self._input.LA(1)

8838 if token in [CSharpParser.OPEN_BRACE]:

8839 self.enterOuterAlt(localctx, 1)

8840 self.state = 1281

8841 self.block()

8842 pass

8843 elif token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BREAK, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.CONTINUE, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DO, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FIXED, CSharpParser.FLOAT, CSharpParser.FOR, CSharpParser.FOREACH, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GOTO, CSharpParser.GROUP, CSharpParser.IF, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LOCK, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.RETURN, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.SWITCH, CSharpParser.THIS, CSharpParser.THROW, CSharpParser.TRUE, CSharpParser.TRY, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.UNSAFE, CSharpParser.USHORT, CSharpParser.USING, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.WHILE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.SEMICOLON, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:

8844 self.enterOuterAlt(localctx, 2)

8845 self.state = 1282

8846 self.simple_embedded_statement()

8847 pass

8848 else:

8849 raise NoViableAltException(self)

8850

8851 except RecognitionException as re:

8852 localctx.exception = re

8853 self._errHandler.reportError(self, re)

8854 self._errHandler.recover(self, re)

8855 finally:

8856 self.exitRule()

8857 return localctx

8858

8859

8860 class Simple_embedded_statementContext(ParserRuleContext):

8861 __slots__ = 'parser'

8862

8863 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

8864 super().__init__(parent, invokingState)

8865 self.parser = parser

8866

8867

8868 def getRuleIndex(self):

8869 return CSharpParser.RULE_simple_embedded_statement

8870

8871

8872 def copyFrom(self, ctx:ParserRuleContext):

8873 super().copyFrom(ctx)

8874

8875

8876

8877 class TryStatementContext(Simple_embedded_statementContext):

8878

8879 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Simple_embedded_statementContext

8880 super().__init__(parser)

8881 self.copyFrom(ctx)

8882

8883 def TRY(self):

8884 return self.getToken(CSharpParser.TRY, 0)

8885 def block(self):

8886 return self.getTypedRuleContext(CSharpParser.BlockContext,0)

8887

8888 def catch_clauses(self):

8889 return self.getTypedRuleContext(CSharpParser.Catch_clausesContext,0)

8890

8891 def finally_clause(self):

8892 return self.getTypedRuleContext(CSharpParser.Finally_clauseContext,0)

8893

8894

8895 def enterRule(self, listener:ParseTreeListener):

8896 if hasattr( listener, "enterTryStatement" ):

8897 listener.enterTryStatement(self)

8898

8899 def exitRule(self, listener:ParseTreeListener):

8900 if hasattr( listener, "exitTryStatement" ):

8901 listener.exitTryStatement(self)

8902

8903

8904 class CheckedStatementContext(Simple_embedded_statementContext):

8905

8906 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Simple_embedded_statementContext

8907 super().__init__(parser)

8908 self.copyFrom(ctx)

8909

8910 def CHECKED(self):

8911 return self.getToken(CSharpParser.CHECKED, 0)

8912 def block(self):

8913 return self.getTypedRuleContext(CSharpParser.BlockContext,0)

8914

8915

8916 def enterRule(self, listener:ParseTreeListener):

8917 if hasattr( listener, "enterCheckedStatement" ):

8918 listener.enterCheckedStatement(self)

8919

8920 def exitRule(self, listener:ParseTreeListener):

8921 if hasattr( listener, "exitCheckedStatement" ):

8922 listener.exitCheckedStatement(self)

8923

8924

8925 class ThrowStatementContext(Simple_embedded_statementContext):

8926

8927 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Simple_embedded_statementContext

8928 super().__init__(parser)

8929 self.copyFrom(ctx)

8930

8931 def THROW(self):

8932 return self.getToken(CSharpParser.THROW, 0)

8933 def SEMICOLON(self):

8934 return self.getToken(CSharpParser.SEMICOLON, 0)

8935 def expression(self):

8936 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

8937

8938

8939 def enterRule(self, listener:ParseTreeListener):

8940 if hasattr( listener, "enterThrowStatement" ):

8941 listener.enterThrowStatement(self)

8942

8943 def exitRule(self, listener:ParseTreeListener):

8944 if hasattr( listener, "exitThrowStatement" ):

8945 listener.exitThrowStatement(self)

8946

8947

8948 class TheEmptyStatementContext(Simple_embedded_statementContext):

8949

8950 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Simple_embedded_statementContext

8951 super().__init__(parser)

8952 self.copyFrom(ctx)

8953

8954 def SEMICOLON(self):

8955 return self.getToken(CSharpParser.SEMICOLON, 0)

8956

8957 def enterRule(self, listener:ParseTreeListener):

8958 if hasattr( listener, "enterTheEmptyStatement" ):

8959 listener.enterTheEmptyStatement(self)

8960

8961 def exitRule(self, listener:ParseTreeListener):

8962 if hasattr( listener, "exitTheEmptyStatement" ):

8963 listener.exitTheEmptyStatement(self)

8964

8965

8966 class UnsafeStatementContext(Simple_embedded_statementContext):

8967

8968 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Simple_embedded_statementContext

8969 super().__init__(parser)

8970 self.copyFrom(ctx)

8971

8972 def UNSAFE(self):

8973 return self.getToken(CSharpParser.UNSAFE, 0)

8974 def block(self):

8975 return self.getTypedRuleContext(CSharpParser.BlockContext,0)

8976

8977

8978 def enterRule(self, listener:ParseTreeListener):

8979 if hasattr( listener, "enterUnsafeStatement" ):

8980 listener.enterUnsafeStatement(self)

8981

8982 def exitRule(self, listener:ParseTreeListener):

8983 if hasattr( listener, "exitUnsafeStatement" ):

8984 listener.exitUnsafeStatement(self)

8985

8986

8987 class ForStatementContext(Simple_embedded_statementContext):

8988

8989 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Simple_embedded_statementContext

8990 super().__init__(parser)

8991 self.copyFrom(ctx)

8992

8993 def FOR(self):

8994 return self.getToken(CSharpParser.FOR, 0)

8995 def OPEN_PARENS(self):

8996 return self.getToken(CSharpParser.OPEN_PARENS, 0)

8997 def SEMICOLON(self, i:int=None):

8998 if i is None:

8999 return self.getTokens(CSharpParser.SEMICOLON)

9000 else:

9001 return self.getToken(CSharpParser.SEMICOLON, i)

9002 def CLOSE_PARENS(self):

9003 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

9004 def embedded_statement(self):

9005 return self.getTypedRuleContext(CSharpParser.Embedded_statementContext,0)

9006

9007 def for_initializer(self):

9008 return self.getTypedRuleContext(CSharpParser.For_initializerContext,0)

9009

9010 def expression(self):

9011 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

9012

9013 def for_iterator(self):

9014 return self.getTypedRuleContext(CSharpParser.For_iteratorContext,0)

9015

9016

9017 def enterRule(self, listener:ParseTreeListener):

9018 if hasattr( listener, "enterForStatement" ):

9019 listener.enterForStatement(self)

9020

9021 def exitRule(self, listener:ParseTreeListener):

9022 if hasattr( listener, "exitForStatement" ):

9023 listener.exitForStatement(self)

9024

9025

9026 class BreakStatementContext(Simple_embedded_statementContext):

9027

9028 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Simple_embedded_statementContext

9029 super().__init__(parser)

9030 self.copyFrom(ctx)

9031

9032 def BREAK(self):

9033 return self.getToken(CSharpParser.BREAK, 0)

9034 def SEMICOLON(self):

9035 return self.getToken(CSharpParser.SEMICOLON, 0)

9036

9037 def enterRule(self, listener:ParseTreeListener):

9038 if hasattr( listener, "enterBreakStatement" ):

9039 listener.enterBreakStatement(self)

9040

9041 def exitRule(self, listener:ParseTreeListener):

9042 if hasattr( listener, "exitBreakStatement" ):

9043 listener.exitBreakStatement(self)

9044

9045

9046 class IfStatementContext(Simple_embedded_statementContext):

9047

9048 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Simple_embedded_statementContext

9049 super().__init__(parser)

9050 self.copyFrom(ctx)

9051

9052 def IF(self):

9053 return self.getToken(CSharpParser.IF, 0)

9054 def OPEN_PARENS(self):

9055 return self.getToken(CSharpParser.OPEN_PARENS, 0)

9056 def expression(self):

9057 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

9058

9059 def CLOSE_PARENS(self):

9060 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

9061 def if_body(self, i:int=None):

9062 if i is None:

9063 return self.getTypedRuleContexts(CSharpParser.If_bodyContext)

9064 else:

9065 return self.getTypedRuleContext(CSharpParser.If_bodyContext,i)

9066

9067 def ELSE(self):

9068 return self.getToken(CSharpParser.ELSE, 0)

9069

9070 def enterRule(self, listener:ParseTreeListener):

9071 if hasattr( listener, "enterIfStatement" ):

9072 listener.enterIfStatement(self)

9073

9074 def exitRule(self, listener:ParseTreeListener):

9075 if hasattr( listener, "exitIfStatement" ):

9076 listener.exitIfStatement(self)

9077

9078

9079 class ReturnStatementContext(Simple_embedded_statementContext):

9080

9081 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Simple_embedded_statementContext

9082 super().__init__(parser)

9083 self.copyFrom(ctx)

9084

9085 def RETURN(self):

9086 return self.getToken(CSharpParser.RETURN, 0)

9087 def SEMICOLON(self):

9088 return self.getToken(CSharpParser.SEMICOLON, 0)

9089 def expression(self):

9090 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

9091

9092

9093 def enterRule(self, listener:ParseTreeListener):

9094 if hasattr( listener, "enterReturnStatement" ):

9095 listener.enterReturnStatement(self)

9096

9097 def exitRule(self, listener:ParseTreeListener):

9098 if hasattr( listener, "exitReturnStatement" ):

9099 listener.exitReturnStatement(self)

9100

9101

9102 class GotoStatementContext(Simple_embedded_statementContext):

9103

9104 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Simple_embedded_statementContext

9105 super().__init__(parser)

9106 self.copyFrom(ctx)

9107

9108 def GOTO(self):

9109 return self.getToken(CSharpParser.GOTO, 0)

9110 def SEMICOLON(self):

9111 return self.getToken(CSharpParser.SEMICOLON, 0)

9112 def identifier(self):

9113 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

9114

9115 def CASE(self):

9116 return self.getToken(CSharpParser.CASE, 0)

9117 def expression(self):

9118 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

9119

9120 def DEFAULT(self):

9121 return self.getToken(CSharpParser.DEFAULT, 0)

9122

9123 def enterRule(self, listener:ParseTreeListener):

9124 if hasattr( listener, "enterGotoStatement" ):

9125 listener.enterGotoStatement(self)

9126

9127 def exitRule(self, listener:ParseTreeListener):

9128 if hasattr( listener, "exitGotoStatement" ):

9129 listener.exitGotoStatement(self)

9130

9131

9132 class SwitchStatementContext(Simple_embedded_statementContext):

9133

9134 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Simple_embedded_statementContext

9135 super().__init__(parser)

9136 self.copyFrom(ctx)

9137

9138 def SWITCH(self):

9139 return self.getToken(CSharpParser.SWITCH, 0)

9140 def OPEN_PARENS(self):

9141 return self.getToken(CSharpParser.OPEN_PARENS, 0)

9142 def expression(self):

9143 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

9144

9145 def CLOSE_PARENS(self):

9146 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

9147 def OPEN_BRACE(self):

9148 return self.getToken(CSharpParser.OPEN_BRACE, 0)

9149 def CLOSE_BRACE(self):

9150 return self.getToken(CSharpParser.CLOSE_BRACE, 0)

9151 def switch_section(self, i:int=None):

9152 if i is None:

9153 return self.getTypedRuleContexts(CSharpParser.Switch_sectionContext)

9154 else:

9155 return self.getTypedRuleContext(CSharpParser.Switch_sectionContext,i)

9156

9157

9158 def enterRule(self, listener:ParseTreeListener):

9159 if hasattr( listener, "enterSwitchStatement" ):

9160 listener.enterSwitchStatement(self)

9161

9162 def exitRule(self, listener:ParseTreeListener):

9163 if hasattr( listener, "exitSwitchStatement" ):

9164 listener.exitSwitchStatement(self)

9165

9166

9167 class FixedStatementContext(Simple_embedded_statementContext):

9168

9169 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Simple_embedded_statementContext

9170 super().__init__(parser)

9171 self.copyFrom(ctx)

9172

9173 def FIXED(self):

9174 return self.getToken(CSharpParser.FIXED, 0)

9175 def OPEN_PARENS(self):

9176 return self.getToken(CSharpParser.OPEN_PARENS, 0)

9177 def pointer_type(self):

9178 return self.getTypedRuleContext(CSharpParser.Pointer_typeContext,0)

9179

9180 def fixed_pointer_declarators(self):

9181 return self.getTypedRuleContext(CSharpParser.Fixed_pointer_declaratorsContext,0)

9182

9183 def CLOSE_PARENS(self):

9184 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

9185 def embedded_statement(self):

9186 return self.getTypedRuleContext(CSharpParser.Embedded_statementContext,0)

9187

9188

9189 def enterRule(self, listener:ParseTreeListener):

9190 if hasattr( listener, "enterFixedStatement" ):

9191 listener.enterFixedStatement(self)

9192

9193 def exitRule(self, listener:ParseTreeListener):

9194 if hasattr( listener, "exitFixedStatement" ):

9195 listener.exitFixedStatement(self)

9196

9197

9198 class WhileStatementContext(Simple_embedded_statementContext):

9199

9200 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Simple_embedded_statementContext

9201 super().__init__(parser)

9202 self.copyFrom(ctx)

9203

9204 def WHILE(self):

9205 return self.getToken(CSharpParser.WHILE, 0)

9206 def OPEN_PARENS(self):

9207 return self.getToken(CSharpParser.OPEN_PARENS, 0)

9208 def expression(self):

9209 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

9210

9211 def CLOSE_PARENS(self):

9212 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

9213 def embedded_statement(self):

9214 return self.getTypedRuleContext(CSharpParser.Embedded_statementContext,0)

9215

9216

9217 def enterRule(self, listener:ParseTreeListener):

9218 if hasattr( listener, "enterWhileStatement" ):

9219 listener.enterWhileStatement(self)

9220

9221 def exitRule(self, listener:ParseTreeListener):

9222 if hasattr( listener, "exitWhileStatement" ):

9223 listener.exitWhileStatement(self)

9224

9225

9226 class DoStatementContext(Simple_embedded_statementContext):

9227

9228 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Simple_embedded_statementContext

9229 super().__init__(parser)

9230 self.copyFrom(ctx)

9231

9232 def DO(self):

9233 return self.getToken(CSharpParser.DO, 0)

9234 def embedded_statement(self):

9235 return self.getTypedRuleContext(CSharpParser.Embedded_statementContext,0)

9236

9237 def WHILE(self):

9238 return self.getToken(CSharpParser.WHILE, 0)

9239 def OPEN_PARENS(self):

9240 return self.getToken(CSharpParser.OPEN_PARENS, 0)

9241 def expression(self):

9242 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

9243

9244 def CLOSE_PARENS(self):

9245 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

9246 def SEMICOLON(self):

9247 return self.getToken(CSharpParser.SEMICOLON, 0)

9248

9249 def enterRule(self, listener:ParseTreeListener):

9250 if hasattr( listener, "enterDoStatement" ):

9251 listener.enterDoStatement(self)

9252

9253 def exitRule(self, listener:ParseTreeListener):

9254 if hasattr( listener, "exitDoStatement" ):

9255 listener.exitDoStatement(self)

9256

9257

9258 class ForeachStatementContext(Simple_embedded_statementContext):

9259

9260 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Simple_embedded_statementContext

9261 super().__init__(parser)

9262 self.copyFrom(ctx)

9263

9264 def FOREACH(self):

9265 return self.getToken(CSharpParser.FOREACH, 0)

9266 def OPEN_PARENS(self):

9267 return self.getToken(CSharpParser.OPEN_PARENS, 0)

9268 def local_variable_type(self):

9269 return self.getTypedRuleContext(CSharpParser.Local_variable_typeContext,0)

9270

9271 def identifier(self):

9272 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

9273

9274 def IN(self):

9275 return self.getToken(CSharpParser.IN, 0)

9276 def expression(self):

9277 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

9278

9279 def CLOSE_PARENS(self):

9280 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

9281 def embedded_statement(self):

9282 return self.getTypedRuleContext(CSharpParser.Embedded_statementContext,0)

9283

9284 def AWAIT(self):

9285 return self.getToken(CSharpParser.AWAIT, 0)

9286

9287 def enterRule(self, listener:ParseTreeListener):

9288 if hasattr( listener, "enterForeachStatement" ):

9289 listener.enterForeachStatement(self)

9290

9291 def exitRule(self, listener:ParseTreeListener):

9292 if hasattr( listener, "exitForeachStatement" ):

9293 listener.exitForeachStatement(self)

9294

9295

9296 class UncheckedStatementContext(Simple_embedded_statementContext):

9297

9298 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Simple_embedded_statementContext

9299 super().__init__(parser)

9300 self.copyFrom(ctx)

9301

9302 def UNCHECKED(self):

9303 return self.getToken(CSharpParser.UNCHECKED, 0)

9304 def block(self):

9305 return self.getTypedRuleContext(CSharpParser.BlockContext,0)

9306

9307

9308 def enterRule(self, listener:ParseTreeListener):

9309 if hasattr( listener, "enterUncheckedStatement" ):

9310 listener.enterUncheckedStatement(self)

9311

9312 def exitRule(self, listener:ParseTreeListener):

9313 if hasattr( listener, "exitUncheckedStatement" ):

9314 listener.exitUncheckedStatement(self)

9315

9316

9317 class ExpressionStatementContext(Simple_embedded_statementContext):

9318

9319 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Simple_embedded_statementContext

9320 super().__init__(parser)

9321 self.copyFrom(ctx)

9322

9323 def expression(self):

9324 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

9325

9326 def SEMICOLON(self):

9327 return self.getToken(CSharpParser.SEMICOLON, 0)

9328

9329 def enterRule(self, listener:ParseTreeListener):

9330 if hasattr( listener, "enterExpressionStatement" ):

9331 listener.enterExpressionStatement(self)

9332

9333 def exitRule(self, listener:ParseTreeListener):

9334 if hasattr( listener, "exitExpressionStatement" ):

9335 listener.exitExpressionStatement(self)

9336

9337

9338 class ContinueStatementContext(Simple_embedded_statementContext):

9339

9340 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Simple_embedded_statementContext

9341 super().__init__(parser)

9342 self.copyFrom(ctx)

9343

9344 def CONTINUE(self):

9345 return self.getToken(CSharpParser.CONTINUE, 0)

9346 def SEMICOLON(self):

9347 return self.getToken(CSharpParser.SEMICOLON, 0)

9348

9349 def enterRule(self, listener:ParseTreeListener):

9350 if hasattr( listener, "enterContinueStatement" ):

9351 listener.enterContinueStatement(self)

9352

9353 def exitRule(self, listener:ParseTreeListener):

9354 if hasattr( listener, "exitContinueStatement" ):

9355 listener.exitContinueStatement(self)

9356

9357

9358 class UsingStatementContext(Simple_embedded_statementContext):

9359

9360 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Simple_embedded_statementContext

9361 super().__init__(parser)

9362 self.copyFrom(ctx)

9363

9364 def USING(self):

9365 return self.getToken(CSharpParser.USING, 0)

9366 def OPEN_PARENS(self):

9367 return self.getToken(CSharpParser.OPEN_PARENS, 0)

9368 def resource_acquisition(self):

9369 return self.getTypedRuleContext(CSharpParser.Resource_acquisitionContext,0)

9370

9371 def CLOSE_PARENS(self):

9372 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

9373 def embedded_statement(self):

9374 return self.getTypedRuleContext(CSharpParser.Embedded_statementContext,0)

9375

9376

9377 def enterRule(self, listener:ParseTreeListener):

9378 if hasattr( listener, "enterUsingStatement" ):

9379 listener.enterUsingStatement(self)

9380

9381 def exitRule(self, listener:ParseTreeListener):

9382 if hasattr( listener, "exitUsingStatement" ):

9383 listener.exitUsingStatement(self)

9384

9385

9386 class LockStatementContext(Simple_embedded_statementContext):

9387

9388 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Simple_embedded_statementContext

9389 super().__init__(parser)

9390 self.copyFrom(ctx)

9391

9392 def LOCK(self):

9393 return self.getToken(CSharpParser.LOCK, 0)

9394 def OPEN_PARENS(self):

9395 return self.getToken(CSharpParser.OPEN_PARENS, 0)

9396 def expression(self):

9397 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

9398

9399 def CLOSE_PARENS(self):

9400 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

9401 def embedded_statement(self):

9402 return self.getTypedRuleContext(CSharpParser.Embedded_statementContext,0)

9403

9404

9405 def enterRule(self, listener:ParseTreeListener):

9406 if hasattr( listener, "enterLockStatement" ):

9407 listener.enterLockStatement(self)

9408

9409 def exitRule(self, listener:ParseTreeListener):

9410 if hasattr( listener, "exitLockStatement" ):

9411 listener.exitLockStatement(self)

9412

9413

9414 class YieldStatementContext(Simple_embedded_statementContext):

9415

9416 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Simple_embedded_statementContext

9417 super().__init__(parser)

9418 self.copyFrom(ctx)

9419

9420 def YIELD(self):

9421 return self.getToken(CSharpParser.YIELD, 0)

9422 def SEMICOLON(self):

9423 return self.getToken(CSharpParser.SEMICOLON, 0)

9424 def RETURN(self):

9425 return self.getToken(CSharpParser.RETURN, 0)

9426 def expression(self):

9427 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

9428

9429 def BREAK(self):

9430 return self.getToken(CSharpParser.BREAK, 0)

9431

9432 def enterRule(self, listener:ParseTreeListener):

9433 if hasattr( listener, "enterYieldStatement" ):

9434 listener.enterYieldStatement(self)

9435

9436 def exitRule(self, listener:ParseTreeListener):

9437 if hasattr( listener, "exitYieldStatement" ):

9438 listener.exitYieldStatement(self)

9439

9440

9441

9442 def simple_embedded_statement(self):

9443

9444 localctx = CSharpParser.Simple_embedded_statementContext(self, self._ctx, self.state)

9445 self.enterRule(localctx, 168, self.RULE_simple_embedded_statement)

9446 self._la = 0 # Token type

9447 try:

9448 self.state = 1415

9449 self._errHandler.sync(self)

9450 la_ = self._interp.adaptivePredict(self._input,143,self._ctx)

9451 if la_ == 1:

9452 localctx = CSharpParser.TheEmptyStatementContext(self, localctx)

9453 self.enterOuterAlt(localctx, 1)

9454 self.state = 1285

9455 self.match(CSharpParser.SEMICOLON)

9456 pass

9457

9458 elif la_ == 2:

9459 localctx = CSharpParser.ExpressionStatementContext(self, localctx)

9460 self.enterOuterAlt(localctx, 2)

9461 self.state = 1286

9462 self.expression()

9463 self.state = 1287

9464 self.match(CSharpParser.SEMICOLON)

9465 pass

9466

9467 elif la_ == 3:

9468 localctx = CSharpParser.IfStatementContext(self, localctx)

9469 self.enterOuterAlt(localctx, 3)

9470 self.state = 1289

9471 self.match(CSharpParser.IF)

9472 self.state = 1290

9473 self.match(CSharpParser.OPEN_PARENS)

9474 self.state = 1291

9475 self.expression()

9476 self.state = 1292

9477 self.match(CSharpParser.CLOSE_PARENS)

9478 self.state = 1293

9479 self.if_body()

9480 self.state = 1296

9481 self._errHandler.sync(self)

9482 la_ = self._interp.adaptivePredict(self._input,131,self._ctx)

9483 if la_ == 1:

9484 self.state = 1294

9485 self.match(CSharpParser.ELSE)

9486 self.state = 1295

9487 self.if_body()

9488

9489

9490 pass

9491

9492 elif la_ == 4:

9493 localctx = CSharpParser.SwitchStatementContext(self, localctx)

9494 self.enterOuterAlt(localctx, 4)

9495 self.state = 1298

9496 self.match(CSharpParser.SWITCH)

9497 self.state = 1299

9498 self.match(CSharpParser.OPEN_PARENS)

9499 self.state = 1300

9500 self.expression()

9501 self.state = 1301

9502 self.match(CSharpParser.CLOSE_PARENS)

9503 self.state = 1302

9504 self.match(CSharpParser.OPEN_BRACE)

9505 self.state = 1306

9506 self._errHandler.sync(self)

9507 _la = self._input.LA(1)

9508 while _la==CSharpParser.CASE or _la==CSharpParser.DEFAULT:

9509 self.state = 1303

9510 self.switch_section()

9511 self.state = 1308

9512 self._errHandler.sync(self)

9513 _la = self._input.LA(1)

9514

9515 self.state = 1309

9516 self.match(CSharpParser.CLOSE_BRACE)

9517 pass

9518

9519 elif la_ == 5:

9520 localctx = CSharpParser.WhileStatementContext(self, localctx)

9521 self.enterOuterAlt(localctx, 5)

9522 self.state = 1311

9523 self.match(CSharpParser.WHILE)

9524 self.state = 1312

9525 self.match(CSharpParser.OPEN_PARENS)

9526 self.state = 1313

9527 self.expression()

9528 self.state = 1314

9529 self.match(CSharpParser.CLOSE_PARENS)

9530 self.state = 1315

9531 self.embedded_statement()

9532 pass

9533

9534 elif la_ == 6:

9535 localctx = CSharpParser.DoStatementContext(self, localctx)

9536 self.enterOuterAlt(localctx, 6)

9537 self.state = 1317

9538 self.match(CSharpParser.DO)

9539 self.state = 1318

9540 self.embedded_statement()

9541 self.state = 1319

9542 self.match(CSharpParser.WHILE)

9543 self.state = 1320

9544 self.match(CSharpParser.OPEN_PARENS)

9545 self.state = 1321

9546 self.expression()

9547 self.state = 1322

9548 self.match(CSharpParser.CLOSE_PARENS)

9549 self.state = 1323

9550 self.match(CSharpParser.SEMICOLON)

9551 pass

9552

9553 elif la_ == 7:

9554 localctx = CSharpParser.ForStatementContext(self, localctx)

9555 self.enterOuterAlt(localctx, 7)

9556 self.state = 1325

9557 self.match(CSharpParser.FOR)

9558 self.state = 1326

9559 self.match(CSharpParser.OPEN_PARENS)

9560 self.state = 1328

9561 self._errHandler.sync(self)

9562 _la = self._input.LA(1)

9564 self.state = 1327

9565 self.for_initializer()

9566

9567

9568 self.state = 1330

9569 self.match(CSharpParser.SEMICOLON)

9570 self.state = 1332

9571 self._errHandler.sync(self)

9572 _la = self._input.LA(1)

9574 self.state = 1331

9575 self.expression()

9576

9577

9578 self.state = 1334

9579 self.match(CSharpParser.SEMICOLON)

9580 self.state = 1336

9581 self._errHandler.sync(self)

9582 _la = self._input.LA(1)

9584 self.state = 1335

9585 self.for_iterator()

9586

9587

9588 self.state = 1338

9589 self.match(CSharpParser.CLOSE_PARENS)

9590 self.state = 1339

9591 self.embedded_statement()

9592 pass

9593

9594 elif la_ == 8:

9595 localctx = CSharpParser.ForeachStatementContext(self, localctx)

9596 self.enterOuterAlt(localctx, 8)

9597 self.state = 1341

9598 self._errHandler.sync(self)

9599 _la = self._input.LA(1)

9600 if _la==CSharpParser.AWAIT:

9601 self.state = 1340

9602 self.match(CSharpParser.AWAIT)

9603

9604

9605 self.state = 1343

9606 self.match(CSharpParser.FOREACH)

9607 self.state = 1344

9608 self.match(CSharpParser.OPEN_PARENS)

9609 self.state = 1345

9610 self.local_variable_type()

9611 self.state = 1346

9612 self.identifier()

9613 self.state = 1347

9614 self.match(CSharpParser.IN)

9615 self.state = 1348

9616 self.expression()

9617 self.state = 1349

9618 self.match(CSharpParser.CLOSE_PARENS)

9619 self.state = 1350

9620 self.embedded_statement()

9621 pass

9622

9623 elif la_ == 9:

9624 localctx = CSharpParser.BreakStatementContext(self, localctx)

9625 self.enterOuterAlt(localctx, 9)

9626 self.state = 1352

9627 self.match(CSharpParser.BREAK)

9628 self.state = 1353

9629 self.match(CSharpParser.SEMICOLON)

9630 pass

9631

9632 elif la_ == 10:

9633 localctx = CSharpParser.ContinueStatementContext(self, localctx)

9634 self.enterOuterAlt(localctx, 10)

9635 self.state = 1354

9636 self.match(CSharpParser.CONTINUE)

9637 self.state = 1355

9638 self.match(CSharpParser.SEMICOLON)

9639 pass

9640

9641 elif la_ == 11:

9642 localctx = CSharpParser.GotoStatementContext(self, localctx)

9643 self.enterOuterAlt(localctx, 11)

9644 self.state = 1356

9645 self.match(CSharpParser.GOTO)

9646 self.state = 1361

9647 self._errHandler.sync(self)

9648 token = self._input.LA(1)

9649 if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BY, CSharpParser.DESCENDING, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.NAMEOF, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.UNMANAGED, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER]:

9650 self.state = 1357

9651 self.identifier()

9652 pass

9653 elif token in [CSharpParser.CASE]:

9654 self.state = 1358

9655 self.match(CSharpParser.CASE)

9656 self.state = 1359

9657 self.expression()

9658 pass

9659 elif token in [CSharpParser.DEFAULT]:

9660 self.state = 1360

9661 self.match(CSharpParser.DEFAULT)

9662 pass

9663 else:

9664 raise NoViableAltException(self)

9665

9666 self.state = 1363

9667 self.match(CSharpParser.SEMICOLON)

9668 pass

9669

9670 elif la_ == 12:

9671 localctx = CSharpParser.ReturnStatementContext(self, localctx)

9672 self.enterOuterAlt(localctx, 12)

9673 self.state = 1364

9674 self.match(CSharpParser.RETURN)

9675 self.state = 1366

9676 self._errHandler.sync(self)

9677 _la = self._input.LA(1)

9679 self.state = 1365

9680 self.expression()

9681

9682

9683 self.state = 1368

9684 self.match(CSharpParser.SEMICOLON)

9685 pass

9686

9687 elif la_ == 13:

9688 localctx = CSharpParser.ThrowStatementContext(self, localctx)

9689 self.enterOuterAlt(localctx, 13)

9690 self.state = 1369

9691 self.match(CSharpParser.THROW)

9692 self.state = 1371

9693 self._errHandler.sync(self)

9694 _la = self._input.LA(1)

9696 self.state = 1370

9697 self.expression()

9698

9699

9700 self.state = 1373

9701 self.match(CSharpParser.SEMICOLON)

9702 pass

9703

9704 elif la_ == 14:

9705 localctx = CSharpParser.TryStatementContext(self, localctx)

9706 self.enterOuterAlt(localctx, 14)

9707 self.state = 1374

9708 self.match(CSharpParser.TRY)

9709 self.state = 1375

9710 self.block()

9711 self.state = 1381

9712 self._errHandler.sync(self)

9713 token = self._input.LA(1)

9714 if token in [CSharpParser.CATCH]:

9715 self.state = 1376

9716 self.catch_clauses()

9717 self.state = 1378

9718 self._errHandler.sync(self)

9719 _la = self._input.LA(1)

9720 if _la==CSharpParser.FINALLY:

9721 self.state = 1377

9722 self.finally_clause()

9723

9724

9725 pass

9726 elif token in [CSharpParser.FINALLY]:

9727 self.state = 1380

9728 self.finally_clause()

9729 pass

9730 else:

9731 raise NoViableAltException(self)

9732

9733 pass

9734

9735 elif la_ == 15:

9736 localctx = CSharpParser.CheckedStatementContext(self, localctx)

9737 self.enterOuterAlt(localctx, 15)

9738 self.state = 1383

9739 self.match(CSharpParser.CHECKED)

9740 self.state = 1384

9741 self.block()

9742 pass

9743

9744 elif la_ == 16:

9745 localctx = CSharpParser.UncheckedStatementContext(self, localctx)

9746 self.enterOuterAlt(localctx, 16)

9747 self.state = 1385

9748 self.match(CSharpParser.UNCHECKED)

9749 self.state = 1386

9750 self.block()

9751 pass

9752

9753 elif la_ == 17:

9754 localctx = CSharpParser.LockStatementContext(self, localctx)

9755 self.enterOuterAlt(localctx, 17)

9756 self.state = 1387

9757 self.match(CSharpParser.LOCK)

9758 self.state = 1388

9759 self.match(CSharpParser.OPEN_PARENS)

9760 self.state = 1389

9761 self.expression()

9762 self.state = 1390

9763 self.match(CSharpParser.CLOSE_PARENS)

9764 self.state = 1391

9765 self.embedded_statement()

9766 pass

9767

9768 elif la_ == 18:

9769 localctx = CSharpParser.UsingStatementContext(self, localctx)

9770 self.enterOuterAlt(localctx, 18)

9771 self.state = 1393

9772 self.match(CSharpParser.USING)

9773 self.state = 1394

9774 self.match(CSharpParser.OPEN_PARENS)

9775 self.state = 1395

9776 self.resource_acquisition()

9777 self.state = 1396

9778 self.match(CSharpParser.CLOSE_PARENS)

9779 self.state = 1397

9780 self.embedded_statement()

9781 pass

9782

9783 elif la_ == 19:

9784 localctx = CSharpParser.YieldStatementContext(self, localctx)

9785 self.enterOuterAlt(localctx, 19)

9786 self.state = 1399

9787 self.match(CSharpParser.YIELD)

9788 self.state = 1403

9789 self._errHandler.sync(self)

9790 token = self._input.LA(1)

9791 if token in [CSharpParser.RETURN]:

9792 self.state = 1400

9793 self.match(CSharpParser.RETURN)

9794 self.state = 1401

9795 self.expression()

9796 pass

9797 elif token in [CSharpParser.BREAK]:

9798 self.state = 1402

9799 self.match(CSharpParser.BREAK)

9800 pass

9801 else:

9802 raise NoViableAltException(self)

9803

9804 self.state = 1405

9805 self.match(CSharpParser.SEMICOLON)

9806 pass

9807

9808 elif la_ == 20:

9809 localctx = CSharpParser.UnsafeStatementContext(self, localctx)

9810 self.enterOuterAlt(localctx, 20)

9811 self.state = 1406

9812 self.match(CSharpParser.UNSAFE)

9813 self.state = 1407

9814 self.block()

9815 pass

9816

9817 elif la_ == 21:

9818 localctx = CSharpParser.FixedStatementContext(self, localctx)

9819 self.enterOuterAlt(localctx, 21)

9820 self.state = 1408

9821 self.match(CSharpParser.FIXED)

9822 self.state = 1409

9823 self.match(CSharpParser.OPEN_PARENS)

9824 self.state = 1410

9825 self.pointer_type()

9826 self.state = 1411

9827 self.fixed_pointer_declarators()

9828 self.state = 1412

9829 self.match(CSharpParser.CLOSE_PARENS)

9830 self.state = 1413

9831 self.embedded_statement()

9832 pass

9833

9834

9835 except RecognitionException as re:

9836 localctx.exception = re

9837 self._errHandler.reportError(self, re)

9838 self._errHandler.recover(self, re)

9839 finally:

9840 self.exitRule()

9841 return localctx

9842

9843

9844 class BlockContext(ParserRuleContext):

9845 __slots__ = 'parser'

9846

9847 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

9848 super().__init__(parent, invokingState)

9849 self.parser = parser

9850

9851 def OPEN_BRACE(self):

9852 return self.getToken(CSharpParser.OPEN_BRACE, 0)

9853

9854 def CLOSE_BRACE(self):

9855 return self.getToken(CSharpParser.CLOSE_BRACE, 0)

9856

9857 def statement_list(self):

9858 return self.getTypedRuleContext(CSharpParser.Statement_listContext,0)

9859

9860

9861 def getRuleIndex(self):

9862 return CSharpParser.RULE_block

9863

9864 def enterRule(self, listener:ParseTreeListener):

9865 if hasattr( listener, "enterBlock" ):

9866 listener.enterBlock(self)

9867

9868 def exitRule(self, listener:ParseTreeListener):

9869 if hasattr( listener, "exitBlock" ):

9870 listener.exitBlock(self)

9875 def block(self):

9876

9877 localctx = CSharpParser.BlockContext(self, self._ctx, self.state)

9878 self.enterRule(localctx, 170, self.RULE_block)

9879 self._la = 0 # Token type

9880 try:

9881 self.enterOuterAlt(localctx, 1)

9882 self.state = 1417

9883 self.match(CSharpParser.OPEN_BRACE)

9884 self.state = 1419

9885 self._errHandler.sync(self)

9886 _la = self._input.LA(1)

9888 self.state = 1418

9889 self.statement_list()

9890

9891

9892 self.state = 1421

9893 self.match(CSharpParser.CLOSE_BRACE)

9894 except RecognitionException as re:

9895 localctx.exception = re

9896 self._errHandler.reportError(self, re)

9897 self._errHandler.recover(self, re)

9898 finally:

9899 self.exitRule()

9900 return localctx

9901

9902

9903 class Local_variable_declarationContext(ParserRuleContext):

9904 __slots__ = 'parser'

9905

9906 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

9907 super().__init__(parent, invokingState)

9908 self.parser = parser

9909

9910 def local_variable_type(self):

9911 return self.getTypedRuleContext(CSharpParser.Local_variable_typeContext,0)

9912

9913

9914 def local_variable_declarator(self, i:int=None):

9915 if i is None:

9916 return self.getTypedRuleContexts(CSharpParser.Local_variable_declaratorContext)

9917 else:

9918 return self.getTypedRuleContext(CSharpParser.Local_variable_declaratorContext,i)

9919

9920

9921 def USING(self):

9922 return self.getToken(CSharpParser.USING, 0)

9923

9924 def REF(self):

9925 return self.getToken(CSharpParser.REF, 0)

9926

9927 def READONLY(self):

9928 return self.getToken(CSharpParser.READONLY, 0)

9929

9930 def COMMA(self, i:int=None):

9931 if i is None:

9932 return self.getTokens(CSharpParser.COMMA)

9933 else:

9934 return self.getToken(CSharpParser.COMMA, i)

9935

9936 def FIXED(self):

9937 return self.getToken(CSharpParser.FIXED, 0)

9938

9939 def pointer_type(self):

9940 return self.getTypedRuleContext(CSharpParser.Pointer_typeContext,0)

9941

9942

9943 def fixed_pointer_declarators(self):

9944 return self.getTypedRuleContext(CSharpParser.Fixed_pointer_declaratorsContext,0)

9945

9946

9947 def getRuleIndex(self):

9948 return CSharpParser.RULE_local_variable_declaration

9949

9950 def enterRule(self, listener:ParseTreeListener):

9951 if hasattr( listener, "enterLocal_variable_declaration" ):

9952 listener.enterLocal_variable_declaration(self)

9953

9954 def exitRule(self, listener:ParseTreeListener):

9955 if hasattr( listener, "exitLocal_variable_declaration" ):

9956 listener.exitLocal_variable_declaration(self)

9961 def local_variable_declaration(self):

9962

9963 localctx = CSharpParser.Local_variable_declarationContext(self, self._ctx, self.state)

9964 self.enterRule(localctx, 172, self.RULE_local_variable_declaration)

9965 self._la = 0 # Token type

9966 try:

9967 self.state = 1444

9968 self._errHandler.sync(self)

9969 token = self._input.LA(1)

9970 if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.DECIMAL, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.STRING, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.USING, CSharpParser.VAR, CSharpParser.VOID, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.OPEN_PARENS]:

9971 self.enterOuterAlt(localctx, 1)

9972 self.state = 1427

9973 self._errHandler.sync(self)

9974 la_ = self._interp.adaptivePredict(self._input,145,self._ctx)

9975 if la_ == 1:

9976 self.state = 1423

9977 self.match(CSharpParser.USING)

9978

9979 elif la_ == 2:

9980 self.state = 1424

9981 self.match(CSharpParser.REF)

9982

9983 elif la_ == 3:

9984 self.state = 1425

9985 self.match(CSharpParser.REF)

9986 self.state = 1426

9987 self.match(CSharpParser.READONLY)

9988

9989

9990 self.state = 1429

9991 self.local_variable_type()

9992 self.state = 1430

9993 self.local_variable_declarator()

9994 self.state = 1437

9995 self._errHandler.sync(self)

9996 _la = self._input.LA(1)

9997 while _la==CSharpParser.COMMA:

9998 self.state = 1431

9999 self.match(CSharpParser.COMMA)

10000 self.state = 1432

10001 self.local_variable_declarator()

10002 self.state = 1433

10003 if not this.IsLocalVariableDeclaration() :

10004 from antlr4.error.Errors import FailedPredicateException

10005 raise FailedPredicateException(self, " this.IsLocalVariableDeclaration() ")

10006 self.state = 1439

10007 self._errHandler.sync(self)

10008 _la = self._input.LA(1)

10009

10010 pass

10011 elif token in [CSharpParser.FIXED]:

10012 self.enterOuterAlt(localctx, 2)

10013 self.state = 1440

10014 self.match(CSharpParser.FIXED)

10015 self.state = 1441

10016 self.pointer_type()

10017 self.state = 1442

10018 self.fixed_pointer_declarators()

10019 pass

10020 else:

10021 raise NoViableAltException(self)

10022

10023 except RecognitionException as re:

10024 localctx.exception = re

10025 self._errHandler.reportError(self, re)

10026 self._errHandler.recover(self, re)

10027 finally:

10028 self.exitRule()

10029 return localctx

10030

10031

10032 class Local_variable_typeContext(ParserRuleContext):

10033 __slots__ = 'parser'

10034

10035 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

10036 super().__init__(parent, invokingState)

10037 self.parser = parser

10038

10039 def VAR(self):

10040 return self.getToken(CSharpParser.VAR, 0)

10041

10042 def type_(self):

10043 return self.getTypedRuleContext(CSharpParser.Type_Context,0)

10044

10045

10046 def getRuleIndex(self):

10047 return CSharpParser.RULE_local_variable_type

10048

10049 def enterRule(self, listener:ParseTreeListener):

10050 if hasattr( listener, "enterLocal_variable_type" ):

10051 listener.enterLocal_variable_type(self)

10052

10053 def exitRule(self, listener:ParseTreeListener):

10054 if hasattr( listener, "exitLocal_variable_type" ):

10055 listener.exitLocal_variable_type(self)

10060 def local_variable_type(self):

10061

10062 localctx = CSharpParser.Local_variable_typeContext(self, self._ctx, self.state)

10063 self.enterRule(localctx, 174, self.RULE_local_variable_type)

10064 try:

10065 self.state = 1448

10066 self._errHandler.sync(self)

10067 la_ = self._interp.adaptivePredict(self._input,148,self._ctx)

10068 if la_ == 1:

10069 self.enterOuterAlt(localctx, 1)

10070 self.state = 1446

10071 self.match(CSharpParser.VAR)

10072 pass

10073

10074 elif la_ == 2:

10075 self.enterOuterAlt(localctx, 2)

10076 self.state = 1447

10077 self.type_()

10078 pass

10079

10080

10081 except RecognitionException as re:

10082 localctx.exception = re

10083 self._errHandler.reportError(self, re)

10084 self._errHandler.recover(self, re)

10085 finally:

10086 self.exitRule()

10087 return localctx

10088

10089

10090 class Local_variable_declaratorContext(ParserRuleContext):

10091 __slots__ = 'parser'

10092

10093 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

10094 super().__init__(parent, invokingState)

10095 self.parser = parser

10096

10097 def identifier(self):

10098 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

10099

10100

10101 def ASSIGNMENT(self):

10102 return self.getToken(CSharpParser.ASSIGNMENT, 0)

10103

10104 def local_variable_initializer(self):

10105 return self.getTypedRuleContext(CSharpParser.Local_variable_initializerContext,0)

10106

10107

10108 def REF(self):

10109 return self.getToken(CSharpParser.REF, 0)

10110

10111 def getRuleIndex(self):

10112 return CSharpParser.RULE_local_variable_declarator

10113

10114 def enterRule(self, listener:ParseTreeListener):

10115 if hasattr( listener, "enterLocal_variable_declarator" ):

10116 listener.enterLocal_variable_declarator(self)

10117

10118 def exitRule(self, listener:ParseTreeListener):

10119 if hasattr( listener, "exitLocal_variable_declarator" ):

10120 listener.exitLocal_variable_declarator(self)

10125 def local_variable_declarator(self):

10126

10127 localctx = CSharpParser.Local_variable_declaratorContext(self, self._ctx, self.state)

10128 self.enterRule(localctx, 176, self.RULE_local_variable_declarator)

10129 try:

10130 self.enterOuterAlt(localctx, 1)

10131 self.state = 1450

10132 self.identifier()

10133 self.state = 1456

10134 self._errHandler.sync(self)

10135 la_ = self._interp.adaptivePredict(self._input,150,self._ctx)

10136 if la_ == 1:

10137 self.state = 1451

10138 self.match(CSharpParser.ASSIGNMENT)

10139 self.state = 1453

10140 self._errHandler.sync(self)

10141 la_ = self._interp.adaptivePredict(self._input,149,self._ctx)

10142 if la_ == 1:

10143 self.state = 1452

10144 self.match(CSharpParser.REF)

10145

10146

10147 self.state = 1455

10148 self.local_variable_initializer()

10149

10150

10151 except RecognitionException as re:

10152 localctx.exception = re

10153 self._errHandler.reportError(self, re)

10154 self._errHandler.recover(self, re)

10155 finally:

10156 self.exitRule()

10157 return localctx

10158

10159

10160 class Local_variable_initializerContext(ParserRuleContext):

10161 __slots__ = 'parser'

10162

10163 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

10164 super().__init__(parent, invokingState)

10165 self.parser = parser

10166

10167 def expression(self):

10168 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

10169

10170

10171 def array_initializer(self):

10172 return self.getTypedRuleContext(CSharpParser.Array_initializerContext,0)

10173

10174

10175 def stackalloc_initializer(self):

10176 return self.getTypedRuleContext(CSharpParser.Stackalloc_initializerContext,0)

10177

10178

10179 def getRuleIndex(self):

10180 return CSharpParser.RULE_local_variable_initializer

10181

10182 def enterRule(self, listener:ParseTreeListener):

10183 if hasattr( listener, "enterLocal_variable_initializer" ):

10184 listener.enterLocal_variable_initializer(self)

10185

10186 def exitRule(self, listener:ParseTreeListener):

10187 if hasattr( listener, "exitLocal_variable_initializer" ):

10188 listener.exitLocal_variable_initializer(self)

10193 def local_variable_initializer(self):

10194

10195 localctx = CSharpParser.Local_variable_initializerContext(self, self._ctx, self.state)

10196 self.enterRule(localctx, 178, self.RULE_local_variable_initializer)

10197 try:

10198 self.state = 1461

10199 self._errHandler.sync(self)

10200 token = self._input.LA(1)

10201 if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:

10202 self.enterOuterAlt(localctx, 1)

10203 self.state = 1458

10204 self.expression()

10205 pass

10206 elif token in [CSharpParser.OPEN_BRACE]:

10207 self.enterOuterAlt(localctx, 2)

10208 self.state = 1459

10209 self.array_initializer()

10210 pass

10211 elif token in [CSharpParser.STACKALLOC]:

10212 self.enterOuterAlt(localctx, 3)

10213 self.state = 1460

10214 self.stackalloc_initializer()

10215 pass

10216 else:

10217 raise NoViableAltException(self)

10218

10219 except RecognitionException as re:

10220 localctx.exception = re

10221 self._errHandler.reportError(self, re)

10222 self._errHandler.recover(self, re)

10223 finally:

10224 self.exitRule()

10225 return localctx

10226

10227

10228 class Local_constant_declarationContext(ParserRuleContext):

10229 __slots__ = 'parser'

10230

10231 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

10232 super().__init__(parent, invokingState)

10233 self.parser = parser

10234

10235 def CONST(self):

10236 return self.getToken(CSharpParser.CONST, 0)

10237

10238 def type_(self):

10239 return self.getTypedRuleContext(CSharpParser.Type_Context,0)

10240

10241

10242 def constant_declarators(self):

10243 return self.getTypedRuleContext(CSharpParser.Constant_declaratorsContext,0)

10244

10245

10246 def getRuleIndex(self):

10247 return CSharpParser.RULE_local_constant_declaration

10248

10249 def enterRule(self, listener:ParseTreeListener):

10250 if hasattr( listener, "enterLocal_constant_declaration" ):

10251 listener.enterLocal_constant_declaration(self)

10252

10253 def exitRule(self, listener:ParseTreeListener):

10254 if hasattr( listener, "exitLocal_constant_declaration" ):

10255 listener.exitLocal_constant_declaration(self)

10260 def local_constant_declaration(self):

10261

10262 localctx = CSharpParser.Local_constant_declarationContext(self, self._ctx, self.state)

10263 self.enterRule(localctx, 180, self.RULE_local_constant_declaration)

10264 try:

10265 self.enterOuterAlt(localctx, 1)

10266 self.state = 1463

10267 self.match(CSharpParser.CONST)

10268 self.state = 1464

10269 self.type_()

10270 self.state = 1465

10271 self.constant_declarators()

10272 except RecognitionException as re:

10273 localctx.exception = re

10274 self._errHandler.reportError(self, re)

10275 self._errHandler.recover(self, re)

10276 finally:

10277 self.exitRule()

10278 return localctx

10279

10280

10281 class If_bodyContext(ParserRuleContext):

10282 __slots__ = 'parser'

10283

10284 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

10285 super().__init__(parent, invokingState)

10286 self.parser = parser

10287

10288 def block(self):

10289 return self.getTypedRuleContext(CSharpParser.BlockContext,0)

10290

10291

10292 def simple_embedded_statement(self):

10293 return self.getTypedRuleContext(CSharpParser.Simple_embedded_statementContext,0)

10294

10295

10296 def getRuleIndex(self):

10297 return CSharpParser.RULE_if_body

10298

10299 def enterRule(self, listener:ParseTreeListener):

10300 if hasattr( listener, "enterIf_body" ):

10301 listener.enterIf_body(self)

10302

10303 def exitRule(self, listener:ParseTreeListener):

10304 if hasattr( listener, "exitIf_body" ):

10305 listener.exitIf_body(self)

10310 def if_body(self):

10311

10312 localctx = CSharpParser.If_bodyContext(self, self._ctx, self.state)

10313 self.enterRule(localctx, 182, self.RULE_if_body)

10314 try:

10315 self.state = 1469

10316 self._errHandler.sync(self)

10317 token = self._input.LA(1)

10318 if token in [CSharpParser.OPEN_BRACE]:

10319 self.enterOuterAlt(localctx, 1)

10320 self.state = 1467

10321 self.block()

10322 pass

10323 elif token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BREAK, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.CONTINUE, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DO, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FIXED, CSharpParser.FLOAT, CSharpParser.FOR, CSharpParser.FOREACH, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GOTO, CSharpParser.GROUP, CSharpParser.IF, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LOCK, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.RETURN, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.SWITCH, CSharpParser.THIS, CSharpParser.THROW, CSharpParser.TRUE, CSharpParser.TRY, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.UNSAFE, CSharpParser.USHORT, CSharpParser.USING, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.WHILE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.SEMICOLON, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:

10324 self.enterOuterAlt(localctx, 2)

10325 self.state = 1468

10326 self.simple_embedded_statement()

10327 pass

10328 else:

10329 raise NoViableAltException(self)

10330

10331 except RecognitionException as re:

10332 localctx.exception = re

10333 self._errHandler.reportError(self, re)

10334 self._errHandler.recover(self, re)

10335 finally:

10336 self.exitRule()

10337 return localctx

10338

10339

10340 class Switch_sectionContext(ParserRuleContext):

10341 __slots__ = 'parser'

10342

10343 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

10344 super().__init__(parent, invokingState)

10345 self.parser = parser

10346

10347 def statement_list(self):

10348 return self.getTypedRuleContext(CSharpParser.Statement_listContext,0)

10349

10350

10351 def switch_label(self, i:int=None):

10352 if i is None:

10353 return self.getTypedRuleContexts(CSharpParser.Switch_labelContext)

10354 else:

10355 return self.getTypedRuleContext(CSharpParser.Switch_labelContext,i)

10356

10357

10358 def getRuleIndex(self):

10359 return CSharpParser.RULE_switch_section

10360

10361 def enterRule(self, listener:ParseTreeListener):

10362 if hasattr( listener, "enterSwitch_section" ):

10363 listener.enterSwitch_section(self)

10364

10365 def exitRule(self, listener:ParseTreeListener):

10366 if hasattr( listener, "exitSwitch_section" ):

10367 listener.exitSwitch_section(self)

10372 def switch_section(self):

10373

10374 localctx = CSharpParser.Switch_sectionContext(self, self._ctx, self.state)

10375 self.enterRule(localctx, 184, self.RULE_switch_section)

10376 try:

10377 self.enterOuterAlt(localctx, 1)

10378 self.state = 1472

10379 self._errHandler.sync(self)

10380 _alt = 1

10381 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

10382 if _alt == 1:

10383 self.state = 1471

10384 self.switch_label()

10385

10386 else:

10387 raise NoViableAltException(self)

10388 self.state = 1474

10389 self._errHandler.sync(self)

10390 _alt = self._interp.adaptivePredict(self._input,153,self._ctx)

10391

10392 self.state = 1476

10393 self.statement_list()

10394 except RecognitionException as re:

10395 localctx.exception = re

10396 self._errHandler.reportError(self, re)

10397 self._errHandler.recover(self, re)

10398 finally:

10399 self.exitRule()

10400 return localctx

10401

10402

10403 class Switch_labelContext(ParserRuleContext):

10404 __slots__ = 'parser'

10405

10406 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

10407 super().__init__(parent, invokingState)

10408 self.parser = parser

10409

10410 def CASE(self):

10411 return self.getToken(CSharpParser.CASE, 0)

10412

10413 def expression(self):

10414 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

10415

10416

10417 def COLON(self):

10418 return self.getToken(CSharpParser.COLON, 0)

10419

10420 def case_guard(self):

10421 return self.getTypedRuleContext(CSharpParser.Case_guardContext,0)

10422

10423

10424 def DEFAULT(self):

10425 return self.getToken(CSharpParser.DEFAULT, 0)

10426

10427 def getRuleIndex(self):

10428 return CSharpParser.RULE_switch_label

10429

10430 def enterRule(self, listener:ParseTreeListener):

10431 if hasattr( listener, "enterSwitch_label" ):

10432 listener.enterSwitch_label(self)

10433

10434 def exitRule(self, listener:ParseTreeListener):

10435 if hasattr( listener, "exitSwitch_label" ):

10436 listener.exitSwitch_label(self)

10441 def switch_label(self):

10442

10443 localctx = CSharpParser.Switch_labelContext(self, self._ctx, self.state)

10444 self.enterRule(localctx, 186, self.RULE_switch_label)

10445 self._la = 0 # Token type

10446 try:

10447 self.state = 1487

10448 self._errHandler.sync(self)

10449 token = self._input.LA(1)

10450 if token in [CSharpParser.CASE]:

10451 self.enterOuterAlt(localctx, 1)

10452 self.state = 1478

10453 self.match(CSharpParser.CASE)

10454 self.state = 1479

10455 self.expression()

10456 self.state = 1481

10457 self._errHandler.sync(self)

10458 _la = self._input.LA(1)

10459 if _la==CSharpParser.WHEN:

10460 self.state = 1480

10461 self.case_guard()

10462

10463

10464 self.state = 1483

10465 self.match(CSharpParser.COLON)

10466 pass

10467 elif token in [CSharpParser.DEFAULT]:

10468 self.enterOuterAlt(localctx, 2)

10469 self.state = 1485

10470 self.match(CSharpParser.DEFAULT)

10471 self.state = 1486

10472 self.match(CSharpParser.COLON)

10473 pass

10474 else:

10475 raise NoViableAltException(self)

10476

10477 except RecognitionException as re:

10478 localctx.exception = re

10479 self._errHandler.reportError(self, re)

10480 self._errHandler.recover(self, re)

10481 finally:

10482 self.exitRule()

10483 return localctx

10484

10485

10486 class Case_guardContext(ParserRuleContext):

10487 __slots__ = 'parser'

10488

10489 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

10490 super().__init__(parent, invokingState)

10491 self.parser = parser

10492

10493 def WHEN(self):

10494 return self.getToken(CSharpParser.WHEN, 0)

10495

10496 def expression(self):

10497 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

10498

10499

10500 def getRuleIndex(self):

10501 return CSharpParser.RULE_case_guard

10502

10503 def enterRule(self, listener:ParseTreeListener):

10504 if hasattr( listener, "enterCase_guard" ):

10505 listener.enterCase_guard(self)

10506

10507 def exitRule(self, listener:ParseTreeListener):

10508 if hasattr( listener, "exitCase_guard" ):

10509 listener.exitCase_guard(self)

10514 def case_guard(self):

10515

10516 localctx = CSharpParser.Case_guardContext(self, self._ctx, self.state)

10517 self.enterRule(localctx, 188, self.RULE_case_guard)

10518 try:

10519 self.enterOuterAlt(localctx, 1)

10520 self.state = 1489

10521 self.match(CSharpParser.WHEN)

10522 self.state = 1490

10523 self.expression()

10524 except RecognitionException as re:

10525 localctx.exception = re

10526 self._errHandler.reportError(self, re)

10527 self._errHandler.recover(self, re)

10528 finally:

10529 self.exitRule()

10530 return localctx

10531

10532

10533 class Statement_listContext(ParserRuleContext):

10534 __slots__ = 'parser'

10535

10536 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

10537 super().__init__(parent, invokingState)

10538 self.parser = parser

10539

10540 def statement(self, i:int=None):

10541 if i is None:

10542 return self.getTypedRuleContexts(CSharpParser.StatementContext)

10543 else:

10544 return self.getTypedRuleContext(CSharpParser.StatementContext,i)

10545

10546

10547 def getRuleIndex(self):

10548 return CSharpParser.RULE_statement_list

10549

10550 def enterRule(self, listener:ParseTreeListener):

10551 if hasattr( listener, "enterStatement_list" ):

10552 listener.enterStatement_list(self)

10553

10554 def exitRule(self, listener:ParseTreeListener):

10555 if hasattr( listener, "exitStatement_list" ):

10556 listener.exitStatement_list(self)

10561 def statement_list(self):

10562

10563 localctx = CSharpParser.Statement_listContext(self, self._ctx, self.state)

10564 self.enterRule(localctx, 190, self.RULE_statement_list)

10565 try:

10566 self.enterOuterAlt(localctx, 1)

10567 self.state = 1493

10568 self._errHandler.sync(self)

10569 _alt = 1

10570 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

10571 if _alt == 1:

10572 self.state = 1492

10573 self.statement()

10574

10575 else:

10576 raise NoViableAltException(self)

10577 self.state = 1495

10578 self._errHandler.sync(self)

10579 _alt = self._interp.adaptivePredict(self._input,156,self._ctx)

10580

10581 except RecognitionException as re:

10582 localctx.exception = re

10583 self._errHandler.reportError(self, re)

10584 self._errHandler.recover(self, re)

10585 finally:

10586 self.exitRule()

10587 return localctx

10588

10589

10590 class For_initializerContext(ParserRuleContext):

10591 __slots__ = 'parser'

10592

10593 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

10594 super().__init__(parent, invokingState)

10595 self.parser = parser

10596

10597 def local_variable_declaration(self):

10598 return self.getTypedRuleContext(CSharpParser.Local_variable_declarationContext,0)

10599

10600

10601 def expression(self, i:int=None):

10602 if i is None:

10603 return self.getTypedRuleContexts(CSharpParser.ExpressionContext)

10604 else:

10605 return self.getTypedRuleContext(CSharpParser.ExpressionContext,i)

10606

10607

10608 def COMMA(self, i:int=None):

10609 if i is None:

10610 return self.getTokens(CSharpParser.COMMA)

10611 else:

10612 return self.getToken(CSharpParser.COMMA, i)

10613

10614 def getRuleIndex(self):

10615 return CSharpParser.RULE_for_initializer

10616

10617 def enterRule(self, listener:ParseTreeListener):

10618 if hasattr( listener, "enterFor_initializer" ):

10619 listener.enterFor_initializer(self)

10620

10621 def exitRule(self, listener:ParseTreeListener):

10622 if hasattr( listener, "exitFor_initializer" ):

10623 listener.exitFor_initializer(self)

10628 def for_initializer(self):

10629

10630 localctx = CSharpParser.For_initializerContext(self, self._ctx, self.state)

10631 self.enterRule(localctx, 192, self.RULE_for_initializer)

10632 self._la = 0 # Token type

10633 try:

10634 self.state = 1506

10635 self._errHandler.sync(self)

10636 la_ = self._interp.adaptivePredict(self._input,158,self._ctx)

10637 if la_ == 1:

10638 self.enterOuterAlt(localctx, 1)

10639 self.state = 1497

10640 self.local_variable_declaration()

10641 pass

10642

10643 elif la_ == 2:

10644 self.enterOuterAlt(localctx, 2)

10645 self.state = 1498

10646 self.expression()

10647 self.state = 1503

10648 self._errHandler.sync(self)

10649 _la = self._input.LA(1)

10650 while _la==CSharpParser.COMMA:

10651 self.state = 1499

10652 self.match(CSharpParser.COMMA)

10653 self.state = 1500

10654 self.expression()

10655 self.state = 1505

10656 self._errHandler.sync(self)

10657 _la = self._input.LA(1)

10658

10659 pass

10660

10661

10662 except RecognitionException as re:

10663 localctx.exception = re

10664 self._errHandler.reportError(self, re)

10665 self._errHandler.recover(self, re)

10666 finally:

10667 self.exitRule()

10668 return localctx

10669

10670

10671 class For_iteratorContext(ParserRuleContext):

10672 __slots__ = 'parser'

10673

10674 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

10675 super().__init__(parent, invokingState)

10676 self.parser = parser

10677

10678 def expression(self, i:int=None):

10679 if i is None:

10680 return self.getTypedRuleContexts(CSharpParser.ExpressionContext)

10681 else:

10682 return self.getTypedRuleContext(CSharpParser.ExpressionContext,i)

10683

10684

10685 def COMMA(self, i:int=None):

10686 if i is None:

10687 return self.getTokens(CSharpParser.COMMA)

10688 else:

10689 return self.getToken(CSharpParser.COMMA, i)

10690

10691 def getRuleIndex(self):

10692 return CSharpParser.RULE_for_iterator

10693

10694 def enterRule(self, listener:ParseTreeListener):

10695 if hasattr( listener, "enterFor_iterator" ):

10696 listener.enterFor_iterator(self)

10697

10698 def exitRule(self, listener:ParseTreeListener):

10699 if hasattr( listener, "exitFor_iterator" ):

10700 listener.exitFor_iterator(self)

10705 def for_iterator(self):

10706

10707 localctx = CSharpParser.For_iteratorContext(self, self._ctx, self.state)

10708 self.enterRule(localctx, 194, self.RULE_for_iterator)

10709 self._la = 0 # Token type

10710 try:

10711 self.enterOuterAlt(localctx, 1)

10712 self.state = 1508

10713 self.expression()

10714 self.state = 1513

10715 self._errHandler.sync(self)

10716 _la = self._input.LA(1)

10717 while _la==CSharpParser.COMMA:

10718 self.state = 1509

10719 self.match(CSharpParser.COMMA)

10720 self.state = 1510

10721 self.expression()

10722 self.state = 1515

10723 self._errHandler.sync(self)

10724 _la = self._input.LA(1)

10725

10726 except RecognitionException as re:

10727 localctx.exception = re

10728 self._errHandler.reportError(self, re)

10729 self._errHandler.recover(self, re)

10730 finally:

10731 self.exitRule()

10732 return localctx

10733

10734

10735 class Catch_clausesContext(ParserRuleContext):

10736 __slots__ = 'parser'

10737

10738 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

10739 super().__init__(parent, invokingState)

10740 self.parser = parser

10741

10742 def specific_catch_clause(self, i:int=None):

10743 if i is None:

10744 return self.getTypedRuleContexts(CSharpParser.Specific_catch_clauseContext)

10745 else:

10746 return self.getTypedRuleContext(CSharpParser.Specific_catch_clauseContext,i)

10747

10748

10749 def general_catch_clause(self):

10750 return self.getTypedRuleContext(CSharpParser.General_catch_clauseContext,0)

10751

10752

10753 def getRuleIndex(self):

10754 return CSharpParser.RULE_catch_clauses

10755

10756 def enterRule(self, listener:ParseTreeListener):

10757 if hasattr( listener, "enterCatch_clauses" ):

10758 listener.enterCatch_clauses(self)

10759

10760 def exitRule(self, listener:ParseTreeListener):

10761 if hasattr( listener, "exitCatch_clauses" ):

10762 listener.exitCatch_clauses(self)

10767 def catch_clauses(self):

10768

10769 localctx = CSharpParser.Catch_clausesContext(self, self._ctx, self.state)

10770 self.enterRule(localctx, 196, self.RULE_catch_clauses)

10771 self._la = 0 # Token type

10772 try:

10773 self.state = 1527

10774 self._errHandler.sync(self)

10775 la_ = self._interp.adaptivePredict(self._input,162,self._ctx)

10776 if la_ == 1:

10777 self.enterOuterAlt(localctx, 1)

10778 self.state = 1516

10779 self.specific_catch_clause()

10780 self.state = 1520

10781 self._errHandler.sync(self)

10782 _alt = self._interp.adaptivePredict(self._input,160,self._ctx)

10783 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

10784 if _alt==1:

10785 self.state = 1517

10786 self.specific_catch_clause()

10787 self.state = 1522

10788 self._errHandler.sync(self)

10789 _alt = self._interp.adaptivePredict(self._input,160,self._ctx)

10790

10791 self.state = 1524

10792 self._errHandler.sync(self)

10793 _la = self._input.LA(1)

10794 if _la==CSharpParser.CATCH:

10795 self.state = 1523

10796 self.general_catch_clause()

10797

10798

10799 pass

10800

10801 elif la_ == 2:

10802 self.enterOuterAlt(localctx, 2)

10803 self.state = 1526

10804 self.general_catch_clause()

10805 pass

10806

10807

10808 except RecognitionException as re:

10809 localctx.exception = re

10810 self._errHandler.reportError(self, re)

10811 self._errHandler.recover(self, re)

10812 finally:

10813 self.exitRule()

10814 return localctx

10815

10816

10817 class Specific_catch_clauseContext(ParserRuleContext):

10818 __slots__ = 'parser'

10819

10820 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

10821 super().__init__(parent, invokingState)

10822 self.parser = parser

10823

10824 def CATCH(self):

10825 return self.getToken(CSharpParser.CATCH, 0)

10826

10827 def OPEN_PARENS(self):

10828 return self.getToken(CSharpParser.OPEN_PARENS, 0)

10829

10830 def class_type(self):

10831 return self.getTypedRuleContext(CSharpParser.Class_typeContext,0)

10832

10833

10834 def CLOSE_PARENS(self):

10835 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

10836

10837 def block(self):

10838 return self.getTypedRuleContext(CSharpParser.BlockContext,0)

10839

10840

10841 def identifier(self):

10842 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

10843

10844

10845 def exception_filter(self):

10846 return self.getTypedRuleContext(CSharpParser.Exception_filterContext,0)

10847

10848

10849 def getRuleIndex(self):

10850 return CSharpParser.RULE_specific_catch_clause

10851

10852 def enterRule(self, listener:ParseTreeListener):

10853 if hasattr( listener, "enterSpecific_catch_clause" ):

10854 listener.enterSpecific_catch_clause(self)

10855

10856 def exitRule(self, listener:ParseTreeListener):

10857 if hasattr( listener, "exitSpecific_catch_clause" ):

10858 listener.exitSpecific_catch_clause(self)

10863 def specific_catch_clause(self):

10864

10865 localctx = CSharpParser.Specific_catch_clauseContext(self, self._ctx, self.state)

10866 self.enterRule(localctx, 198, self.RULE_specific_catch_clause)

10867 self._la = 0 # Token type

10868 try:

10869 self.enterOuterAlt(localctx, 1)

10870 self.state = 1529

10871 self.match(CSharpParser.CATCH)

10872 self.state = 1530

10873 self.match(CSharpParser.OPEN_PARENS)

10874 self.state = 1531

10875 self.class_type()

10876 self.state = 1533

10877 self._errHandler.sync(self)

10878 _la = self._input.LA(1)

10880 self.state = 1532

10881 self.identifier()

10882

10883

10884 self.state = 1535

10885 self.match(CSharpParser.CLOSE_PARENS)

10886 self.state = 1537

10887 self._errHandler.sync(self)

10888 _la = self._input.LA(1)

10889 if _la==CSharpParser.WHEN:

10890 self.state = 1536

10891 self.exception_filter()

10892

10893

10894 self.state = 1539

10895 self.block()

10896 except RecognitionException as re:

10897 localctx.exception = re

10898 self._errHandler.reportError(self, re)

10899 self._errHandler.recover(self, re)

10900 finally:

10901 self.exitRule()

10902 return localctx

10903

10904

10905 class General_catch_clauseContext(ParserRuleContext):

10906 __slots__ = 'parser'

10907

10908 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

10909 super().__init__(parent, invokingState)

10910 self.parser = parser

10911

10912 def CATCH(self):

10913 return self.getToken(CSharpParser.CATCH, 0)

10914

10915 def block(self):

10916 return self.getTypedRuleContext(CSharpParser.BlockContext,0)

10917

10918

10919 def exception_filter(self):

10920 return self.getTypedRuleContext(CSharpParser.Exception_filterContext,0)

10921

10922

10923 def getRuleIndex(self):

10924 return CSharpParser.RULE_general_catch_clause

10925

10926 def enterRule(self, listener:ParseTreeListener):

10927 if hasattr( listener, "enterGeneral_catch_clause" ):

10928 listener.enterGeneral_catch_clause(self)

10929

10930 def exitRule(self, listener:ParseTreeListener):

10931 if hasattr( listener, "exitGeneral_catch_clause" ):

10932 listener.exitGeneral_catch_clause(self)

10937 def general_catch_clause(self):

10938

10939 localctx = CSharpParser.General_catch_clauseContext(self, self._ctx, self.state)

10940 self.enterRule(localctx, 200, self.RULE_general_catch_clause)

10941 self._la = 0 # Token type

10942 try:

10943 self.enterOuterAlt(localctx, 1)

10944 self.state = 1541

10945 self.match(CSharpParser.CATCH)

10946 self.state = 1543

10947 self._errHandler.sync(self)

10948 _la = self._input.LA(1)

10949 if _la==CSharpParser.WHEN:

10950 self.state = 1542

10951 self.exception_filter()

10952

10953

10954 self.state = 1545

10955 self.block()

10956 except RecognitionException as re:

10957 localctx.exception = re

10958 self._errHandler.reportError(self, re)

10959 self._errHandler.recover(self, re)

10960 finally:

10961 self.exitRule()

10962 return localctx

10963

10964

10965 class Exception_filterContext(ParserRuleContext):

10966 __slots__ = 'parser'

10967

10968 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

10969 super().__init__(parent, invokingState)

10970 self.parser = parser

10971

10972 def WHEN(self):

10973 return self.getToken(CSharpParser.WHEN, 0)

10974

10975 def OPEN_PARENS(self):

10976 return self.getToken(CSharpParser.OPEN_PARENS, 0)

10977

10978 def expression(self):

10979 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

10980

10981

10982 def CLOSE_PARENS(self):

10983 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

10984

10985 def getRuleIndex(self):

10986 return CSharpParser.RULE_exception_filter

10987

10988 def enterRule(self, listener:ParseTreeListener):

10989 if hasattr( listener, "enterException_filter" ):

10990 listener.enterException_filter(self)

10991

10992 def exitRule(self, listener:ParseTreeListener):

10993 if hasattr( listener, "exitException_filter" ):

10994 listener.exitException_filter(self)

10999 def exception_filter(self):

11000

11001 localctx = CSharpParser.Exception_filterContext(self, self._ctx, self.state)

11002 self.enterRule(localctx, 202, self.RULE_exception_filter)

11003 try:

11004 self.enterOuterAlt(localctx, 1)

11005 self.state = 1547

11006 self.match(CSharpParser.WHEN)

11007 self.state = 1548

11008 self.match(CSharpParser.OPEN_PARENS)

11009 self.state = 1549

11010 self.expression()

11011 self.state = 1550

11012 self.match(CSharpParser.CLOSE_PARENS)

11013 except RecognitionException as re:

11014 localctx.exception = re

11015 self._errHandler.reportError(self, re)

11016 self._errHandler.recover(self, re)

11017 finally:

11018 self.exitRule()

11019 return localctx

11020

11021

11022 class Finally_clauseContext(ParserRuleContext):

11023 __slots__ = 'parser'

11024

11025 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

11026 super().__init__(parent, invokingState)

11027 self.parser = parser

11028

11029 def FINALLY(self):

11030 return self.getToken(CSharpParser.FINALLY, 0)

11031

11032 def block(self):

11033 return self.getTypedRuleContext(CSharpParser.BlockContext,0)

11034

11035

11036 def getRuleIndex(self):

11037 return CSharpParser.RULE_finally_clause

11038

11039 def enterRule(self, listener:ParseTreeListener):

11040 if hasattr( listener, "enterFinally_clause" ):

11041 listener.enterFinally_clause(self)

11042

11043 def exitRule(self, listener:ParseTreeListener):

11044 if hasattr( listener, "exitFinally_clause" ):

11045 listener.exitFinally_clause(self)

11050 def finally_clause(self):

11051

11052 localctx = CSharpParser.Finally_clauseContext(self, self._ctx, self.state)

11053 self.enterRule(localctx, 204, self.RULE_finally_clause)

11054 try:

11055 self.enterOuterAlt(localctx, 1)

11056 self.state = 1552

11057 self.match(CSharpParser.FINALLY)

11058 self.state = 1553

11059 self.block()

11060 except RecognitionException as re:

11061 localctx.exception = re

11062 self._errHandler.reportError(self, re)

11063 self._errHandler.recover(self, re)

11064 finally:

11065 self.exitRule()

11066 return localctx

11067

11068

11069 class Resource_acquisitionContext(ParserRuleContext):

11070 __slots__ = 'parser'

11071

11072 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

11073 super().__init__(parent, invokingState)

11074 self.parser = parser

11075

11076 def local_variable_declaration(self):

11077 return self.getTypedRuleContext(CSharpParser.Local_variable_declarationContext,0)

11078

11079

11080 def expression(self):

11081 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

11082

11083

11084 def getRuleIndex(self):

11085 return CSharpParser.RULE_resource_acquisition

11086

11087 def enterRule(self, listener:ParseTreeListener):

11088 if hasattr( listener, "enterResource_acquisition" ):

11089 listener.enterResource_acquisition(self)

11090

11091 def exitRule(self, listener:ParseTreeListener):

11092 if hasattr( listener, "exitResource_acquisition" ):

11093 listener.exitResource_acquisition(self)

11098 def resource_acquisition(self):

11099

11100 localctx = CSharpParser.Resource_acquisitionContext(self, self._ctx, self.state)

11101 self.enterRule(localctx, 206, self.RULE_resource_acquisition)

11102 try:

11103 self.state = 1557

11104 self._errHandler.sync(self)

11105 la_ = self._interp.adaptivePredict(self._input,166,self._ctx)

11106 if la_ == 1:

11107 self.enterOuterAlt(localctx, 1)

11108 self.state = 1555

11109 self.local_variable_declaration()

11110 pass

11111

11112 elif la_ == 2:

11113 self.enterOuterAlt(localctx, 2)

11114 self.state = 1556

11115 self.expression()

11116 pass

11117

11118

11119 except RecognitionException as re:

11120 localctx.exception = re

11121 self._errHandler.reportError(self, re)

11122 self._errHandler.recover(self, re)

11123 finally:

11124 self.exitRule()

11125 return localctx

11126

11127

11128 class Namespace_declarationContext(ParserRuleContext):

11129 __slots__ = 'parser'

11130

11131 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

11132 super().__init__(parent, invokingState)

11133 self.parser = parser

11134 self.qi = None # Qualified_identifierContext

11135

11136 def NAMESPACE(self):

11137 return self.getToken(CSharpParser.NAMESPACE, 0)

11138

11139 def namespace_body(self):

11140 return self.getTypedRuleContext(CSharpParser.Namespace_bodyContext,0)

11141

11142

11143 def qualified_identifier(self):

11144 return self.getTypedRuleContext(CSharpParser.Qualified_identifierContext,0)

11145

11146

11147 def SEMICOLON(self):

11148 return self.getToken(CSharpParser.SEMICOLON, 0)

11149

11150 def getRuleIndex(self):

11151 return CSharpParser.RULE_namespace_declaration

11152

11153 def enterRule(self, listener:ParseTreeListener):

11154 if hasattr( listener, "enterNamespace_declaration" ):

11155 listener.enterNamespace_declaration(self)

11156

11157 def exitRule(self, listener:ParseTreeListener):

11158 if hasattr( listener, "exitNamespace_declaration" ):

11159 listener.exitNamespace_declaration(self)

11164 def namespace_declaration(self):

11165

11166 localctx = CSharpParser.Namespace_declarationContext(self, self._ctx, self.state)

11167 self.enterRule(localctx, 208, self.RULE_namespace_declaration)

11168 self._la = 0 # Token type

11169 try:

11170 self.enterOuterAlt(localctx, 1)

11171 self.state = 1559

11172 self.match(CSharpParser.NAMESPACE)

11173 self.state = 1560

11174 localctx.qi = self.qualified_identifier()

11175 self.state = 1561

11176 self.namespace_body()

11177 self.state = 1563

11178 self._errHandler.sync(self)

11179 _la = self._input.LA(1)

11180 if _la==CSharpParser.SEMICOLON:

11181 self.state = 1562

11182 self.match(CSharpParser.SEMICOLON)

11183

11184

11185 except RecognitionException as re:

11186 localctx.exception = re

11187 self._errHandler.reportError(self, re)

11188 self._errHandler.recover(self, re)

11189 finally:

11190 self.exitRule()

11191 return localctx

11192

11193

11194 class Qualified_identifierContext(ParserRuleContext):

11195 __slots__ = 'parser'

11196

11197 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

11198 super().__init__(parent, invokingState)

11199 self.parser = parser

11200

11201 def identifier(self, i:int=None):

11202 if i is None:

11203 return self.getTypedRuleContexts(CSharpParser.IdentifierContext)

11204 else:

11205 return self.getTypedRuleContext(CSharpParser.IdentifierContext,i)

11206

11207

11208 def DOT(self, i:int=None):

11209 if i is None:

11210 return self.getTokens(CSharpParser.DOT)

11211 else:

11212 return self.getToken(CSharpParser.DOT, i)

11213

11214 def getRuleIndex(self):

11215 return CSharpParser.RULE_qualified_identifier

11216

11217 def enterRule(self, listener:ParseTreeListener):

11218 if hasattr( listener, "enterQualified_identifier" ):

11219 listener.enterQualified_identifier(self)

11220

11221 def exitRule(self, listener:ParseTreeListener):

11222 if hasattr( listener, "exitQualified_identifier" ):

11223 listener.exitQualified_identifier(self)

11228 def qualified_identifier(self):

11229

11230 localctx = CSharpParser.Qualified_identifierContext(self, self._ctx, self.state)

11231 self.enterRule(localctx, 210, self.RULE_qualified_identifier)

11232 self._la = 0 # Token type

11233 try:

11234 self.enterOuterAlt(localctx, 1)

11235 self.state = 1565

11236 self.identifier()

11237 self.state = 1570

11238 self._errHandler.sync(self)

11239 _la = self._input.LA(1)

11240 while _la==CSharpParser.DOT:

11241 self.state = 1566

11242 self.match(CSharpParser.DOT)

11243 self.state = 1567

11244 self.identifier()

11245 self.state = 1572

11246 self._errHandler.sync(self)

11247 _la = self._input.LA(1)

11248

11249 except RecognitionException as re:

11250 localctx.exception = re

11251 self._errHandler.reportError(self, re)

11252 self._errHandler.recover(self, re)

11253 finally:

11254 self.exitRule()

11255 return localctx

11256

11257

11258 class Namespace_bodyContext(ParserRuleContext):

11259 __slots__ = 'parser'

11260

11261 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

11262 super().__init__(parent, invokingState)

11263 self.parser = parser

11264

11265 def OPEN_BRACE(self):

11266 return self.getToken(CSharpParser.OPEN_BRACE, 0)

11267

11268 def CLOSE_BRACE(self):

11269 return self.getToken(CSharpParser.CLOSE_BRACE, 0)

11270

11271 def extern_alias_directives(self):

11272 return self.getTypedRuleContext(CSharpParser.Extern_alias_directivesContext,0)

11273

11274

11275 def using_directives(self):

11276 return self.getTypedRuleContext(CSharpParser.Using_directivesContext,0)

11277

11278

11279 def namespace_member_declarations(self):

11280 return self.getTypedRuleContext(CSharpParser.Namespace_member_declarationsContext,0)

11281

11282

11283 def getRuleIndex(self):

11284 return CSharpParser.RULE_namespace_body

11285

11286 def enterRule(self, listener:ParseTreeListener):

11287 if hasattr( listener, "enterNamespace_body" ):

11288 listener.enterNamespace_body(self)

11289

11290 def exitRule(self, listener:ParseTreeListener):

11291 if hasattr( listener, "exitNamespace_body" ):

11292 listener.exitNamespace_body(self)

11297 def namespace_body(self):

11298

11299 localctx = CSharpParser.Namespace_bodyContext(self, self._ctx, self.state)

11300 self.enterRule(localctx, 212, self.RULE_namespace_body)

11301 self._la = 0 # Token type

11302 try:

11303 self.enterOuterAlt(localctx, 1)

11304 self.state = 1573

11305 self.match(CSharpParser.OPEN_BRACE)

11306 self.state = 1575

11307 self._errHandler.sync(self)

11308 la_ = self._interp.adaptivePredict(self._input,169,self._ctx)

11309 if la_ == 1:

11310 self.state = 1574

11311 self.extern_alias_directives()

11312

11313

11314 self.state = 1578

11315 self._errHandler.sync(self)

11316 _la = self._input.LA(1)

11317 if _la==CSharpParser.USING:

11318 self.state = 1577

11319 self.using_directives()

11320

11321

11322 self.state = 1581

11323 self._errHandler.sync(self)

11324 _la = self._input.LA(1)

11326 self.state = 1580

11327 self.namespace_member_declarations()

11328

11329

11330 self.state = 1583

11331 self.match(CSharpParser.CLOSE_BRACE)

11332 except RecognitionException as re:

11333 localctx.exception = re

11334 self._errHandler.reportError(self, re)

11335 self._errHandler.recover(self, re)

11336 finally:

11337 self.exitRule()

11338 return localctx

11339

11340

11341 class Extern_alias_directivesContext(ParserRuleContext):

11342 __slots__ = 'parser'

11343

11344 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

11345 super().__init__(parent, invokingState)

11346 self.parser = parser

11347

11348 def extern_alias_directive(self, i:int=None):

11349 if i is None:

11350 return self.getTypedRuleContexts(CSharpParser.Extern_alias_directiveContext)

11351 else:

11352 return self.getTypedRuleContext(CSharpParser.Extern_alias_directiveContext,i)

11353

11354

11355 def getRuleIndex(self):

11356 return CSharpParser.RULE_extern_alias_directives

11357

11358 def enterRule(self, listener:ParseTreeListener):

11359 if hasattr( listener, "enterExtern_alias_directives" ):

11360 listener.enterExtern_alias_directives(self)

11361

11362 def exitRule(self, listener:ParseTreeListener):

11363 if hasattr( listener, "exitExtern_alias_directives" ):

11364 listener.exitExtern_alias_directives(self)

11369 def extern_alias_directives(self):

11370

11371 localctx = CSharpParser.Extern_alias_directivesContext(self, self._ctx, self.state)

11372 self.enterRule(localctx, 214, self.RULE_extern_alias_directives)

11373 try:

11374 self.enterOuterAlt(localctx, 1)

11375 self.state = 1586

11376 self._errHandler.sync(self)

11377 _alt = 1

11378 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

11379 if _alt == 1:

11380 self.state = 1585

11381 self.extern_alias_directive()

11382

11383 else:

11384 raise NoViableAltException(self)

11385 self.state = 1588

11386 self._errHandler.sync(self)

11387 _alt = self._interp.adaptivePredict(self._input,172,self._ctx)

11388

11389 except RecognitionException as re:

11390 localctx.exception = re

11391 self._errHandler.reportError(self, re)

11392 self._errHandler.recover(self, re)

11393 finally:

11394 self.exitRule()

11395 return localctx

11396

11397

11398 class Extern_alias_directiveContext(ParserRuleContext):

11399 __slots__ = 'parser'

11400

11401 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

11402 super().__init__(parent, invokingState)

11403 self.parser = parser

11404

11405 def EXTERN(self):

11406 return self.getToken(CSharpParser.EXTERN, 0)

11407

11408 def ALIAS(self):

11409 return self.getToken(CSharpParser.ALIAS, 0)

11410

11411 def identifier(self):

11412 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

11413

11414

11415 def SEMICOLON(self):

11416 return self.getToken(CSharpParser.SEMICOLON, 0)

11417

11418 def getRuleIndex(self):

11419 return CSharpParser.RULE_extern_alias_directive

11420

11421 def enterRule(self, listener:ParseTreeListener):

11422 if hasattr( listener, "enterExtern_alias_directive" ):

11423 listener.enterExtern_alias_directive(self)

11424

11425 def exitRule(self, listener:ParseTreeListener):

11426 if hasattr( listener, "exitExtern_alias_directive" ):

11427 listener.exitExtern_alias_directive(self)

11432 def extern_alias_directive(self):

11433

11434 localctx = CSharpParser.Extern_alias_directiveContext(self, self._ctx, self.state)

11435 self.enterRule(localctx, 216, self.RULE_extern_alias_directive)

11436 try:

11437 self.enterOuterAlt(localctx, 1)

11438 self.state = 1590

11439 self.match(CSharpParser.EXTERN)

11440 self.state = 1591

11441 self.match(CSharpParser.ALIAS)

11442 self.state = 1592

11443 self.identifier()

11444 self.state = 1593

11445 self.match(CSharpParser.SEMICOLON)

11446 except RecognitionException as re:

11447 localctx.exception = re

11448 self._errHandler.reportError(self, re)

11449 self._errHandler.recover(self, re)

11450 finally:

11451 self.exitRule()

11452 return localctx

11453

11454

11455 class Using_directivesContext(ParserRuleContext):

11456 __slots__ = 'parser'

11457

11458 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

11459 super().__init__(parent, invokingState)

11460 self.parser = parser

11461

11462 def using_directive(self, i:int=None):

11463 if i is None:

11464 return self.getTypedRuleContexts(CSharpParser.Using_directiveContext)

11465 else:

11466 return self.getTypedRuleContext(CSharpParser.Using_directiveContext,i)

11467

11468

11469 def getRuleIndex(self):

11470 return CSharpParser.RULE_using_directives

11471

11472 def enterRule(self, listener:ParseTreeListener):

11473 if hasattr( listener, "enterUsing_directives" ):

11474 listener.enterUsing_directives(self)

11475

11476 def exitRule(self, listener:ParseTreeListener):

11477 if hasattr( listener, "exitUsing_directives" ):

11478 listener.exitUsing_directives(self)

11483 def using_directives(self):

11484

11485 localctx = CSharpParser.Using_directivesContext(self, self._ctx, self.state)

11486 self.enterRule(localctx, 218, self.RULE_using_directives)

11487 self._la = 0 # Token type

11488 try:

11489 self.enterOuterAlt(localctx, 1)

11490 self.state = 1596

11491 self._errHandler.sync(self)

11492 _la = self._input.LA(1)

11493 while True:

11494 self.state = 1595

11495 self.using_directive()

11496 self.state = 1598

11497 self._errHandler.sync(self)

11498 _la = self._input.LA(1)

11499 if not (_la==CSharpParser.USING):

11500 break

11501

11502 except RecognitionException as re:

11503 localctx.exception = re

11504 self._errHandler.reportError(self, re)

11505 self._errHandler.recover(self, re)

11506 finally:

11507 self.exitRule()

11508 return localctx

11509

11510

11511 class Using_directiveContext(ParserRuleContext):

11512 __slots__ = 'parser'

11513

11514 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

11515 super().__init__(parent, invokingState)

11516 self.parser = parser

11517

11518

11519 def getRuleIndex(self):

11520 return CSharpParser.RULE_using_directive

11521

11522

11523 def copyFrom(self, ctx:ParserRuleContext):

11524 super().copyFrom(ctx)

11525

11526

11527

11528 class UsingAliasDirectiveContext(Using_directiveContext):

11529

11530 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Using_directiveContext

11531 super().__init__(parser)

11532 self.copyFrom(ctx)

11533

11534 def USING(self):

11535 return self.getToken(CSharpParser.USING, 0)

11536 def identifier(self):

11537 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

11538

11539 def ASSIGNMENT(self):

11540 return self.getToken(CSharpParser.ASSIGNMENT, 0)

11541 def namespace_or_type_name(self):

11542 return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,0)

11543

11544 def SEMICOLON(self):

11545 return self.getToken(CSharpParser.SEMICOLON, 0)

11546

11547 def enterRule(self, listener:ParseTreeListener):

11548 if hasattr( listener, "enterUsingAliasDirective" ):

11549 listener.enterUsingAliasDirective(self)

11550

11551 def exitRule(self, listener:ParseTreeListener):

11552 if hasattr( listener, "exitUsingAliasDirective" ):

11553 listener.exitUsingAliasDirective(self)

11554

11555

11556 class UsingNamespaceDirectiveContext(Using_directiveContext):

11557

11558 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Using_directiveContext

11559 super().__init__(parser)

11560 self.copyFrom(ctx)

11561

11562 def USING(self):

11563 return self.getToken(CSharpParser.USING, 0)

11564 def namespace_or_type_name(self):

11565 return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,0)

11566

11567 def SEMICOLON(self):

11568 return self.getToken(CSharpParser.SEMICOLON, 0)

11569

11570 def enterRule(self, listener:ParseTreeListener):

11571 if hasattr( listener, "enterUsingNamespaceDirective" ):

11572 listener.enterUsingNamespaceDirective(self)

11573

11574 def exitRule(self, listener:ParseTreeListener):

11575 if hasattr( listener, "exitUsingNamespaceDirective" ):

11576 listener.exitUsingNamespaceDirective(self)

11577

11578

11579 class UsingStaticDirectiveContext(Using_directiveContext):

11580

11581 def __init__(self, parser, ctx:ParserRuleContext): # actually a CSharpParser.Using_directiveContext

11582 super().__init__(parser)

11583 self.copyFrom(ctx)

11584

11585 def USING(self):

11586 return self.getToken(CSharpParser.USING, 0)

11587 def STATIC(self):

11588 return self.getToken(CSharpParser.STATIC, 0)

11589 def namespace_or_type_name(self):

11590 return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,0)

11591

11592 def SEMICOLON(self):

11593 return self.getToken(CSharpParser.SEMICOLON, 0)

11594

11595 def enterRule(self, listener:ParseTreeListener):

11596 if hasattr( listener, "enterUsingStaticDirective" ):

11597 listener.enterUsingStaticDirective(self)

11598

11599 def exitRule(self, listener:ParseTreeListener):

11600 if hasattr( listener, "exitUsingStaticDirective" ):

11601 listener.exitUsingStaticDirective(self)

11602

11603

11604

11605 def using_directive(self):

11606

11607 localctx = CSharpParser.Using_directiveContext(self, self._ctx, self.state)

11608 self.enterRule(localctx, 220, self.RULE_using_directive)

11609 try:

11610 self.state = 1615

11611 self._errHandler.sync(self)

11612 la_ = self._interp.adaptivePredict(self._input,174,self._ctx)

11613 if la_ == 1:

11614 localctx = CSharpParser.UsingAliasDirectiveContext(self, localctx)

11615 self.enterOuterAlt(localctx, 1)

11616 self.state = 1600

11617 self.match(CSharpParser.USING)

11618 self.state = 1601

11619 self.identifier()

11620 self.state = 1602

11621 self.match(CSharpParser.ASSIGNMENT)

11622 self.state = 1603

11623 self.namespace_or_type_name()

11624 self.state = 1604

11625 self.match(CSharpParser.SEMICOLON)

11626 pass

11627

11628 elif la_ == 2:

11629 localctx = CSharpParser.UsingNamespaceDirectiveContext(self, localctx)

11630 self.enterOuterAlt(localctx, 2)

11631 self.state = 1606

11632 self.match(CSharpParser.USING)

11633 self.state = 1607

11634 self.namespace_or_type_name()

11635 self.state = 1608

11636 self.match(CSharpParser.SEMICOLON)

11637 pass

11638

11639 elif la_ == 3:

11640 localctx = CSharpParser.UsingStaticDirectiveContext(self, localctx)

11641 self.enterOuterAlt(localctx, 3)

11642 self.state = 1610

11643 self.match(CSharpParser.USING)

11644 self.state = 1611

11645 self.match(CSharpParser.STATIC)

11646 self.state = 1612

11647 self.namespace_or_type_name()

11648 self.state = 1613

11649 self.match(CSharpParser.SEMICOLON)

11650 pass

11651

11652

11653 except RecognitionException as re:

11654 localctx.exception = re

11655 self._errHandler.reportError(self, re)

11656 self._errHandler.recover(self, re)

11657 finally:

11658 self.exitRule()

11659 return localctx

11660

11661

11662 class Namespace_member_declarationsContext(ParserRuleContext):

11663 __slots__ = 'parser'

11664

11665 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

11666 super().__init__(parent, invokingState)

11667 self.parser = parser

11668

11669 def namespace_member_declaration(self, i:int=None):

11670 if i is None:

11671 return self.getTypedRuleContexts(CSharpParser.Namespace_member_declarationContext)

11672 else:

11673 return self.getTypedRuleContext(CSharpParser.Namespace_member_declarationContext,i)

11674

11675

11676 def getRuleIndex(self):

11677 return CSharpParser.RULE_namespace_member_declarations

11678

11679 def enterRule(self, listener:ParseTreeListener):

11680 if hasattr( listener, "enterNamespace_member_declarations" ):

11681 listener.enterNamespace_member_declarations(self)

11682

11683 def exitRule(self, listener:ParseTreeListener):

11684 if hasattr( listener, "exitNamespace_member_declarations" ):

11685 listener.exitNamespace_member_declarations(self)

11690 def namespace_member_declarations(self):

11691

11692 localctx = CSharpParser.Namespace_member_declarationsContext(self, self._ctx, self.state)

11693 self.enterRule(localctx, 222, self.RULE_namespace_member_declarations)

11694 self._la = 0 # Token type

11695 try:

11696 self.enterOuterAlt(localctx, 1)

11697 self.state = 1618

11698 self._errHandler.sync(self)

11699 _la = self._input.LA(1)

11700 while True:

11701 self.state = 1617

11702 self.namespace_member_declaration()

11703 self.state = 1620

11704 self._errHandler.sync(self)

11705 _la = self._input.LA(1)

11707 break

11708

11709 except RecognitionException as re:

11710 localctx.exception = re

11711 self._errHandler.reportError(self, re)

11712 self._errHandler.recover(self, re)

11713 finally:

11714 self.exitRule()

11715 return localctx

11716

11717

11718 class Namespace_member_declarationContext(ParserRuleContext):

11719 __slots__ = 'parser'

11720

11721 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

11722 super().__init__(parent, invokingState)

11723 self.parser = parser

11724

11725 def namespace_declaration(self):

11726 return self.getTypedRuleContext(CSharpParser.Namespace_declarationContext,0)

11727

11728

11729 def type_declaration(self):

11730 return self.getTypedRuleContext(CSharpParser.Type_declarationContext,0)

11731

11732

11733 def getRuleIndex(self):

11734 return CSharpParser.RULE_namespace_member_declaration

11735

11736 def enterRule(self, listener:ParseTreeListener):

11737 if hasattr( listener, "enterNamespace_member_declaration" ):

11738 listener.enterNamespace_member_declaration(self)

11739

11740 def exitRule(self, listener:ParseTreeListener):

11741 if hasattr( listener, "exitNamespace_member_declaration" ):

11742 listener.exitNamespace_member_declaration(self)

11747 def namespace_member_declaration(self):

11748

11749 localctx = CSharpParser.Namespace_member_declarationContext(self, self._ctx, self.state)

11750 self.enterRule(localctx, 224, self.RULE_namespace_member_declaration)

11751 try:

11752 self.state = 1624

11753 self._errHandler.sync(self)

11754 token = self._input.LA(1)

11755 if token in [CSharpParser.NAMESPACE]:

11756 self.enterOuterAlt(localctx, 1)

11757 self.state = 1622

11758 self.namespace_declaration()

11759 pass

11760 elif token in [CSharpParser.ABSTRACT, CSharpParser.ASYNC, CSharpParser.CLASS, CSharpParser.DELEGATE, CSharpParser.ENUM, CSharpParser.EXTERN, CSharpParser.INTERFACE, CSharpParser.INTERNAL, CSharpParser.NEW, CSharpParser.OVERRIDE, CSharpParser.PARTIAL, CSharpParser.PRIVATE, CSharpParser.PROTECTED, CSharpParser.PUBLIC, CSharpParser.READONLY, CSharpParser.REF, CSharpParser.SEALED, CSharpParser.STATIC, CSharpParser.STRUCT, CSharpParser.UNSAFE, CSharpParser.VIRTUAL, CSharpParser.VOLATILE, CSharpParser.OPEN_BRACKET]:

11761 self.enterOuterAlt(localctx, 2)

11762 self.state = 1623

11763 self.type_declaration()

11764 pass

11765 else:

11766 raise NoViableAltException(self)

11767

11768 except RecognitionException as re:

11769 localctx.exception = re

11770 self._errHandler.reportError(self, re)

11771 self._errHandler.recover(self, re)

11772 finally:

11773 self.exitRule()

11774 return localctx

11775

11776

11777 class Type_declarationContext(ParserRuleContext):

11778 __slots__ = 'parser'

11779

11780 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

11781 super().__init__(parent, invokingState)

11782 self.parser = parser

11783

11784 def class_definition(self):

11785 return self.getTypedRuleContext(CSharpParser.Class_definitionContext,0)

11786

11787

11788 def struct_definition(self):

11789 return self.getTypedRuleContext(CSharpParser.Struct_definitionContext,0)

11790

11791

11792 def interface_definition(self):

11793 return self.getTypedRuleContext(CSharpParser.Interface_definitionContext,0)

11794

11795

11796 def enum_definition(self):

11797 return self.getTypedRuleContext(CSharpParser.Enum_definitionContext,0)

11798

11799

11800 def delegate_definition(self):

11801 return self.getTypedRuleContext(CSharpParser.Delegate_definitionContext,0)

11802

11803

11804 def attributes(self):

11805 return self.getTypedRuleContext(CSharpParser.AttributesContext,0)

11806

11807

11808 def all_member_modifiers(self):

11809 return self.getTypedRuleContext(CSharpParser.All_member_modifiersContext,0)

11810

11811

11812 def getRuleIndex(self):

11813 return CSharpParser.RULE_type_declaration

11814

11815 def enterRule(self, listener:ParseTreeListener):

11816 if hasattr( listener, "enterType_declaration" ):

11817 listener.enterType_declaration(self)

11818

11819 def exitRule(self, listener:ParseTreeListener):

11820 if hasattr( listener, "exitType_declaration" ):

11821 listener.exitType_declaration(self)

11826 def type_declaration(self):

11827

11828 localctx = CSharpParser.Type_declarationContext(self, self._ctx, self.state)

11829 self.enterRule(localctx, 226, self.RULE_type_declaration)

11830 self._la = 0 # Token type

11831 try:

11832 self.enterOuterAlt(localctx, 1)

11833 self.state = 1627

11834 self._errHandler.sync(self)

11835 _la = self._input.LA(1)

11836 if _la==CSharpParser.OPEN_BRACKET:

11837 self.state = 1626

11838 self.attributes()

11839

11840

11841 self.state = 1630

11842 self._errHandler.sync(self)

11843 la_ = self._interp.adaptivePredict(self._input,178,self._ctx)

11844 if la_ == 1:

11845 self.state = 1629

11846 self.all_member_modifiers()

11847

11848

11849 self.state = 1637

11850 self._errHandler.sync(self)

11851 token = self._input.LA(1)

11852 if token in [CSharpParser.CLASS]:

11853 self.state = 1632

11854 self.class_definition()

11855 pass

11856 elif token in [CSharpParser.READONLY, CSharpParser.REF, CSharpParser.STRUCT]:

11857 self.state = 1633

11858 self.struct_definition()

11859 pass

11860 elif token in [CSharpParser.INTERFACE]:

11861 self.state = 1634

11862 self.interface_definition()

11863 pass

11864 elif token in [CSharpParser.ENUM]:

11865 self.state = 1635

11866 self.enum_definition()

11867 pass

11868 elif token in [CSharpParser.DELEGATE]:

11869 self.state = 1636

11870 self.delegate_definition()

11871 pass

11872 else:

11873 raise NoViableAltException(self)

11874

11875 except RecognitionException as re:

11876 localctx.exception = re

11877 self._errHandler.reportError(self, re)

11878 self._errHandler.recover(self, re)

11879 finally:

11880 self.exitRule()

11881 return localctx

11882

11883

11884 class Qualified_alias_memberContext(ParserRuleContext):

11885 __slots__ = 'parser'

11886

11887 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

11888 super().__init__(parent, invokingState)

11889 self.parser = parser

11890

11891 def identifier(self, i:int=None):

11892 if i is None:

11893 return self.getTypedRuleContexts(CSharpParser.IdentifierContext)

11894 else:

11895 return self.getTypedRuleContext(CSharpParser.IdentifierContext,i)

11896

11897

11898 def DOUBLE_COLON(self):

11899 return self.getToken(CSharpParser.DOUBLE_COLON, 0)

11900

11901 def type_argument_list(self):

11902 return self.getTypedRuleContext(CSharpParser.Type_argument_listContext,0)

11903

11904

11905 def getRuleIndex(self):

11906 return CSharpParser.RULE_qualified_alias_member

11907

11908 def enterRule(self, listener:ParseTreeListener):

11909 if hasattr( listener, "enterQualified_alias_member" ):

11910 listener.enterQualified_alias_member(self)

11911

11912 def exitRule(self, listener:ParseTreeListener):

11913 if hasattr( listener, "exitQualified_alias_member" ):

11914 listener.exitQualified_alias_member(self)

11919 def qualified_alias_member(self):

11920

11921 localctx = CSharpParser.Qualified_alias_memberContext(self, self._ctx, self.state)

11922 self.enterRule(localctx, 228, self.RULE_qualified_alias_member)

11923 try:

11924 self.enterOuterAlt(localctx, 1)

11925 self.state = 1639

11926 self.identifier()

11927 self.state = 1640

11928 self.match(CSharpParser.DOUBLE_COLON)

11929 self.state = 1641

11930 self.identifier()

11931 self.state = 1643

11932 self._errHandler.sync(self)

11933 la_ = self._interp.adaptivePredict(self._input,180,self._ctx)

11934 if la_ == 1:

11935 self.state = 1642

11936 self.type_argument_list()

11937

11938

11939 except RecognitionException as re:

11940 localctx.exception = re

11941 self._errHandler.reportError(self, re)

11942 self._errHandler.recover(self, re)

11943 finally:

11944 self.exitRule()

11945 return localctx

11946

11947

11948 class Type_parameter_listContext(ParserRuleContext):

11949 __slots__ = 'parser'

11950

11951 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

11952 super().__init__(parent, invokingState)

11953 self.parser = parser

11954

11955 def LT(self):

11956 return self.getToken(CSharpParser.LT, 0)

11957

11958 def type_parameter(self, i:int=None):

11959 if i is None:

11960 return self.getTypedRuleContexts(CSharpParser.Type_parameterContext)

11961 else:

11962 return self.getTypedRuleContext(CSharpParser.Type_parameterContext,i)

11963

11964

11965 def GT(self):

11966 return self.getToken(CSharpParser.GT, 0)

11967

11968 def COMMA(self, i:int=None):

11969 if i is None:

11970 return self.getTokens(CSharpParser.COMMA)

11971 else:

11972 return self.getToken(CSharpParser.COMMA, i)

11973

11974 def getRuleIndex(self):

11975 return CSharpParser.RULE_type_parameter_list

11976

11977 def enterRule(self, listener:ParseTreeListener):

11978 if hasattr( listener, "enterType_parameter_list" ):

11979 listener.enterType_parameter_list(self)

11980

11981 def exitRule(self, listener:ParseTreeListener):

11982 if hasattr( listener, "exitType_parameter_list" ):

11983 listener.exitType_parameter_list(self)

11988 def type_parameter_list(self):

11989

11990 localctx = CSharpParser.Type_parameter_listContext(self, self._ctx, self.state)

11991 self.enterRule(localctx, 230, self.RULE_type_parameter_list)

11992 self._la = 0 # Token type

11993 try:

11994 self.enterOuterAlt(localctx, 1)

11995 self.state = 1645

11996 self.match(CSharpParser.LT)

11997 self.state = 1646

11998 self.type_parameter()

11999 self.state = 1651

12000 self._errHandler.sync(self)

12001 _la = self._input.LA(1)

12002 while _la==CSharpParser.COMMA:

12003 self.state = 1647

12004 self.match(CSharpParser.COMMA)

12005 self.state = 1648

12006 self.type_parameter()

12007 self.state = 1653

12008 self._errHandler.sync(self)

12009 _la = self._input.LA(1)

12010

12011 self.state = 1654

12012 self.match(CSharpParser.GT)

12013 except RecognitionException as re:

12014 localctx.exception = re

12015 self._errHandler.reportError(self, re)

12016 self._errHandler.recover(self, re)

12017 finally:

12018 self.exitRule()

12019 return localctx

12020

12021

12022 class Type_parameterContext(ParserRuleContext):

12023 __slots__ = 'parser'

12024

12025 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

12026 super().__init__(parent, invokingState)

12027 self.parser = parser

12028

12029 def identifier(self):

12030 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

12031

12032

12033 def attributes(self):

12034 return self.getTypedRuleContext(CSharpParser.AttributesContext,0)

12035

12036

12037 def getRuleIndex(self):

12038 return CSharpParser.RULE_type_parameter

12039

12040 def enterRule(self, listener:ParseTreeListener):

12041 if hasattr( listener, "enterType_parameter" ):

12042 listener.enterType_parameter(self)

12043

12044 def exitRule(self, listener:ParseTreeListener):

12045 if hasattr( listener, "exitType_parameter" ):

12046 listener.exitType_parameter(self)

12051 def type_parameter(self):

12052

12053 localctx = CSharpParser.Type_parameterContext(self, self._ctx, self.state)

12054 self.enterRule(localctx, 232, self.RULE_type_parameter)

12055 self._la = 0 # Token type

12056 try:

12057 self.enterOuterAlt(localctx, 1)

12058 self.state = 1657

12059 self._errHandler.sync(self)

12060 _la = self._input.LA(1)

12061 if _la==CSharpParser.OPEN_BRACKET:

12062 self.state = 1656

12063 self.attributes()

12064

12065

12066 self.state = 1659

12067 self.identifier()

12068 except RecognitionException as re:

12069 localctx.exception = re

12070 self._errHandler.reportError(self, re)

12071 self._errHandler.recover(self, re)

12072 finally:

12073 self.exitRule()

12074 return localctx

12075

12076

12077 class Class_baseContext(ParserRuleContext):

12078 __slots__ = 'parser'

12079

12080 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

12081 super().__init__(parent, invokingState)

12082 self.parser = parser

12083

12084 def COLON(self):

12085 return self.getToken(CSharpParser.COLON, 0)

12086

12087 def class_type(self):

12088 return self.getTypedRuleContext(CSharpParser.Class_typeContext,0)

12089

12090

12091 def COMMA(self, i:int=None):

12092 if i is None:

12093 return self.getTokens(CSharpParser.COMMA)

12094 else:

12095 return self.getToken(CSharpParser.COMMA, i)

12096

12097 def namespace_or_type_name(self, i:int=None):

12098 if i is None:

12099 return self.getTypedRuleContexts(CSharpParser.Namespace_or_type_nameContext)

12100 else:

12101 return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,i)

12102

12103

12104 def getRuleIndex(self):

12105 return CSharpParser.RULE_class_base

12106

12107 def enterRule(self, listener:ParseTreeListener):

12108 if hasattr( listener, "enterClass_base" ):

12109 listener.enterClass_base(self)

12110

12111 def exitRule(self, listener:ParseTreeListener):

12112 if hasattr( listener, "exitClass_base" ):

12113 listener.exitClass_base(self)

12118 def class_base(self):

12119

12120 localctx = CSharpParser.Class_baseContext(self, self._ctx, self.state)

12121 self.enterRule(localctx, 234, self.RULE_class_base)

12122 self._la = 0 # Token type

12123 try:

12124 self.enterOuterAlt(localctx, 1)

12125 self.state = 1661

12126 self.match(CSharpParser.COLON)

12127 self.state = 1662

12128 self.class_type()

12129 self.state = 1667

12130 self._errHandler.sync(self)

12131 _la = self._input.LA(1)

12132 while _la==CSharpParser.COMMA:

12133 self.state = 1663

12134 self.match(CSharpParser.COMMA)

12135 self.state = 1664

12136 self.namespace_or_type_name()

12137 self.state = 1669

12138 self._errHandler.sync(self)

12139 _la = self._input.LA(1)

12140

12141 except RecognitionException as re:

12142 localctx.exception = re

12143 self._errHandler.reportError(self, re)

12144 self._errHandler.recover(self, re)

12145 finally:

12146 self.exitRule()

12147 return localctx

12148

12149

12150 class Interface_type_listContext(ParserRuleContext):

12151 __slots__ = 'parser'

12152

12153 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

12154 super().__init__(parent, invokingState)

12155 self.parser = parser

12156

12157 def namespace_or_type_name(self, i:int=None):

12158 if i is None:

12159 return self.getTypedRuleContexts(CSharpParser.Namespace_or_type_nameContext)

12160 else:

12161 return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,i)

12162

12163

12164 def COMMA(self, i:int=None):

12165 if i is None:

12166 return self.getTokens(CSharpParser.COMMA)

12167 else:

12168 return self.getToken(CSharpParser.COMMA, i)

12169

12170 def getRuleIndex(self):

12171 return CSharpParser.RULE_interface_type_list

12172

12173 def enterRule(self, listener:ParseTreeListener):

12174 if hasattr( listener, "enterInterface_type_list" ):

12175 listener.enterInterface_type_list(self)

12176

12177 def exitRule(self, listener:ParseTreeListener):

12178 if hasattr( listener, "exitInterface_type_list" ):

12179 listener.exitInterface_type_list(self)

12184 def interface_type_list(self):

12185

12186 localctx = CSharpParser.Interface_type_listContext(self, self._ctx, self.state)

12187 self.enterRule(localctx, 236, self.RULE_interface_type_list)

12188 self._la = 0 # Token type

12189 try:

12190 self.enterOuterAlt(localctx, 1)

12191 self.state = 1670

12192 self.namespace_or_type_name()

12193 self.state = 1675

12194 self._errHandler.sync(self)

12195 _la = self._input.LA(1)

12196 while _la==CSharpParser.COMMA:

12197 self.state = 1671

12198 self.match(CSharpParser.COMMA)

12199 self.state = 1672

12200 self.namespace_or_type_name()

12201 self.state = 1677

12202 self._errHandler.sync(self)

12203 _la = self._input.LA(1)

12204

12205 except RecognitionException as re:

12206 localctx.exception = re

12207 self._errHandler.reportError(self, re)

12208 self._errHandler.recover(self, re)

12209 finally:

12210 self.exitRule()

12211 return localctx

12212

12213

12214 class Type_parameter_constraints_clausesContext(ParserRuleContext):

12215 __slots__ = 'parser'

12216

12217 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

12218 super().__init__(parent, invokingState)

12219 self.parser = parser

12220

12221 def type_parameter_constraints_clause(self, i:int=None):

12222 if i is None:

12223 return self.getTypedRuleContexts(CSharpParser.Type_parameter_constraints_clauseContext)

12224 else:

12225 return self.getTypedRuleContext(CSharpParser.Type_parameter_constraints_clauseContext,i)

12226

12227

12228 def getRuleIndex(self):

12229 return CSharpParser.RULE_type_parameter_constraints_clauses

12230

12231 def enterRule(self, listener:ParseTreeListener):

12232 if hasattr( listener, "enterType_parameter_constraints_clauses" ):

12233 listener.enterType_parameter_constraints_clauses(self)

12234

12235 def exitRule(self, listener:ParseTreeListener):

12236 if hasattr( listener, "exitType_parameter_constraints_clauses" ):

12237 listener.exitType_parameter_constraints_clauses(self)

12242 def type_parameter_constraints_clauses(self):

12243

12244 localctx = CSharpParser.Type_parameter_constraints_clausesContext(self, self._ctx, self.state)

12245 self.enterRule(localctx, 238, self.RULE_type_parameter_constraints_clauses)

12246 self._la = 0 # Token type

12247 try:

12248 self.enterOuterAlt(localctx, 1)

12249 self.state = 1679

12250 self._errHandler.sync(self)

12251 _la = self._input.LA(1)

12252 while True:

12253 self.state = 1678

12254 self.type_parameter_constraints_clause()

12255 self.state = 1681

12256 self._errHandler.sync(self)

12257 _la = self._input.LA(1)

12258 if not (_la==CSharpParser.WHERE):

12259 break

12260

12261 except RecognitionException as re:

12262 localctx.exception = re

12263 self._errHandler.reportError(self, re)

12264 self._errHandler.recover(self, re)

12265 finally:

12266 self.exitRule()

12267 return localctx

12268

12269

12270 class Type_parameter_constraints_clauseContext(ParserRuleContext):

12271 __slots__ = 'parser'

12272

12273 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

12274 super().__init__(parent, invokingState)

12275 self.parser = parser

12276

12277 def WHERE(self):

12278 return self.getToken(CSharpParser.WHERE, 0)

12279

12280 def identifier(self):

12281 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

12282

12283

12284 def COLON(self):

12285 return self.getToken(CSharpParser.COLON, 0)

12286

12287 def type_parameter_constraints(self):

12288 return self.getTypedRuleContext(CSharpParser.Type_parameter_constraintsContext,0)

12289

12290

12291 def getRuleIndex(self):

12292 return CSharpParser.RULE_type_parameter_constraints_clause

12293

12294 def enterRule(self, listener:ParseTreeListener):

12295 if hasattr( listener, "enterType_parameter_constraints_clause" ):

12296 listener.enterType_parameter_constraints_clause(self)

12297

12298 def exitRule(self, listener:ParseTreeListener):

12299 if hasattr( listener, "exitType_parameter_constraints_clause" ):

12300 listener.exitType_parameter_constraints_clause(self)

12305 def type_parameter_constraints_clause(self):

12306

12307 localctx = CSharpParser.Type_parameter_constraints_clauseContext(self, self._ctx, self.state)

12308 self.enterRule(localctx, 240, self.RULE_type_parameter_constraints_clause)

12309 try:

12310 self.enterOuterAlt(localctx, 1)

12311 self.state = 1683

12312 self.match(CSharpParser.WHERE)

12313 self.state = 1684

12314 self.identifier()

12315 self.state = 1685

12316 self.match(CSharpParser.COLON)

12317 self.state = 1686

12318 self.type_parameter_constraints()

12319 except RecognitionException as re:

12320 localctx.exception = re

12321 self._errHandler.reportError(self, re)

12322 self._errHandler.recover(self, re)

12323 finally:

12324 self.exitRule()

12325 return localctx

12326

12327

12328 class Type_parameter_constraintsContext(ParserRuleContext):

12329 __slots__ = 'parser'

12330

12331 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

12332 super().__init__(parent, invokingState)

12333 self.parser = parser

12334

12335 def constructor_constraint(self):

12336 return self.getTypedRuleContext(CSharpParser.Constructor_constraintContext,0)

12337

12338

12339 def primary_constraint(self):

12340 return self.getTypedRuleContext(CSharpParser.Primary_constraintContext,0)

12341

12342

12343 def COMMA(self, i:int=None):

12344 if i is None:

12345 return self.getTokens(CSharpParser.COMMA)

12346 else:

12347 return self.getToken(CSharpParser.COMMA, i)

12348

12349 def secondary_constraints(self):

12350 return self.getTypedRuleContext(CSharpParser.Secondary_constraintsContext,0)

12351

12352

12353 def getRuleIndex(self):

12354 return CSharpParser.RULE_type_parameter_constraints

12355

12356 def enterRule(self, listener:ParseTreeListener):

12357 if hasattr( listener, "enterType_parameter_constraints" ):

12358 listener.enterType_parameter_constraints(self)

12359

12360 def exitRule(self, listener:ParseTreeListener):

12361 if hasattr( listener, "exitType_parameter_constraints" ):

12362 listener.exitType_parameter_constraints(self)

12367 def type_parameter_constraints(self):

12368

12369 localctx = CSharpParser.Type_parameter_constraintsContext(self, self._ctx, self.state)

12370 self.enterRule(localctx, 242, self.RULE_type_parameter_constraints)

12371 self._la = 0 # Token type

12372 try:

12373 self.state = 1698

12374 self._errHandler.sync(self)

12375 token = self._input.LA(1)

12376 if token in [CSharpParser.NEW]:

12377 self.enterOuterAlt(localctx, 1)

12378 self.state = 1688

12379 self.constructor_constraint()

12380 pass

12381 elif token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BY, CSharpParser.CLASS, CSharpParser.DESCENDING, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.STRING, CSharpParser.STRUCT, CSharpParser.UNMANAGED, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER]:

12382 self.enterOuterAlt(localctx, 2)

12383 self.state = 1689

12384 self.primary_constraint()

12385 self.state = 1692

12386 self._errHandler.sync(self)

12387 la_ = self._interp.adaptivePredict(self._input,186,self._ctx)

12388 if la_ == 1:

12389 self.state = 1690

12390 self.match(CSharpParser.COMMA)

12391 self.state = 1691

12392 self.secondary_constraints()

12393

12394

12395 self.state = 1696

12396 self._errHandler.sync(self)

12397 _la = self._input.LA(1)

12398 if _la==CSharpParser.COMMA:

12399 self.state = 1694

12400 self.match(CSharpParser.COMMA)

12401 self.state = 1695

12402 self.constructor_constraint()

12403

12404

12405 pass

12406 else:

12407 raise NoViableAltException(self)

12408

12409 except RecognitionException as re:

12410 localctx.exception = re

12411 self._errHandler.reportError(self, re)

12412 self._errHandler.recover(self, re)

12413 finally:

12414 self.exitRule()

12415 return localctx

12416

12417

12418 class Primary_constraintContext(ParserRuleContext):

12419 __slots__ = 'parser'

12420

12421 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

12422 super().__init__(parent, invokingState)

12423 self.parser = parser

12424

12425 def class_type(self):

12426 return self.getTypedRuleContext(CSharpParser.Class_typeContext,0)

12427

12428

12429 def CLASS(self):

12430 return self.getToken(CSharpParser.CLASS, 0)

12431

12432 def INTERR(self):

12433 return self.getToken(CSharpParser.INTERR, 0)

12434

12435 def STRUCT(self):

12436 return self.getToken(CSharpParser.STRUCT, 0)

12437

12438 def UNMANAGED(self):

12439 return self.getToken(CSharpParser.UNMANAGED, 0)

12440

12441 def getRuleIndex(self):

12442 return CSharpParser.RULE_primary_constraint

12443

12444 def enterRule(self, listener:ParseTreeListener):

12445 if hasattr( listener, "enterPrimary_constraint" ):

12446 listener.enterPrimary_constraint(self)

12447

12448 def exitRule(self, listener:ParseTreeListener):

12449 if hasattr( listener, "exitPrimary_constraint" ):

12450 listener.exitPrimary_constraint(self)

12455 def primary_constraint(self):

12456

12457 localctx = CSharpParser.Primary_constraintContext(self, self._ctx, self.state)

12458 self.enterRule(localctx, 244, self.RULE_primary_constraint)

12459 self._la = 0 # Token type

12460 try:

12461 self.state = 1707

12462 self._errHandler.sync(self)

12463 la_ = self._interp.adaptivePredict(self._input,190,self._ctx)

12464 if la_ == 1:

12465 self.enterOuterAlt(localctx, 1)

12466 self.state = 1700

12467 self.class_type()

12468 pass

12469

12470 elif la_ == 2:

12471 self.enterOuterAlt(localctx, 2)

12472 self.state = 1701

12473 self.match(CSharpParser.CLASS)

12474 self.state = 1703

12475 self._errHandler.sync(self)

12476 _la = self._input.LA(1)

12477 if _la==CSharpParser.INTERR:

12478 self.state = 1702

12479 self.match(CSharpParser.INTERR)

12480

12481

12482 pass

12483

12484 elif la_ == 3:

12485 self.enterOuterAlt(localctx, 3)

12486 self.state = 1705

12487 self.match(CSharpParser.STRUCT)

12488 pass

12489

12490 elif la_ == 4:

12491 self.enterOuterAlt(localctx, 4)

12492 self.state = 1706

12493 self.match(CSharpParser.UNMANAGED)

12494 pass

12495

12496

12497 except RecognitionException as re:

12498 localctx.exception = re

12499 self._errHandler.reportError(self, re)

12500 self._errHandler.recover(self, re)

12501 finally:

12502 self.exitRule()

12503 return localctx

12504

12505

12506 class Secondary_constraintsContext(ParserRuleContext):

12507 __slots__ = 'parser'

12508

12509 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

12510 super().__init__(parent, invokingState)

12511 self.parser = parser

12512

12513 def namespace_or_type_name(self, i:int=None):

12514 if i is None:

12515 return self.getTypedRuleContexts(CSharpParser.Namespace_or_type_nameContext)

12516 else:

12517 return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,i)

12518

12519

12520 def COMMA(self, i:int=None):

12521 if i is None:

12522 return self.getTokens(CSharpParser.COMMA)

12523 else:

12524 return self.getToken(CSharpParser.COMMA, i)

12525

12526 def getRuleIndex(self):

12527 return CSharpParser.RULE_secondary_constraints

12528

12529 def enterRule(self, listener:ParseTreeListener):

12530 if hasattr( listener, "enterSecondary_constraints" ):

12531 listener.enterSecondary_constraints(self)

12532

12533 def exitRule(self, listener:ParseTreeListener):

12534 if hasattr( listener, "exitSecondary_constraints" ):

12535 listener.exitSecondary_constraints(self)

12540 def secondary_constraints(self):

12541

12542 localctx = CSharpParser.Secondary_constraintsContext(self, self._ctx, self.state)

12543 self.enterRule(localctx, 246, self.RULE_secondary_constraints)

12544 try:

12545 self.enterOuterAlt(localctx, 1)

12546 self.state = 1709

12547 self.namespace_or_type_name()

12548 self.state = 1714

12549 self._errHandler.sync(self)

12550 _alt = self._interp.adaptivePredict(self._input,191,self._ctx)

12551 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

12552 if _alt==1:

12553 self.state = 1710

12554 self.match(CSharpParser.COMMA)

12555 self.state = 1711

12556 self.namespace_or_type_name()

12557 self.state = 1716

12558 self._errHandler.sync(self)

12559 _alt = self._interp.adaptivePredict(self._input,191,self._ctx)

12560

12561 except RecognitionException as re:

12562 localctx.exception = re

12563 self._errHandler.reportError(self, re)

12564 self._errHandler.recover(self, re)

12565 finally:

12566 self.exitRule()

12567 return localctx

12568

12569

12570 class Constructor_constraintContext(ParserRuleContext):

12571 __slots__ = 'parser'

12572

12573 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

12574 super().__init__(parent, invokingState)

12575 self.parser = parser

12576

12577 def NEW(self):

12578 return self.getToken(CSharpParser.NEW, 0)

12579

12580 def OPEN_PARENS(self):

12581 return self.getToken(CSharpParser.OPEN_PARENS, 0)

12582

12583 def CLOSE_PARENS(self):

12584 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

12585

12586 def getRuleIndex(self):

12587 return CSharpParser.RULE_constructor_constraint

12588

12589 def enterRule(self, listener:ParseTreeListener):

12590 if hasattr( listener, "enterConstructor_constraint" ):

12591 listener.enterConstructor_constraint(self)

12592

12593 def exitRule(self, listener:ParseTreeListener):

12594 if hasattr( listener, "exitConstructor_constraint" ):

12595 listener.exitConstructor_constraint(self)

12600 def constructor_constraint(self):

12601

12602 localctx = CSharpParser.Constructor_constraintContext(self, self._ctx, self.state)

12603 self.enterRule(localctx, 248, self.RULE_constructor_constraint)

12604 try:

12605 self.enterOuterAlt(localctx, 1)

12606 self.state = 1717

12607 self.match(CSharpParser.NEW)

12608 self.state = 1718

12609 self.match(CSharpParser.OPEN_PARENS)

12610 self.state = 1719

12611 self.match(CSharpParser.CLOSE_PARENS)

12612 except RecognitionException as re:

12613 localctx.exception = re

12614 self._errHandler.reportError(self, re)

12615 self._errHandler.recover(self, re)

12616 finally:

12617 self.exitRule()

12618 return localctx

12619

12620

12621 class Class_bodyContext(ParserRuleContext):

12622 __slots__ = 'parser'

12623

12624 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

12625 super().__init__(parent, invokingState)

12626 self.parser = parser

12627

12628 def OPEN_BRACE(self):

12629 return self.getToken(CSharpParser.OPEN_BRACE, 0)

12630

12631 def CLOSE_BRACE(self):

12632 return self.getToken(CSharpParser.CLOSE_BRACE, 0)

12633

12634 def class_member_declarations(self):

12635 return self.getTypedRuleContext(CSharpParser.Class_member_declarationsContext,0)

12636

12637

12638 def getRuleIndex(self):

12639 return CSharpParser.RULE_class_body

12640

12641 def enterRule(self, listener:ParseTreeListener):

12642 if hasattr( listener, "enterClass_body" ):

12643 listener.enterClass_body(self)

12644

12645 def exitRule(self, listener:ParseTreeListener):

12646 if hasattr( listener, "exitClass_body" ):

12647 listener.exitClass_body(self)

12652 def class_body(self):

12653

12654 localctx = CSharpParser.Class_bodyContext(self, self._ctx, self.state)

12655 self.enterRule(localctx, 250, self.RULE_class_body)

12656 self._la = 0 # Token type

12657 try:

12658 self.enterOuterAlt(localctx, 1)

12659 self.state = 1721

12660 self.match(CSharpParser.OPEN_BRACE)

12661 self.state = 1723

12662 self._errHandler.sync(self)

12663 _la = self._input.LA(1)

12665 self.state = 1722

12666 self.class_member_declarations()

12667

12668

12669 self.state = 1725

12670 self.match(CSharpParser.CLOSE_BRACE)

12671 except RecognitionException as re:

12672 localctx.exception = re

12673 self._errHandler.reportError(self, re)

12674 self._errHandler.recover(self, re)

12675 finally:

12676 self.exitRule()

12677 return localctx

12678

12679

12680 class Class_member_declarationsContext(ParserRuleContext):

12681 __slots__ = 'parser'

12682

12683 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

12684 super().__init__(parent, invokingState)

12685 self.parser = parser

12686

12687 def class_member_declaration(self, i:int=None):

12688 if i is None:

12689 return self.getTypedRuleContexts(CSharpParser.Class_member_declarationContext)

12690 else:

12691 return self.getTypedRuleContext(CSharpParser.Class_member_declarationContext,i)

12692

12693

12694 def getRuleIndex(self):

12695 return CSharpParser.RULE_class_member_declarations

12696

12697 def enterRule(self, listener:ParseTreeListener):

12698 if hasattr( listener, "enterClass_member_declarations" ):

12699 listener.enterClass_member_declarations(self)

12700

12701 def exitRule(self, listener:ParseTreeListener):

12702 if hasattr( listener, "exitClass_member_declarations" ):

12703 listener.exitClass_member_declarations(self)

12708 def class_member_declarations(self):

12709

12710 localctx = CSharpParser.Class_member_declarationsContext(self, self._ctx, self.state)

12711 self.enterRule(localctx, 252, self.RULE_class_member_declarations)

12712 self._la = 0 # Token type

12713 try:

12714 self.enterOuterAlt(localctx, 1)

12715 self.state = 1728

12716 self._errHandler.sync(self)

12717 _la = self._input.LA(1)

12718 while True:

12719 self.state = 1727

12720 self.class_member_declaration()

12721 self.state = 1730

12722 self._errHandler.sync(self)

12723 _la = self._input.LA(1)

12725 break

12726

12727 except RecognitionException as re:

12728 localctx.exception = re

12729 self._errHandler.reportError(self, re)

12730 self._errHandler.recover(self, re)

12731 finally:

12732 self.exitRule()

12733 return localctx

12734

12735

12736 class Class_member_declarationContext(ParserRuleContext):

12737 __slots__ = 'parser'

12738

12739 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

12740 super().__init__(parent, invokingState)

12741 self.parser = parser

12742

12743 def common_member_declaration(self):

12744 return self.getTypedRuleContext(CSharpParser.Common_member_declarationContext,0)

12745

12746

12747 def destructor_definition(self):

12748 return self.getTypedRuleContext(CSharpParser.Destructor_definitionContext,0)

12749

12750

12751 def attributes(self):

12752 return self.getTypedRuleContext(CSharpParser.AttributesContext,0)

12753

12754

12755 def all_member_modifiers(self):

12756 return self.getTypedRuleContext(CSharpParser.All_member_modifiersContext,0)

12757

12758

12759 def getRuleIndex(self):

12760 return CSharpParser.RULE_class_member_declaration

12761

12762 def enterRule(self, listener:ParseTreeListener):

12763 if hasattr( listener, "enterClass_member_declaration" ):

12764 listener.enterClass_member_declaration(self)

12765

12766 def exitRule(self, listener:ParseTreeListener):

12767 if hasattr( listener, "exitClass_member_declaration" ):

12768 listener.exitClass_member_declaration(self)

12773 def class_member_declaration(self):

12774

12775 localctx = CSharpParser.Class_member_declarationContext(self, self._ctx, self.state)

12776 self.enterRule(localctx, 254, self.RULE_class_member_declaration)

12777 self._la = 0 # Token type

12778 try:

12779 self.enterOuterAlt(localctx, 1)

12780 self.state = 1733

12781 self._errHandler.sync(self)

12782 _la = self._input.LA(1)

12783 if _la==CSharpParser.OPEN_BRACKET:

12784 self.state = 1732

12785 self.attributes()

12786

12787

12788 self.state = 1736

12789 self._errHandler.sync(self)

12790 la_ = self._interp.adaptivePredict(self._input,195,self._ctx)

12791 if la_ == 1:

12792 self.state = 1735

12793 self.all_member_modifiers()

12794

12795

12796 self.state = 1740

12797 self._errHandler.sync(self)

12798 token = self._input.LA(1)

12799 if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CLASS, CSharpParser.CONST, CSharpParser.DECIMAL, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.ENUM, CSharpParser.EQUALS, CSharpParser.EVENT, CSharpParser.EXPLICIT, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.IMPLICIT, CSharpParser.INT, CSharpParser.INTERFACE, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.READONLY, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.STRING, CSharpParser.STRUCT, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.VOID, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.OPEN_PARENS]:

12800 self.state = 1738

12801 self.common_member_declaration()

12802 pass

12803 elif token in [CSharpParser.TILDE]:

12804 self.state = 1739

12805 self.destructor_definition()

12806 pass

12807 else:

12808 raise NoViableAltException(self)

12809

12810 except RecognitionException as re:

12811 localctx.exception = re

12812 self._errHandler.reportError(self, re)

12813 self._errHandler.recover(self, re)

12814 finally:

12815 self.exitRule()

12816 return localctx

12817

12818

12819 class All_member_modifiersContext(ParserRuleContext):

12820 __slots__ = 'parser'

12821

12822 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

12823 super().__init__(parent, invokingState)

12824 self.parser = parser

12825

12826 def all_member_modifier(self, i:int=None):

12827 if i is None:

12828 return self.getTypedRuleContexts(CSharpParser.All_member_modifierContext)

12829 else:

12830 return self.getTypedRuleContext(CSharpParser.All_member_modifierContext,i)

12831

12832

12833 def getRuleIndex(self):

12834 return CSharpParser.RULE_all_member_modifiers

12835

12836 def enterRule(self, listener:ParseTreeListener):

12837 if hasattr( listener, "enterAll_member_modifiers" ):

12838 listener.enterAll_member_modifiers(self)

12839

12840 def exitRule(self, listener:ParseTreeListener):

12841 if hasattr( listener, "exitAll_member_modifiers" ):

12842 listener.exitAll_member_modifiers(self)

12847 def all_member_modifiers(self):

12848

12849 localctx = CSharpParser.All_member_modifiersContext(self, self._ctx, self.state)

12850 self.enterRule(localctx, 256, self.RULE_all_member_modifiers)

12851 try:

12852 self.enterOuterAlt(localctx, 1)

12853 self.state = 1743

12854 self._errHandler.sync(self)

12855 _alt = 1

12856 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

12857 if _alt == 1:

12858 self.state = 1742

12859 self.all_member_modifier()

12860

12861 else:

12862 raise NoViableAltException(self)

12863 self.state = 1745

12864 self._errHandler.sync(self)

12865 _alt = self._interp.adaptivePredict(self._input,197,self._ctx)

12866

12867 except RecognitionException as re:

12868 localctx.exception = re

12869 self._errHandler.reportError(self, re)

12870 self._errHandler.recover(self, re)

12871 finally:

12872 self.exitRule()

12873 return localctx

12874

12875

12876 class All_member_modifierContext(ParserRuleContext):

12877 __slots__ = 'parser'

12878

12879 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

12880 super().__init__(parent, invokingState)

12881 self.parser = parser

12882

12883 def NEW(self):

12884 return self.getToken(CSharpParser.NEW, 0)

12885

12886 def PUBLIC(self):

12887 return self.getToken(CSharpParser.PUBLIC, 0)

12888

12889 def PROTECTED(self):

12890 return self.getToken(CSharpParser.PROTECTED, 0)

12891

12892 def INTERNAL(self):

12893 return self.getToken(CSharpParser.INTERNAL, 0)

12894

12895 def PRIVATE(self):

12896 return self.getToken(CSharpParser.PRIVATE, 0)

12897

12898 def READONLY(self):

12899 return self.getToken(CSharpParser.READONLY, 0)

12900

12901 def VOLATILE(self):

12902 return self.getToken(CSharpParser.VOLATILE, 0)

12903

12904 def VIRTUAL(self):

12905 return self.getToken(CSharpParser.VIRTUAL, 0)

12906

12907 def SEALED(self):

12908 return self.getToken(CSharpParser.SEALED, 0)

12909

12910 def OVERRIDE(self):

12911 return self.getToken(CSharpParser.OVERRIDE, 0)

12912

12913 def ABSTRACT(self):

12914 return self.getToken(CSharpParser.ABSTRACT, 0)

12915

12916 def STATIC(self):

12917 return self.getToken(CSharpParser.STATIC, 0)

12918

12919 def UNSAFE(self):

12920 return self.getToken(CSharpParser.UNSAFE, 0)

12921

12922 def EXTERN(self):

12923 return self.getToken(CSharpParser.EXTERN, 0)

12924

12925 def PARTIAL(self):

12926 return self.getToken(CSharpParser.PARTIAL, 0)

12927

12928 def ASYNC(self):

12929 return self.getToken(CSharpParser.ASYNC, 0)

12930

12931 def getRuleIndex(self):

12932 return CSharpParser.RULE_all_member_modifier

12933

12934 def enterRule(self, listener:ParseTreeListener):

12935 if hasattr( listener, "enterAll_member_modifier" ):

12936 listener.enterAll_member_modifier(self)

12937

12938 def exitRule(self, listener:ParseTreeListener):

12939 if hasattr( listener, "exitAll_member_modifier" ):

12940 listener.exitAll_member_modifier(self)

12945 def all_member_modifier(self):

12946

12947 localctx = CSharpParser.All_member_modifierContext(self, self._ctx, self.state)

12948 self.enterRule(localctx, 258, self.RULE_all_member_modifier)

12949 self._la = 0 # Token type

12950 try:

12951 self.enterOuterAlt(localctx, 1)

12952 self.state = 1747

12953 _la = self._input.LA(1)

12954 if not((((_la) & ~0x3f) == 0 and ((1 << _la) & ((1 << CSharpParser.ABSTRACT) | (1 << CSharpParser.ASYNC) | (1 << CSharpParser.EXTERN) | (1 << CSharpParser.INTERNAL))) != 0) or ((((_la - 66)) & ~0x3f) == 0 and ((1 << (_la - 66)) & ((1 << (CSharpParser.NEW - 66)) | (1 << (CSharpParser.OVERRIDE - 66)) | (1 << (CSharpParser.PARTIAL - 66)) | (1 << (CSharpParser.PRIVATE - 66)) | (1 << (CSharpParser.PROTECTED - 66)) | (1 << (CSharpParser.PUBLIC - 66)) | (1 << (CSharpParser.READONLY - 66)) | (1 << (CSharpParser.SEALED - 66)) | (1 << (CSharpParser.STATIC - 66)) | (1 << (CSharpParser.UNSAFE - 66)) | (1 << (CSharpParser.VIRTUAL - 66)) | (1 << (CSharpParser.VOLATILE - 66)))) != 0)):

12955 self._errHandler.recoverInline(self)

12956 else:

12957 self._errHandler.reportMatch(self)

12958 self.consume()

12959 except RecognitionException as re:

12960 localctx.exception = re

12961 self._errHandler.reportError(self, re)

12962 self._errHandler.recover(self, re)

12963 finally:

12964 self.exitRule()

12965 return localctx

12966

12967

12968 class Common_member_declarationContext(ParserRuleContext):

12969 __slots__ = 'parser'

12970

12971 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

12972 super().__init__(parent, invokingState)

12973 self.parser = parser

12974

12975 def constant_declaration(self):

12976 return self.getTypedRuleContext(CSharpParser.Constant_declarationContext,0)

12977

12978

12979 def typed_member_declaration(self):

12980 return self.getTypedRuleContext(CSharpParser.Typed_member_declarationContext,0)

12981

12982

12983 def event_declaration(self):

12984 return self.getTypedRuleContext(CSharpParser.Event_declarationContext,0)

12985

12986

12987 def conversion_operator_declarator(self):

12988 return self.getTypedRuleContext(CSharpParser.Conversion_operator_declaratorContext,0)

12989

12990

12991 def body(self):

12992 return self.getTypedRuleContext(CSharpParser.BodyContext,0)

12993

12994

12995 def right_arrow(self):

12996 return self.getTypedRuleContext(CSharpParser.Right_arrowContext,0)

12997

12998

12999 def throwable_expression(self):

13000 return self.getTypedRuleContext(CSharpParser.Throwable_expressionContext,0)

13001

13002

13003 def SEMICOLON(self):

13004 return self.getToken(CSharpParser.SEMICOLON, 0)

13005

13006 def constructor_declaration(self):

13007 return self.getTypedRuleContext(CSharpParser.Constructor_declarationContext,0)

13008

13009

13010 def VOID(self):

13011 return self.getToken(CSharpParser.VOID, 0)

13012

13013 def method_declaration(self):

13014 return self.getTypedRuleContext(CSharpParser.Method_declarationContext,0)

13015

13016

13017 def class_definition(self):

13018 return self.getTypedRuleContext(CSharpParser.Class_definitionContext,0)

13019

13020

13021 def struct_definition(self):

13022 return self.getTypedRuleContext(CSharpParser.Struct_definitionContext,0)

13023

13024

13025 def interface_definition(self):

13026 return self.getTypedRuleContext(CSharpParser.Interface_definitionContext,0)

13027

13028

13029 def enum_definition(self):

13030 return self.getTypedRuleContext(CSharpParser.Enum_definitionContext,0)

13031

13032

13033 def delegate_definition(self):

13034 return self.getTypedRuleContext(CSharpParser.Delegate_definitionContext,0)

13035

13036

13037 def getRuleIndex(self):

13038 return CSharpParser.RULE_common_member_declaration

13039

13040 def enterRule(self, listener:ParseTreeListener):

13041 if hasattr( listener, "enterCommon_member_declaration" ):

13042 listener.enterCommon_member_declaration(self)

13043

13044 def exitRule(self, listener:ParseTreeListener):

13045 if hasattr( listener, "exitCommon_member_declaration" ):

13046 listener.exitCommon_member_declaration(self)

13051 def common_member_declaration(self):

13052

13053 localctx = CSharpParser.Common_member_declarationContext(self, self._ctx, self.state)

13054 self.enterRule(localctx, 260, self.RULE_common_member_declaration)

13055 try:

13056 self.state = 1768

13057 self._errHandler.sync(self)

13058 la_ = self._interp.adaptivePredict(self._input,199,self._ctx)

13059 if la_ == 1:

13060 self.enterOuterAlt(localctx, 1)

13061 self.state = 1749

13062 self.constant_declaration()

13063 pass

13064

13065 elif la_ == 2:

13066 self.enterOuterAlt(localctx, 2)

13067 self.state = 1750

13068 self.typed_member_declaration()

13069 pass

13070

13071 elif la_ == 3:

13072 self.enterOuterAlt(localctx, 3)

13073 self.state = 1751

13074 self.event_declaration()

13075 pass

13076

13077 elif la_ == 4:

13078 self.enterOuterAlt(localctx, 4)

13079 self.state = 1752

13080 self.conversion_operator_declarator()

13081 self.state = 1758

13082 self._errHandler.sync(self)

13083 token = self._input.LA(1)

13084 if token in [CSharpParser.OPEN_BRACE, CSharpParser.SEMICOLON]:

13085 self.state = 1753

13086 self.body()

13087 pass

13088 elif token in [CSharpParser.ASSIGNMENT]:

13089 self.state = 1754

13090 self.right_arrow()

13091 self.state = 1755

13092 self.throwable_expression()

13093 self.state = 1756

13094 self.match(CSharpParser.SEMICOLON)

13095 pass

13096 else:

13097 raise NoViableAltException(self)

13098

13099 pass

13100

13101 elif la_ == 5:

13102 self.enterOuterAlt(localctx, 5)

13103 self.state = 1760

13104 self.constructor_declaration()

13105 pass

13106

13107 elif la_ == 6:

13108 self.enterOuterAlt(localctx, 6)

13109 self.state = 1761

13110 self.match(CSharpParser.VOID)

13111 self.state = 1762

13112 self.method_declaration()

13113 pass

13114

13115 elif la_ == 7:

13116 self.enterOuterAlt(localctx, 7)

13117 self.state = 1763

13118 self.class_definition()

13119 pass

13120

13121 elif la_ == 8:

13122 self.enterOuterAlt(localctx, 8)

13123 self.state = 1764

13124 self.struct_definition()

13125 pass

13126

13127 elif la_ == 9:

13128 self.enterOuterAlt(localctx, 9)

13129 self.state = 1765

13130 self.interface_definition()

13131 pass

13132

13133 elif la_ == 10:

13134 self.enterOuterAlt(localctx, 10)

13135 self.state = 1766

13136 self.enum_definition()

13137 pass

13138

13139 elif la_ == 11:

13140 self.enterOuterAlt(localctx, 11)

13141 self.state = 1767

13142 self.delegate_definition()

13143 pass

13144

13145

13146 except RecognitionException as re:

13147 localctx.exception = re

13148 self._errHandler.reportError(self, re)

13149 self._errHandler.recover(self, re)

13150 finally:

13151 self.exitRule()

13152 return localctx

13153

13154

13155 class Typed_member_declarationContext(ParserRuleContext):

13156 __slots__ = 'parser'

13157

13158 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

13159 super().__init__(parent, invokingState)

13160 self.parser = parser

13161

13162 def type_(self):

13163 return self.getTypedRuleContext(CSharpParser.Type_Context,0)

13164

13165

13166 def namespace_or_type_name(self):

13167 return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,0)

13168

13169

13170 def DOT(self):

13171 return self.getToken(CSharpParser.DOT, 0)

13172

13173 def indexer_declaration(self):

13174 return self.getTypedRuleContext(CSharpParser.Indexer_declarationContext,0)

13175

13176

13177 def method_declaration(self):

13178 return self.getTypedRuleContext(CSharpParser.Method_declarationContext,0)

13179

13180

13181 def property_declaration(self):

13182 return self.getTypedRuleContext(CSharpParser.Property_declarationContext,0)

13183

13184

13185 def operator_declaration(self):

13186 return self.getTypedRuleContext(CSharpParser.Operator_declarationContext,0)

13187

13188

13189 def field_declaration(self):

13190 return self.getTypedRuleContext(CSharpParser.Field_declarationContext,0)

13191

13192

13193 def REF(self):

13194 return self.getToken(CSharpParser.REF, 0)

13195

13196 def READONLY(self):

13197 return self.getToken(CSharpParser.READONLY, 0)

13198

13199 def getRuleIndex(self):

13200 return CSharpParser.RULE_typed_member_declaration

13201

13202 def enterRule(self, listener:ParseTreeListener):

13203 if hasattr( listener, "enterTyped_member_declaration" ):

13204 listener.enterTyped_member_declaration(self)

13205

13206 def exitRule(self, listener:ParseTreeListener):

13207 if hasattr( listener, "exitTyped_member_declaration" ):

13208 listener.exitTyped_member_declaration(self)

13213 def typed_member_declaration(self):

13214

13215 localctx = CSharpParser.Typed_member_declarationContext(self, self._ctx, self.state)

13216 self.enterRule(localctx, 262, self.RULE_typed_member_declaration)

13217 try:

13218 self.enterOuterAlt(localctx, 1)

13219 self.state = 1775

13220 self._errHandler.sync(self)

13221 la_ = self._interp.adaptivePredict(self._input,200,self._ctx)

13222 if la_ == 1:

13223 self.state = 1770

13224 self.match(CSharpParser.REF)

13225

13226 elif la_ == 2:

13227 self.state = 1771

13228 self.match(CSharpParser.READONLY)

13229 self.state = 1772

13230 self.match(CSharpParser.REF)

13231

13232 elif la_ == 3:

13233 self.state = 1773

13234 self.match(CSharpParser.REF)

13235 self.state = 1774

13236 self.match(CSharpParser.READONLY)

13237

13238

13239 self.state = 1777

13240 self.type_()

13241 self.state = 1787

13242 self._errHandler.sync(self)

13243 la_ = self._interp.adaptivePredict(self._input,201,self._ctx)

13244 if la_ == 1:

13245 self.state = 1778

13246 self.namespace_or_type_name()

13247 self.state = 1779

13248 self.match(CSharpParser.DOT)

13249 self.state = 1780

13250 self.indexer_declaration()

13251 pass

13252

13253 elif la_ == 2:

13254 self.state = 1782

13255 self.method_declaration()

13256 pass

13257

13258 elif la_ == 3:

13259 self.state = 1783

13260 self.property_declaration()

13261 pass

13262

13263 elif la_ == 4:

13264 self.state = 1784

13265 self.indexer_declaration()

13266 pass

13267

13268 elif la_ == 5:

13269 self.state = 1785

13270 self.operator_declaration()

13271 pass

13272

13273 elif la_ == 6:

13274 self.state = 1786

13275 self.field_declaration()

13276 pass

13277

13278

13279 except RecognitionException as re:

13280 localctx.exception = re

13281 self._errHandler.reportError(self, re)

13282 self._errHandler.recover(self, re)

13283 finally:

13284 self.exitRule()

13285 return localctx

13286

13287

13288 class Constant_declaratorsContext(ParserRuleContext):

13289 __slots__ = 'parser'

13290

13291 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

13292 super().__init__(parent, invokingState)

13293 self.parser = parser

13294

13295 def constant_declarator(self, i:int=None):

13296 if i is None:

13297 return self.getTypedRuleContexts(CSharpParser.Constant_declaratorContext)

13298 else:

13299 return self.getTypedRuleContext(CSharpParser.Constant_declaratorContext,i)

13300

13301

13302 def COMMA(self, i:int=None):

13303 if i is None:

13304 return self.getTokens(CSharpParser.COMMA)

13305 else:

13306 return self.getToken(CSharpParser.COMMA, i)

13307

13308 def getRuleIndex(self):

13309 return CSharpParser.RULE_constant_declarators

13310

13311 def enterRule(self, listener:ParseTreeListener):

13312 if hasattr( listener, "enterConstant_declarators" ):

13313 listener.enterConstant_declarators(self)

13314

13315 def exitRule(self, listener:ParseTreeListener):

13316 if hasattr( listener, "exitConstant_declarators" ):

13317 listener.exitConstant_declarators(self)

13322 def constant_declarators(self):

13323

13324 localctx = CSharpParser.Constant_declaratorsContext(self, self._ctx, self.state)

13325 self.enterRule(localctx, 264, self.RULE_constant_declarators)

13326 self._la = 0 # Token type

13327 try:

13328 self.enterOuterAlt(localctx, 1)

13329 self.state = 1789

13330 self.constant_declarator()

13331 self.state = 1794

13332 self._errHandler.sync(self)

13333 _la = self._input.LA(1)

13334 while _la==CSharpParser.COMMA:

13335 self.state = 1790

13336 self.match(CSharpParser.COMMA)

13337 self.state = 1791

13338 self.constant_declarator()

13339 self.state = 1796

13340 self._errHandler.sync(self)

13341 _la = self._input.LA(1)

13342

13343 except RecognitionException as re:

13344 localctx.exception = re

13345 self._errHandler.reportError(self, re)

13346 self._errHandler.recover(self, re)

13347 finally:

13348 self.exitRule()

13349 return localctx

13350

13351

13352 class Constant_declaratorContext(ParserRuleContext):

13353 __slots__ = 'parser'

13354

13355 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

13356 super().__init__(parent, invokingState)

13357 self.parser = parser

13358

13359 def identifier(self):

13360 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

13361

13362

13363 def ASSIGNMENT(self):

13364 return self.getToken(CSharpParser.ASSIGNMENT, 0)

13365

13366 def expression(self):

13367 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

13368

13369

13370 def getRuleIndex(self):

13371 return CSharpParser.RULE_constant_declarator

13372

13373 def enterRule(self, listener:ParseTreeListener):

13374 if hasattr( listener, "enterConstant_declarator" ):

13375 listener.enterConstant_declarator(self)

13376

13377 def exitRule(self, listener:ParseTreeListener):

13378 if hasattr( listener, "exitConstant_declarator" ):

13379 listener.exitConstant_declarator(self)

13384 def constant_declarator(self):

13385

13386 localctx = CSharpParser.Constant_declaratorContext(self, self._ctx, self.state)

13387 self.enterRule(localctx, 266, self.RULE_constant_declarator)

13388 try:

13389 self.enterOuterAlt(localctx, 1)

13390 self.state = 1797

13391 self.identifier()

13392 self.state = 1798

13393 self.match(CSharpParser.ASSIGNMENT)

13394 self.state = 1799

13395 self.expression()

13396 except RecognitionException as re:

13397 localctx.exception = re

13398 self._errHandler.reportError(self, re)

13399 self._errHandler.recover(self, re)

13400 finally:

13401 self.exitRule()

13402 return localctx

13403

13404

13405 class Variable_declaratorsContext(ParserRuleContext):

13406 __slots__ = 'parser'

13407

13408 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

13409 super().__init__(parent, invokingState)

13410 self.parser = parser

13411

13412 def variable_declarator(self, i:int=None):

13413 if i is None:

13414 return self.getTypedRuleContexts(CSharpParser.Variable_declaratorContext)

13415 else:

13416 return self.getTypedRuleContext(CSharpParser.Variable_declaratorContext,i)

13417

13418

13419 def COMMA(self, i:int=None):

13420 if i is None:

13421 return self.getTokens(CSharpParser.COMMA)

13422 else:

13423 return self.getToken(CSharpParser.COMMA, i)

13424

13425 def getRuleIndex(self):

13426 return CSharpParser.RULE_variable_declarators

13427

13428 def enterRule(self, listener:ParseTreeListener):

13429 if hasattr( listener, "enterVariable_declarators" ):

13430 listener.enterVariable_declarators(self)

13431

13432 def exitRule(self, listener:ParseTreeListener):

13433 if hasattr( listener, "exitVariable_declarators" ):

13434 listener.exitVariable_declarators(self)

13439 def variable_declarators(self):

13440

13441 localctx = CSharpParser.Variable_declaratorsContext(self, self._ctx, self.state)

13442 self.enterRule(localctx, 268, self.RULE_variable_declarators)

13443 self._la = 0 # Token type

13444 try:

13445 self.enterOuterAlt(localctx, 1)

13446 self.state = 1801

13447 self.variable_declarator()

13448 self.state = 1806

13449 self._errHandler.sync(self)

13450 _la = self._input.LA(1)

13451 while _la==CSharpParser.COMMA:

13452 self.state = 1802

13453 self.match(CSharpParser.COMMA)

13454 self.state = 1803

13455 self.variable_declarator()

13456 self.state = 1808

13457 self._errHandler.sync(self)

13458 _la = self._input.LA(1)

13459

13460 except RecognitionException as re:

13461 localctx.exception = re

13462 self._errHandler.reportError(self, re)

13463 self._errHandler.recover(self, re)

13464 finally:

13465 self.exitRule()

13466 return localctx

13467

13468

13469 class Variable_declaratorContext(ParserRuleContext):

13470 __slots__ = 'parser'

13471

13472 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

13473 super().__init__(parent, invokingState)

13474 self.parser = parser

13475

13476 def identifier(self):

13477 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

13478

13479

13480 def ASSIGNMENT(self):

13481 return self.getToken(CSharpParser.ASSIGNMENT, 0)

13482

13483 def variable_initializer(self):

13484 return self.getTypedRuleContext(CSharpParser.Variable_initializerContext,0)

13485

13486

13487 def getRuleIndex(self):

13488 return CSharpParser.RULE_variable_declarator

13489

13490 def enterRule(self, listener:ParseTreeListener):

13491 if hasattr( listener, "enterVariable_declarator" ):

13492 listener.enterVariable_declarator(self)

13493

13494 def exitRule(self, listener:ParseTreeListener):

13495 if hasattr( listener, "exitVariable_declarator" ):

13496 listener.exitVariable_declarator(self)

13501 def variable_declarator(self):

13502

13503 localctx = CSharpParser.Variable_declaratorContext(self, self._ctx, self.state)

13504 self.enterRule(localctx, 270, self.RULE_variable_declarator)

13505 self._la = 0 # Token type

13506 try:

13507 self.enterOuterAlt(localctx, 1)

13508 self.state = 1809

13509 self.identifier()

13510 self.state = 1812

13511 self._errHandler.sync(self)

13512 _la = self._input.LA(1)

13513 if _la==CSharpParser.ASSIGNMENT:

13514 self.state = 1810

13515 self.match(CSharpParser.ASSIGNMENT)

13516 self.state = 1811

13517 self.variable_initializer()

13518

13519

13520 except RecognitionException as re:

13521 localctx.exception = re

13522 self._errHandler.reportError(self, re)

13523 self._errHandler.recover(self, re)

13524 finally:

13525 self.exitRule()

13526 return localctx

13527

13528

13529 class Variable_initializerContext(ParserRuleContext):

13530 __slots__ = 'parser'

13531

13532 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

13533 super().__init__(parent, invokingState)

13534 self.parser = parser

13535

13536 def expression(self):

13537 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

13538

13539

13540 def array_initializer(self):

13541 return self.getTypedRuleContext(CSharpParser.Array_initializerContext,0)

13542

13543

13544 def getRuleIndex(self):

13545 return CSharpParser.RULE_variable_initializer

13546

13547 def enterRule(self, listener:ParseTreeListener):

13548 if hasattr( listener, "enterVariable_initializer" ):

13549 listener.enterVariable_initializer(self)

13550

13551 def exitRule(self, listener:ParseTreeListener):

13552 if hasattr( listener, "exitVariable_initializer" ):

13553 listener.exitVariable_initializer(self)

13558 def variable_initializer(self):

13559

13560 localctx = CSharpParser.Variable_initializerContext(self, self._ctx, self.state)

13561 self.enterRule(localctx, 272, self.RULE_variable_initializer)

13562 try:

13563 self.state = 1816

13564 self._errHandler.sync(self)

13565 token = self._input.LA(1)

13566 if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:

13567 self.enterOuterAlt(localctx, 1)

13568 self.state = 1814

13569 self.expression()

13570 pass

13571 elif token in [CSharpParser.OPEN_BRACE]:

13572 self.enterOuterAlt(localctx, 2)

13573 self.state = 1815

13574 self.array_initializer()

13575 pass

13576 else:

13577 raise NoViableAltException(self)

13578

13579 except RecognitionException as re:

13580 localctx.exception = re

13581 self._errHandler.reportError(self, re)

13582 self._errHandler.recover(self, re)

13583 finally:

13584 self.exitRule()

13585 return localctx

13586

13587

13588 class Return_typeContext(ParserRuleContext):

13589 __slots__ = 'parser'

13590

13591 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

13592 super().__init__(parent, invokingState)

13593 self.parser = parser

13594

13595 def type_(self):

13596 return self.getTypedRuleContext(CSharpParser.Type_Context,0)

13597

13598

13599 def VOID(self):

13600 return self.getToken(CSharpParser.VOID, 0)

13601

13602 def getRuleIndex(self):

13603 return CSharpParser.RULE_return_type

13604

13605 def enterRule(self, listener:ParseTreeListener):

13606 if hasattr( listener, "enterReturn_type" ):

13607 listener.enterReturn_type(self)

13608

13609 def exitRule(self, listener:ParseTreeListener):

13610 if hasattr( listener, "exitReturn_type" ):

13611 listener.exitReturn_type(self)

13616 def return_type(self):

13617

13618 localctx = CSharpParser.Return_typeContext(self, self._ctx, self.state)

13619 self.enterRule(localctx, 274, self.RULE_return_type)

13620 try:

13621 self.state = 1820

13622 self._errHandler.sync(self)

13623 la_ = self._interp.adaptivePredict(self._input,206,self._ctx)

13624 if la_ == 1:

13625 self.enterOuterAlt(localctx, 1)

13626 self.state = 1818

13627 self.type_()

13628 pass

13629

13630 elif la_ == 2:

13631 self.enterOuterAlt(localctx, 2)

13632 self.state = 1819

13633 self.match(CSharpParser.VOID)

13634 pass

13635

13636

13637 except RecognitionException as re:

13638 localctx.exception = re

13639 self._errHandler.reportError(self, re)

13640 self._errHandler.recover(self, re)

13641 finally:

13642 self.exitRule()

13643 return localctx

13644

13645

13646 class Member_nameContext(ParserRuleContext):

13647 __slots__ = 'parser'

13648

13649 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

13650 super().__init__(parent, invokingState)

13651 self.parser = parser

13652

13653 def namespace_or_type_name(self):

13654 return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,0)

13655

13656

13657 def getRuleIndex(self):

13658 return CSharpParser.RULE_member_name

13659

13660 def enterRule(self, listener:ParseTreeListener):

13661 if hasattr( listener, "enterMember_name" ):

13662 listener.enterMember_name(self)

13663

13664 def exitRule(self, listener:ParseTreeListener):

13665 if hasattr( listener, "exitMember_name" ):

13666 listener.exitMember_name(self)

13671 def member_name(self):

13672

13673 localctx = CSharpParser.Member_nameContext(self, self._ctx, self.state)

13674 self.enterRule(localctx, 276, self.RULE_member_name)

13675 try:

13676 self.enterOuterAlt(localctx, 1)

13677 self.state = 1822

13678 self.namespace_or_type_name()

13679 except RecognitionException as re:

13680 localctx.exception = re

13681 self._errHandler.reportError(self, re)

13682 self._errHandler.recover(self, re)

13683 finally:

13684 self.exitRule()

13685 return localctx

13686

13687

13688 class Method_bodyContext(ParserRuleContext):

13689 __slots__ = 'parser'

13690

13691 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

13692 super().__init__(parent, invokingState)

13693 self.parser = parser

13694

13695 def block(self):

13696 return self.getTypedRuleContext(CSharpParser.BlockContext,0)

13697

13698

13699 def SEMICOLON(self):

13700 return self.getToken(CSharpParser.SEMICOLON, 0)

13701

13702 def getRuleIndex(self):

13703 return CSharpParser.RULE_method_body

13704

13705 def enterRule(self, listener:ParseTreeListener):

13706 if hasattr( listener, "enterMethod_body" ):

13707 listener.enterMethod_body(self)

13708

13709 def exitRule(self, listener:ParseTreeListener):

13710 if hasattr( listener, "exitMethod_body" ):

13711 listener.exitMethod_body(self)

13716 def method_body(self):

13717

13718 localctx = CSharpParser.Method_bodyContext(self, self._ctx, self.state)

13719 self.enterRule(localctx, 278, self.RULE_method_body)

13720 try:

13721 self.state = 1826

13722 self._errHandler.sync(self)

13723 token = self._input.LA(1)

13724 if token in [CSharpParser.OPEN_BRACE]:

13725 self.enterOuterAlt(localctx, 1)

13726 self.state = 1824

13727 self.block()

13728 pass

13729 elif token in [CSharpParser.SEMICOLON]:

13730 self.enterOuterAlt(localctx, 2)

13731 self.state = 1825

13732 self.match(CSharpParser.SEMICOLON)

13733 pass

13734 else:

13735 raise NoViableAltException(self)

13736

13737 except RecognitionException as re:

13738 localctx.exception = re

13739 self._errHandler.reportError(self, re)

13740 self._errHandler.recover(self, re)

13741 finally:

13742 self.exitRule()

13743 return localctx

13744

13745

13746 class Formal_parameter_listContext(ParserRuleContext):

13747 __slots__ = 'parser'

13748

13749 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

13750 super().__init__(parent, invokingState)

13751 self.parser = parser

13752

13753 def parameter_array(self):

13754 return self.getTypedRuleContext(CSharpParser.Parameter_arrayContext,0)

13755

13756

13757 def fixed_parameters(self):

13758 return self.getTypedRuleContext(CSharpParser.Fixed_parametersContext,0)

13759

13760

13761 def COMMA(self):

13762 return self.getToken(CSharpParser.COMMA, 0)

13763

13764 def getRuleIndex(self):

13765 return CSharpParser.RULE_formal_parameter_list

13766

13767 def enterRule(self, listener:ParseTreeListener):

13768 if hasattr( listener, "enterFormal_parameter_list" ):

13769 listener.enterFormal_parameter_list(self)

13770

13771 def exitRule(self, listener:ParseTreeListener):

13772 if hasattr( listener, "exitFormal_parameter_list" ):

13773 listener.exitFormal_parameter_list(self)

13778 def formal_parameter_list(self):

13779

13780 localctx = CSharpParser.Formal_parameter_listContext(self, self._ctx, self.state)

13781 self.enterRule(localctx, 280, self.RULE_formal_parameter_list)

13782 self._la = 0 # Token type

13783 try:

13784 self.state = 1834

13785 self._errHandler.sync(self)

13786 la_ = self._interp.adaptivePredict(self._input,209,self._ctx)

13787 if la_ == 1:

13788 self.enterOuterAlt(localctx, 1)

13789 self.state = 1828

13790 self.parameter_array()

13791 pass

13792

13793 elif la_ == 2:

13794 self.enterOuterAlt(localctx, 2)

13795 self.state = 1829

13796 self.fixed_parameters()

13797 self.state = 1832

13798 self._errHandler.sync(self)

13799 _la = self._input.LA(1)

13800 if _la==CSharpParser.COMMA:

13801 self.state = 1830

13802 self.match(CSharpParser.COMMA)

13803 self.state = 1831

13804 self.parameter_array()

13807 pass

13810 except RecognitionException as re:

13811 localctx.exception = re

13812 self._errHandler.reportError(self, re)

13813 self._errHandler.recover(self, re)

13814 finally:

13815 self.exitRule()

13816 return localctx

13817

13818

13819 class Fixed_parametersContext(ParserRuleContext):

13820 __slots__ = 'parser'

13821

13822 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

13823 super().__init__(parent, invokingState)

13824 self.parser = parser

13825

13826 def fixed_parameter(self, i:int=None):

13827 if i is None:

13828 return self.getTypedRuleContexts(CSharpParser.Fixed_parameterContext)

13829 else:

13830 return self.getTypedRuleContext(CSharpParser.Fixed_parameterContext,i)

13831

13832

13833 def COMMA(self, i:int=None):

13834 if i is None:

13835 return self.getTokens(CSharpParser.COMMA)

13836 else:

13837 return self.getToken(CSharpParser.COMMA, i)

13838

13839 def getRuleIndex(self):

13840 return CSharpParser.RULE_fixed_parameters

13841

13842 def enterRule(self, listener:ParseTreeListener):

13843 if hasattr( listener, "enterFixed_parameters" ):

13844 listener.enterFixed_parameters(self)

13845

13846 def exitRule(self, listener:ParseTreeListener):

13847 if hasattr( listener, "exitFixed_parameters" ):

13848 listener.exitFixed_parameters(self)

13853 def fixed_parameters(self):

13854

13855 localctx = CSharpParser.Fixed_parametersContext(self, self._ctx, self.state)

13856 self.enterRule(localctx, 282, self.RULE_fixed_parameters)

13857 try:

13858 self.enterOuterAlt(localctx, 1)

13859 self.state = 1836

13860 self.fixed_parameter()

13861 self.state = 1841

13862 self._errHandler.sync(self)

13863 _alt = self._interp.adaptivePredict(self._input,210,self._ctx)

13864 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

13865 if _alt==1:

13866 self.state = 1837

13867 self.match(CSharpParser.COMMA)

13868 self.state = 1838

13869 self.fixed_parameter()

13870 self.state = 1843

13871 self._errHandler.sync(self)

13872 _alt = self._interp.adaptivePredict(self._input,210,self._ctx)

13873

13874 except RecognitionException as re:

13875 localctx.exception = re

13876 self._errHandler.reportError(self, re)

13877 self._errHandler.recover(self, re)

13878 finally:

13879 self.exitRule()

13880 return localctx

13881

13882

13883 class Fixed_parameterContext(ParserRuleContext):

13884 __slots__ = 'parser'

13885

13886 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

13887 super().__init__(parent, invokingState)

13888 self.parser = parser

13889

13890 def arg_declaration(self):

13891 return self.getTypedRuleContext(CSharpParser.Arg_declarationContext,0)

13892

13893

13894 def attributes(self):

13895 return self.getTypedRuleContext(CSharpParser.AttributesContext,0)

13896

13897

13898 def parameter_modifier(self):

13899 return self.getTypedRuleContext(CSharpParser.Parameter_modifierContext,0)

13900

13901

13902 def ARGLIST(self):

13903 return self.getToken(CSharpParser.ARGLIST, 0)

13904

13905 def getRuleIndex(self):

13906 return CSharpParser.RULE_fixed_parameter

13907

13908 def enterRule(self, listener:ParseTreeListener):

13909 if hasattr( listener, "enterFixed_parameter" ):

13910 listener.enterFixed_parameter(self)

13911

13912 def exitRule(self, listener:ParseTreeListener):

13913 if hasattr( listener, "exitFixed_parameter" ):

13914 listener.exitFixed_parameter(self)

13919 def fixed_parameter(self):

13920

13921 localctx = CSharpParser.Fixed_parameterContext(self, self._ctx, self.state)

13922 self.enterRule(localctx, 284, self.RULE_fixed_parameter)

13923 self._la = 0 # Token type

13924 try:

13925 self.state = 1852

13926 self._errHandler.sync(self)

13927 la_ = self._interp.adaptivePredict(self._input,213,self._ctx)

13928 if la_ == 1:

13929 self.enterOuterAlt(localctx, 1)

13930 self.state = 1845

13931 self._errHandler.sync(self)

13932 _la = self._input.LA(1)

13933 if _la==CSharpParser.OPEN_BRACKET:

13934 self.state = 1844

13935 self.attributes()

13936

13937

13938 self.state = 1848

13939 self._errHandler.sync(self)

13940 _la = self._input.LA(1)

13941 if ((((_la - 54)) & ~0x3f) == 0 and ((1 << (_la - 54)) & ((1 << (CSharpParser.IN - 54)) | (1 << (CSharpParser.OUT - 54)) | (1 << (CSharpParser.REF - 54)) | (1 << (CSharpParser.THIS - 54)))) != 0):

13942 self.state = 1847

13943 self.parameter_modifier()

13944

13945

13946 self.state = 1850

13947 self.arg_declaration()

13948 pass

13949

13950 elif la_ == 2:

13951 self.enterOuterAlt(localctx, 2)

13952 self.state = 1851

13953 self.match(CSharpParser.ARGLIST)

13954 pass

13955

13956

13957 except RecognitionException as re:

13958 localctx.exception = re

13959 self._errHandler.reportError(self, re)

13960 self._errHandler.recover(self, re)

13961 finally:

13962 self.exitRule()

13963 return localctx

13964

13965

13966 class Parameter_modifierContext(ParserRuleContext):

13967 __slots__ = 'parser'

13968

13969 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

13970 super().__init__(parent, invokingState)

13971 self.parser = parser

13972

13973 def REF(self):

13974 return self.getToken(CSharpParser.REF, 0)

13975

13976 def OUT(self):

13977 return self.getToken(CSharpParser.OUT, 0)

13978

13979 def IN(self):

13980 return self.getToken(CSharpParser.IN, 0)

13981

13982 def THIS(self):

13983 return self.getToken(CSharpParser.THIS, 0)

13984

13985 def getRuleIndex(self):

13986 return CSharpParser.RULE_parameter_modifier

13987

13988 def enterRule(self, listener:ParseTreeListener):

13989 if hasattr( listener, "enterParameter_modifier" ):

13990 listener.enterParameter_modifier(self)

13991

13992 def exitRule(self, listener:ParseTreeListener):

13993 if hasattr( listener, "exitParameter_modifier" ):

13994 listener.exitParameter_modifier(self)

13999 def parameter_modifier(self):

14000

14001 localctx = CSharpParser.Parameter_modifierContext(self, self._ctx, self.state)

14002 self.enterRule(localctx, 286, self.RULE_parameter_modifier)

14003 try:

14004 self.state = 1862

14005 self._errHandler.sync(self)

14006 la_ = self._interp.adaptivePredict(self._input,214,self._ctx)

14007 if la_ == 1:

14008 self.enterOuterAlt(localctx, 1)

14009 self.state = 1854

14010 self.match(CSharpParser.REF)

14011 pass

14012

14013 elif la_ == 2:

14014 self.enterOuterAlt(localctx, 2)

14015 self.state = 1855

14016 self.match(CSharpParser.OUT)

14017 pass

14018

14019 elif la_ == 3:

14020 self.enterOuterAlt(localctx, 3)

14021 self.state = 1856

14022 self.match(CSharpParser.IN)

14023 pass

14024

14025 elif la_ == 4:

14026 self.enterOuterAlt(localctx, 4)

14027 self.state = 1857

14028 self.match(CSharpParser.REF)

14029 self.state = 1858

14030 self.match(CSharpParser.THIS)

14031 pass

14032

14033 elif la_ == 5:

14034 self.enterOuterAlt(localctx, 5)

14035 self.state = 1859

14036 self.match(CSharpParser.IN)

14037 self.state = 1860

14038 self.match(CSharpParser.THIS)

14039 pass

14040

14041 elif la_ == 6:

14042 self.enterOuterAlt(localctx, 6)

14043 self.state = 1861

14044 self.match(CSharpParser.THIS)

14045 pass

14046

14047

14048 except RecognitionException as re:

14049 localctx.exception = re

14050 self._errHandler.reportError(self, re)

14051 self._errHandler.recover(self, re)

14052 finally:

14053 self.exitRule()

14054 return localctx

14055

14056

14057 class Parameter_arrayContext(ParserRuleContext):

14058 __slots__ = 'parser'

14059

14060 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

14061 super().__init__(parent, invokingState)

14062 self.parser = parser

14063

14064 def PARAMS(self):

14065 return self.getToken(CSharpParser.PARAMS, 0)

14066

14067 def array_type(self):

14068 return self.getTypedRuleContext(CSharpParser.Array_typeContext,0)

14069

14070

14071 def identifier(self):

14072 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

14073

14074

14075 def attributes(self):

14076 return self.getTypedRuleContext(CSharpParser.AttributesContext,0)

14077

14078

14079 def getRuleIndex(self):

14080 return CSharpParser.RULE_parameter_array

14081

14082 def enterRule(self, listener:ParseTreeListener):

14083 if hasattr( listener, "enterParameter_array" ):

14084 listener.enterParameter_array(self)

14085

14086 def exitRule(self, listener:ParseTreeListener):

14087 if hasattr( listener, "exitParameter_array" ):

14088 listener.exitParameter_array(self)

14093 def parameter_array(self):

14094

14095 localctx = CSharpParser.Parameter_arrayContext(self, self._ctx, self.state)

14096 self.enterRule(localctx, 288, self.RULE_parameter_array)

14097 self._la = 0 # Token type

14098 try:

14099 self.enterOuterAlt(localctx, 1)

14100 self.state = 1865

14101 self._errHandler.sync(self)

14102 _la = self._input.LA(1)

14103 if _la==CSharpParser.OPEN_BRACKET:

14104 self.state = 1864

14105 self.attributes()

14106

14107

14108 self.state = 1867

14109 self.match(CSharpParser.PARAMS)

14110 self.state = 1868

14111 self.array_type()

14112 self.state = 1869

14113 self.identifier()

14114 except RecognitionException as re:

14115 localctx.exception = re

14116 self._errHandler.reportError(self, re)

14117 self._errHandler.recover(self, re)

14118 finally:

14119 self.exitRule()

14120 return localctx

14121

14122

14123 class Accessor_declarationsContext(ParserRuleContext):

14124 __slots__ = 'parser'

14125

14126 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

14127 super().__init__(parent, invokingState)

14128 self.parser = parser

14129 self.attrs = None # AttributesContext

14130 self.mods = None # Accessor_modifierContext

14131

14132 def GET(self):

14133 return self.getToken(CSharpParser.GET, 0)

14134

14135 def accessor_body(self):

14136 return self.getTypedRuleContext(CSharpParser.Accessor_bodyContext,0)

14137

14138

14139 def SET(self):

14140 return self.getToken(CSharpParser.SET, 0)

14141

14142 def attributes(self):

14143 return self.getTypedRuleContext(CSharpParser.AttributesContext,0)

14144

14145

14146 def accessor_modifier(self):

14147 return self.getTypedRuleContext(CSharpParser.Accessor_modifierContext,0)

14148

14149

14150 def set_accessor_declaration(self):

14151 return self.getTypedRuleContext(CSharpParser.Set_accessor_declarationContext,0)

14152

14153

14154 def get_accessor_declaration(self):

14155 return self.getTypedRuleContext(CSharpParser.Get_accessor_declarationContext,0)

14156

14157

14158 def getRuleIndex(self):

14159 return CSharpParser.RULE_accessor_declarations

14160

14161 def enterRule(self, listener:ParseTreeListener):

14162 if hasattr( listener, "enterAccessor_declarations" ):

14163 listener.enterAccessor_declarations(self)

14164

14165 def exitRule(self, listener:ParseTreeListener):

14166 if hasattr( listener, "exitAccessor_declarations" ):

14167 listener.exitAccessor_declarations(self)

14172 def accessor_declarations(self):

14173

14174 localctx = CSharpParser.Accessor_declarationsContext(self, self._ctx, self.state)

14175 self.enterRule(localctx, 290, self.RULE_accessor_declarations)

14176 self._la = 0 # Token type

14177 try:

14178 self.enterOuterAlt(localctx, 1)

14179 self.state = 1872

14180 self._errHandler.sync(self)

14181 _la = self._input.LA(1)

14182 if _la==CSharpParser.OPEN_BRACKET:

14183 self.state = 1871

14184 localctx.attrs = self.attributes()

14185

14186

14187 self.state = 1875

14188 self._errHandler.sync(self)

14189 _la = self._input.LA(1)

14190 if ((((_la - 57)) & ~0x3f) == 0 and ((1 << (_la - 57)) & ((1 << (CSharpParser.INTERNAL - 57)) | (1 << (CSharpParser.PRIVATE - 57)) | (1 << (CSharpParser.PROTECTED - 57)))) != 0):

14191 self.state = 1874

14192 localctx.mods = self.accessor_modifier()

14193

14194

14195 self.state = 1887

14196 self._errHandler.sync(self)

14197 token = self._input.LA(1)

14198 if token in [CSharpParser.GET]:

14199 self.state = 1877

14200 self.match(CSharpParser.GET)

14201 self.state = 1878

14202 self.accessor_body()

14203 self.state = 1880

14204 self._errHandler.sync(self)

14205 _la = self._input.LA(1)

14206 if _la==CSharpParser.INTERNAL or ((((_la - 76)) & ~0x3f) == 0 and ((1 << (_la - 76)) & ((1 << (CSharpParser.PRIVATE - 76)) | (1 << (CSharpParser.PROTECTED - 76)) | (1 << (CSharpParser.SET - 76)) | (1 << (CSharpParser.OPEN_BRACKET - 76)))) != 0):

14207 self.state = 1879

14208 self.set_accessor_declaration()

14209

14210

14211 pass

14212 elif token in [CSharpParser.SET]:

14213 self.state = 1882

14214 self.match(CSharpParser.SET)

14215 self.state = 1883

14216 self.accessor_body()

14217 self.state = 1885

14218 self._errHandler.sync(self)

14219 _la = self._input.LA(1)

14220 if _la==CSharpParser.GET or _la==CSharpParser.INTERNAL or ((((_la - 76)) & ~0x3f) == 0 and ((1 << (_la - 76)) & ((1 << (CSharpParser.PRIVATE - 76)) | (1 << (CSharpParser.PROTECTED - 76)) | (1 << (CSharpParser.OPEN_BRACKET - 76)))) != 0):

14221 self.state = 1884

14222 self.get_accessor_declaration()

14223

14224

14225 pass

14226 else:

14227 raise NoViableAltException(self)

14228

14229 except RecognitionException as re:

14230 localctx.exception = re

14231 self._errHandler.reportError(self, re)

14232 self._errHandler.recover(self, re)

14233 finally:

14234 self.exitRule()

14235 return localctx

14236

14237

14238 class Get_accessor_declarationContext(ParserRuleContext):

14239 __slots__ = 'parser'

14240

14241 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

14242 super().__init__(parent, invokingState)

14243 self.parser = parser

14244

14245 def GET(self):

14246 return self.getToken(CSharpParser.GET, 0)

14247

14248 def accessor_body(self):

14249 return self.getTypedRuleContext(CSharpParser.Accessor_bodyContext,0)

14250

14251

14252 def attributes(self):

14253 return self.getTypedRuleContext(CSharpParser.AttributesContext,0)

14254

14255

14256 def accessor_modifier(self):

14257 return self.getTypedRuleContext(CSharpParser.Accessor_modifierContext,0)

14258

14259

14260 def getRuleIndex(self):

14261 return CSharpParser.RULE_get_accessor_declaration

14262

14263 def enterRule(self, listener:ParseTreeListener):

14264 if hasattr( listener, "enterGet_accessor_declaration" ):

14265 listener.enterGet_accessor_declaration(self)

14266

14267 def exitRule(self, listener:ParseTreeListener):

14268 if hasattr( listener, "exitGet_accessor_declaration" ):

14269 listener.exitGet_accessor_declaration(self)

14274 def get_accessor_declaration(self):

14275

14276 localctx = CSharpParser.Get_accessor_declarationContext(self, self._ctx, self.state)

14277 self.enterRule(localctx, 292, self.RULE_get_accessor_declaration)

14278 self._la = 0 # Token type

14279 try:

14280 self.enterOuterAlt(localctx, 1)

14281 self.state = 1890

14282 self._errHandler.sync(self)

14283 _la = self._input.LA(1)

14284 if _la==CSharpParser.OPEN_BRACKET:

14285 self.state = 1889

14286 self.attributes()

14287

14288

14289 self.state = 1893

14290 self._errHandler.sync(self)

14291 _la = self._input.LA(1)

14292 if ((((_la - 57)) & ~0x3f) == 0 and ((1 << (_la - 57)) & ((1 << (CSharpParser.INTERNAL - 57)) | (1 << (CSharpParser.PRIVATE - 57)) | (1 << (CSharpParser.PROTECTED - 57)))) != 0):

14293 self.state = 1892

14294 self.accessor_modifier()

14295

14296

14297 self.state = 1895

14298 self.match(CSharpParser.GET)

14299 self.state = 1896

14300 self.accessor_body()

14301 except RecognitionException as re:

14302 localctx.exception = re

14303 self._errHandler.reportError(self, re)

14304 self._errHandler.recover(self, re)

14305 finally:

14306 self.exitRule()

14307 return localctx

14308

14309

14310 class Set_accessor_declarationContext(ParserRuleContext):

14311 __slots__ = 'parser'

14312

14313 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

14314 super().__init__(parent, invokingState)

14315 self.parser = parser

14316

14317 def SET(self):

14318 return self.getToken(CSharpParser.SET, 0)

14319

14320 def accessor_body(self):

14321 return self.getTypedRuleContext(CSharpParser.Accessor_bodyContext,0)

14322

14323

14324 def attributes(self):

14325 return self.getTypedRuleContext(CSharpParser.AttributesContext,0)

14326

14327

14328 def accessor_modifier(self):

14329 return self.getTypedRuleContext(CSharpParser.Accessor_modifierContext,0)

14330

14331

14332 def getRuleIndex(self):

14333 return CSharpParser.RULE_set_accessor_declaration

14334

14335 def enterRule(self, listener:ParseTreeListener):

14336 if hasattr( listener, "enterSet_accessor_declaration" ):

14337 listener.enterSet_accessor_declaration(self)

14338

14339 def exitRule(self, listener:ParseTreeListener):

14340 if hasattr( listener, "exitSet_accessor_declaration" ):

14341 listener.exitSet_accessor_declaration(self)

14346 def set_accessor_declaration(self):

14347

14348 localctx = CSharpParser.Set_accessor_declarationContext(self, self._ctx, self.state)

14349 self.enterRule(localctx, 294, self.RULE_set_accessor_declaration)

14350 self._la = 0 # Token type

14351 try:

14352 self.enterOuterAlt(localctx, 1)

14353 self.state = 1899

14354 self._errHandler.sync(self)

14355 _la = self._input.LA(1)

14356 if _la==CSharpParser.OPEN_BRACKET:

14357 self.state = 1898

14358 self.attributes()

14359

14360

14361 self.state = 1902

14362 self._errHandler.sync(self)

14363 _la = self._input.LA(1)

14364 if ((((_la - 57)) & ~0x3f) == 0 and ((1 << (_la - 57)) & ((1 << (CSharpParser.INTERNAL - 57)) | (1 << (CSharpParser.PRIVATE - 57)) | (1 << (CSharpParser.PROTECTED - 57)))) != 0):

14365 self.state = 1901

14366 self.accessor_modifier()

14367

14368

14369 self.state = 1904

14370 self.match(CSharpParser.SET)

14371 self.state = 1905

14372 self.accessor_body()

14373 except RecognitionException as re:

14374 localctx.exception = re

14375 self._errHandler.reportError(self, re)

14376 self._errHandler.recover(self, re)

14377 finally:

14378 self.exitRule()

14379 return localctx

14380

14381

14382 class Accessor_modifierContext(ParserRuleContext):

14383 __slots__ = 'parser'

14384

14385 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

14386 super().__init__(parent, invokingState)

14387 self.parser = parser

14388

14389 def PROTECTED(self):

14390 return self.getToken(CSharpParser.PROTECTED, 0)

14391

14392 def INTERNAL(self):

14393 return self.getToken(CSharpParser.INTERNAL, 0)

14394

14395 def PRIVATE(self):

14396 return self.getToken(CSharpParser.PRIVATE, 0)

14397

14398 def getRuleIndex(self):

14399 return CSharpParser.RULE_accessor_modifier

14400

14401 def enterRule(self, listener:ParseTreeListener):

14402 if hasattr( listener, "enterAccessor_modifier" ):

14403 listener.enterAccessor_modifier(self)

14404

14405 def exitRule(self, listener:ParseTreeListener):

14406 if hasattr( listener, "exitAccessor_modifier" ):

14407 listener.exitAccessor_modifier(self)

14412 def accessor_modifier(self):

14413

14414 localctx = CSharpParser.Accessor_modifierContext(self, self._ctx, self.state)

14415 self.enterRule(localctx, 296, self.RULE_accessor_modifier)

14416 try:

14417 self.state = 1914

14418 self._errHandler.sync(self)

14419 la_ = self._interp.adaptivePredict(self._input,225,self._ctx)

14420 if la_ == 1:

14421 self.enterOuterAlt(localctx, 1)

14422 self.state = 1907

14423 self.match(CSharpParser.PROTECTED)

14424 pass

14425

14426 elif la_ == 2:

14427 self.enterOuterAlt(localctx, 2)

14428 self.state = 1908

14429 self.match(CSharpParser.INTERNAL)

14430 pass

14431

14432 elif la_ == 3:

14433 self.enterOuterAlt(localctx, 3)

14434 self.state = 1909

14435 self.match(CSharpParser.PRIVATE)

14436 pass

14437

14438 elif la_ == 4:

14439 self.enterOuterAlt(localctx, 4)

14440 self.state = 1910

14441 self.match(CSharpParser.PROTECTED)

14442 self.state = 1911

14443 self.match(CSharpParser.INTERNAL)

14444 pass

14445

14446 elif la_ == 5:

14447 self.enterOuterAlt(localctx, 5)

14448 self.state = 1912

14449 self.match(CSharpParser.INTERNAL)

14450 self.state = 1913

14451 self.match(CSharpParser.PROTECTED)

14452 pass

14453

14454

14455 except RecognitionException as re:

14456 localctx.exception = re

14457 self._errHandler.reportError(self, re)

14458 self._errHandler.recover(self, re)

14459 finally:

14460 self.exitRule()

14461 return localctx

14462

14463

14464 class Accessor_bodyContext(ParserRuleContext):

14465 __slots__ = 'parser'

14466

14467 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

14468 super().__init__(parent, invokingState)

14469 self.parser = parser

14470

14471 def block(self):

14472 return self.getTypedRuleContext(CSharpParser.BlockContext,0)

14473

14474

14475 def SEMICOLON(self):

14476 return self.getToken(CSharpParser.SEMICOLON, 0)

14477

14478 def getRuleIndex(self):

14479 return CSharpParser.RULE_accessor_body

14480

14481 def enterRule(self, listener:ParseTreeListener):

14482 if hasattr( listener, "enterAccessor_body" ):

14483 listener.enterAccessor_body(self)

14484

14485 def exitRule(self, listener:ParseTreeListener):

14486 if hasattr( listener, "exitAccessor_body" ):

14487 listener.exitAccessor_body(self)

14492 def accessor_body(self):

14493

14494 localctx = CSharpParser.Accessor_bodyContext(self, self._ctx, self.state)

14495 self.enterRule(localctx, 298, self.RULE_accessor_body)

14496 try:

14497 self.state = 1918

14498 self._errHandler.sync(self)

14499 token = self._input.LA(1)

14500 if token in [CSharpParser.OPEN_BRACE]:

14501 self.enterOuterAlt(localctx, 1)

14502 self.state = 1916

14503 self.block()

14504 pass

14505 elif token in [CSharpParser.SEMICOLON]:

14506 self.enterOuterAlt(localctx, 2)

14507 self.state = 1917

14508 self.match(CSharpParser.SEMICOLON)

14509 pass

14510 else:

14511 raise NoViableAltException(self)

14512

14513 except RecognitionException as re:

14514 localctx.exception = re

14515 self._errHandler.reportError(self, re)

14516 self._errHandler.recover(self, re)

14517 finally:

14518 self.exitRule()

14519 return localctx

14520

14521

14522 class Event_accessor_declarationsContext(ParserRuleContext):

14523 __slots__ = 'parser'

14524

14525 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

14526 super().__init__(parent, invokingState)

14527 self.parser = parser

14528

14529 def ADD(self):

14530 return self.getToken(CSharpParser.ADD, 0)

14531

14532 def block(self):

14533 return self.getTypedRuleContext(CSharpParser.BlockContext,0)

14534

14535

14536 def remove_accessor_declaration(self):

14537 return self.getTypedRuleContext(CSharpParser.Remove_accessor_declarationContext,0)

14538

14539

14540 def REMOVE(self):

14541 return self.getToken(CSharpParser.REMOVE, 0)

14542

14543 def add_accessor_declaration(self):

14544 return self.getTypedRuleContext(CSharpParser.Add_accessor_declarationContext,0)

14545

14546

14547 def attributes(self):

14548 return self.getTypedRuleContext(CSharpParser.AttributesContext,0)

14549

14550

14551 def getRuleIndex(self):

14552 return CSharpParser.RULE_event_accessor_declarations

14553

14554 def enterRule(self, listener:ParseTreeListener):

14555 if hasattr( listener, "enterEvent_accessor_declarations" ):

14556 listener.enterEvent_accessor_declarations(self)

14557

14558 def exitRule(self, listener:ParseTreeListener):

14559 if hasattr( listener, "exitEvent_accessor_declarations" ):

14560 listener.exitEvent_accessor_declarations(self)

14565 def event_accessor_declarations(self):

14566

14567 localctx = CSharpParser.Event_accessor_declarationsContext(self, self._ctx, self.state)

14568 self.enterRule(localctx, 300, self.RULE_event_accessor_declarations)

14569 self._la = 0 # Token type

14570 try:

14571 self.enterOuterAlt(localctx, 1)

14572 self.state = 1921

14573 self._errHandler.sync(self)

14574 _la = self._input.LA(1)

14575 if _la==CSharpParser.OPEN_BRACKET:

14576 self.state = 1920

14577 self.attributes()

14578

14579

14580 self.state = 1931

14581 self._errHandler.sync(self)

14582 token = self._input.LA(1)

14583 if token in [CSharpParser.ADD]:

14584 self.state = 1923

14585 self.match(CSharpParser.ADD)

14586 self.state = 1924

14587 self.block()

14588 self.state = 1925

14589 self.remove_accessor_declaration()

14590 pass

14591 elif token in [CSharpParser.REMOVE]:

14592 self.state = 1927

14593 self.match(CSharpParser.REMOVE)

14594 self.state = 1928

14595 self.block()

14596 self.state = 1929

14597 self.add_accessor_declaration()

14598 pass

14599 else:

14600 raise NoViableAltException(self)

14601

14602 except RecognitionException as re:

14603 localctx.exception = re

14604 self._errHandler.reportError(self, re)

14605 self._errHandler.recover(self, re)

14606 finally:

14607 self.exitRule()

14608 return localctx

14609

14610

14611 class Add_accessor_declarationContext(ParserRuleContext):

14612 __slots__ = 'parser'

14613

14614 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

14615 super().__init__(parent, invokingState)

14616 self.parser = parser

14617

14618 def ADD(self):

14619 return self.getToken(CSharpParser.ADD, 0)

14620

14621 def block(self):

14622 return self.getTypedRuleContext(CSharpParser.BlockContext,0)

14623

14624

14625 def attributes(self):

14626 return self.getTypedRuleContext(CSharpParser.AttributesContext,0)

14627

14628

14629 def getRuleIndex(self):

14630 return CSharpParser.RULE_add_accessor_declaration

14631

14632 def enterRule(self, listener:ParseTreeListener):

14633 if hasattr( listener, "enterAdd_accessor_declaration" ):

14634 listener.enterAdd_accessor_declaration(self)

14635

14636 def exitRule(self, listener:ParseTreeListener):

14637 if hasattr( listener, "exitAdd_accessor_declaration" ):

14638 listener.exitAdd_accessor_declaration(self)

14643 def add_accessor_declaration(self):

14644

14645 localctx = CSharpParser.Add_accessor_declarationContext(self, self._ctx, self.state)

14646 self.enterRule(localctx, 302, self.RULE_add_accessor_declaration)

14647 self._la = 0 # Token type

14648 try:

14649 self.enterOuterAlt(localctx, 1)

14650 self.state = 1934

14651 self._errHandler.sync(self)

14652 _la = self._input.LA(1)

14653 if _la==CSharpParser.OPEN_BRACKET:

14654 self.state = 1933

14655 self.attributes()

14656

14657

14658 self.state = 1936

14659 self.match(CSharpParser.ADD)

14660 self.state = 1937

14661 self.block()

14662 except RecognitionException as re:

14663 localctx.exception = re

14664 self._errHandler.reportError(self, re)

14665 self._errHandler.recover(self, re)

14666 finally:

14667 self.exitRule()

14668 return localctx

14669

14670

14671 class Remove_accessor_declarationContext(ParserRuleContext):

14672 __slots__ = 'parser'

14673

14674 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

14675 super().__init__(parent, invokingState)

14676 self.parser = parser

14677

14678 def REMOVE(self):

14679 return self.getToken(CSharpParser.REMOVE, 0)

14680

14681 def block(self):

14682 return self.getTypedRuleContext(CSharpParser.BlockContext,0)

14683

14684

14685 def attributes(self):

14686 return self.getTypedRuleContext(CSharpParser.AttributesContext,0)

14687

14688

14689 def getRuleIndex(self):

14690 return CSharpParser.RULE_remove_accessor_declaration

14691

14692 def enterRule(self, listener:ParseTreeListener):

14693 if hasattr( listener, "enterRemove_accessor_declaration" ):

14694 listener.enterRemove_accessor_declaration(self)

14695

14696 def exitRule(self, listener:ParseTreeListener):

14697 if hasattr( listener, "exitRemove_accessor_declaration" ):

14698 listener.exitRemove_accessor_declaration(self)

14703 def remove_accessor_declaration(self):

14704

14705 localctx = CSharpParser.Remove_accessor_declarationContext(self, self._ctx, self.state)

14706 self.enterRule(localctx, 304, self.RULE_remove_accessor_declaration)

14707 self._la = 0 # Token type

14708 try:

14709 self.enterOuterAlt(localctx, 1)

14710 self.state = 1940

14711 self._errHandler.sync(self)

14712 _la = self._input.LA(1)

14713 if _la==CSharpParser.OPEN_BRACKET:

14714 self.state = 1939

14715 self.attributes()

14716

14717

14718 self.state = 1942

14719 self.match(CSharpParser.REMOVE)

14720 self.state = 1943

14721 self.block()

14722 except RecognitionException as re:

14723 localctx.exception = re

14724 self._errHandler.reportError(self, re)

14725 self._errHandler.recover(self, re)

14726 finally:

14727 self.exitRule()

14728 return localctx

14729

14730

14731 class Overloadable_operatorContext(ParserRuleContext):

14732 __slots__ = 'parser'

14733

14734 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

14735 super().__init__(parent, invokingState)

14736 self.parser = parser

14737

14738 def PLUS(self):

14739 return self.getToken(CSharpParser.PLUS, 0)

14740

14741 def MINUS(self):

14742 return self.getToken(CSharpParser.MINUS, 0)

14743

14744 def BANG(self):

14745 return self.getToken(CSharpParser.BANG, 0)

14746

14747 def TILDE(self):

14748 return self.getToken(CSharpParser.TILDE, 0)

14749

14750 def OP_INC(self):

14751 return self.getToken(CSharpParser.OP_INC, 0)

14752

14753 def OP_DEC(self):

14754 return self.getToken(CSharpParser.OP_DEC, 0)

14755

14756 def TRUE(self):

14757 return self.getToken(CSharpParser.TRUE, 0)

14758

14759 def FALSE(self):

14760 return self.getToken(CSharpParser.FALSE, 0)

14761

14762 def STAR(self):

14763 return self.getToken(CSharpParser.STAR, 0)

14764

14765 def DIV(self):

14766 return self.getToken(CSharpParser.DIV, 0)

14767

14768 def PERCENT(self):

14769 return self.getToken(CSharpParser.PERCENT, 0)

14770

14771 def AMP(self):

14772 return self.getToken(CSharpParser.AMP, 0)

14773

14774 def BITWISE_OR(self):

14775 return self.getToken(CSharpParser.BITWISE_OR, 0)

14776

14777 def CARET(self):

14778 return self.getToken(CSharpParser.CARET, 0)

14779

14780 def OP_LEFT_SHIFT(self):

14781 return self.getToken(CSharpParser.OP_LEFT_SHIFT, 0)

14782

14783 def right_shift(self):

14784 return self.getTypedRuleContext(CSharpParser.Right_shiftContext,0)

14785

14786

14787 def OP_EQ(self):

14788 return self.getToken(CSharpParser.OP_EQ, 0)

14789

14790 def OP_NE(self):

14791 return self.getToken(CSharpParser.OP_NE, 0)

14792

14793 def GT(self):

14794 return self.getToken(CSharpParser.GT, 0)

14795

14796 def LT(self):

14797 return self.getToken(CSharpParser.LT, 0)

14798

14799 def OP_GE(self):

14800 return self.getToken(CSharpParser.OP_GE, 0)

14801

14802 def OP_LE(self):

14803 return self.getToken(CSharpParser.OP_LE, 0)

14804

14805 def getRuleIndex(self):

14806 return CSharpParser.RULE_overloadable_operator

14807

14808 def enterRule(self, listener:ParseTreeListener):

14809 if hasattr( listener, "enterOverloadable_operator" ):

14810 listener.enterOverloadable_operator(self)

14811

14812 def exitRule(self, listener:ParseTreeListener):

14813 if hasattr( listener, "exitOverloadable_operator" ):

14814 listener.exitOverloadable_operator(self)

14819 def overloadable_operator(self):

14820

14821 localctx = CSharpParser.Overloadable_operatorContext(self, self._ctx, self.state)

14822 self.enterRule(localctx, 306, self.RULE_overloadable_operator)

14823 try:

14824 self.state = 1967

14825 self._errHandler.sync(self)

14826 la_ = self._interp.adaptivePredict(self._input,231,self._ctx)

14827 if la_ == 1:

14828 self.enterOuterAlt(localctx, 1)

14829 self.state = 1945

14830 self.match(CSharpParser.PLUS)

14831 pass

14832

14833 elif la_ == 2:

14834 self.enterOuterAlt(localctx, 2)

14835 self.state = 1946

14836 self.match(CSharpParser.MINUS)

14837 pass

14838

14839 elif la_ == 3:

14840 self.enterOuterAlt(localctx, 3)

14841 self.state = 1947

14842 self.match(CSharpParser.BANG)

14843 pass

14844

14845 elif la_ == 4:

14846 self.enterOuterAlt(localctx, 4)

14847 self.state = 1948

14848 self.match(CSharpParser.TILDE)

14849 pass

14850

14851 elif la_ == 5:

14852 self.enterOuterAlt(localctx, 5)

14853 self.state = 1949

14854 self.match(CSharpParser.OP_INC)

14855 pass

14856

14857 elif la_ == 6:

14858 self.enterOuterAlt(localctx, 6)

14859 self.state = 1950

14860 self.match(CSharpParser.OP_DEC)

14861 pass

14862

14863 elif la_ == 7:

14864 self.enterOuterAlt(localctx, 7)

14865 self.state = 1951

14866 self.match(CSharpParser.TRUE)

14867 pass

14868

14869 elif la_ == 8:

14870 self.enterOuterAlt(localctx, 8)

14871 self.state = 1952

14872 self.match(CSharpParser.FALSE)

14873 pass

14874

14875 elif la_ == 9:

14876 self.enterOuterAlt(localctx, 9)

14877 self.state = 1953

14878 self.match(CSharpParser.STAR)

14879 pass

14880

14881 elif la_ == 10:

14882 self.enterOuterAlt(localctx, 10)

14883 self.state = 1954

14884 self.match(CSharpParser.DIV)

14885 pass

14886

14887 elif la_ == 11:

14888 self.enterOuterAlt(localctx, 11)

14889 self.state = 1955

14890 self.match(CSharpParser.PERCENT)

14891 pass

14892

14893 elif la_ == 12:

14894 self.enterOuterAlt(localctx, 12)

14895 self.state = 1956

14896 self.match(CSharpParser.AMP)

14897 pass

14898

14899 elif la_ == 13:

14900 self.enterOuterAlt(localctx, 13)

14901 self.state = 1957

14902 self.match(CSharpParser.BITWISE_OR)

14903 pass

14904

14905 elif la_ == 14:

14906 self.enterOuterAlt(localctx, 14)

14907 self.state = 1958

14908 self.match(CSharpParser.CARET)

14909 pass

14910

14911 elif la_ == 15:

14912 self.enterOuterAlt(localctx, 15)

14913 self.state = 1959

14914 self.match(CSharpParser.OP_LEFT_SHIFT)

14915 pass

14916

14917 elif la_ == 16:

14918 self.enterOuterAlt(localctx, 16)

14919 self.state = 1960

14920 self.right_shift()

14921 pass

14922

14923 elif la_ == 17:

14924 self.enterOuterAlt(localctx, 17)

14925 self.state = 1961

14926 self.match(CSharpParser.OP_EQ)

14927 pass

14928

14929 elif la_ == 18:

14930 self.enterOuterAlt(localctx, 18)

14931 self.state = 1962

14932 self.match(CSharpParser.OP_NE)

14933 pass

14934

14935 elif la_ == 19:

14936 self.enterOuterAlt(localctx, 19)

14937 self.state = 1963

14938 self.match(CSharpParser.GT)

14939 pass

14940

14941 elif la_ == 20:

14942 self.enterOuterAlt(localctx, 20)

14943 self.state = 1964

14944 self.match(CSharpParser.LT)

14945 pass

14946

14947 elif la_ == 21:

14948 self.enterOuterAlt(localctx, 21)

14949 self.state = 1965

14950 self.match(CSharpParser.OP_GE)

14951 pass

14952

14953 elif la_ == 22:

14954 self.enterOuterAlt(localctx, 22)

14955 self.state = 1966

14956 self.match(CSharpParser.OP_LE)

14957 pass

14958

14959

14960 except RecognitionException as re:

14961 localctx.exception = re

14962 self._errHandler.reportError(self, re)

14963 self._errHandler.recover(self, re)

14964 finally:

14965 self.exitRule()

14966 return localctx

14967

14968

14969 class Conversion_operator_declaratorContext(ParserRuleContext):

14970 __slots__ = 'parser'

14971

14972 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

14973 super().__init__(parent, invokingState)

14974 self.parser = parser

14975

14976 def OPERATOR(self):

14977 return self.getToken(CSharpParser.OPERATOR, 0)

14978

14979 def type_(self):

14980 return self.getTypedRuleContext(CSharpParser.Type_Context,0)

14981

14982

14983 def OPEN_PARENS(self):

14984 return self.getToken(CSharpParser.OPEN_PARENS, 0)

14985

14986 def arg_declaration(self):

14987 return self.getTypedRuleContext(CSharpParser.Arg_declarationContext,0)

14988

14989

14990 def CLOSE_PARENS(self):

14991 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

14992

14993 def IMPLICIT(self):

14994 return self.getToken(CSharpParser.IMPLICIT, 0)

14995

14996 def EXPLICIT(self):

14997 return self.getToken(CSharpParser.EXPLICIT, 0)

14998

14999 def getRuleIndex(self):

15000 return CSharpParser.RULE_conversion_operator_declarator

15001

15002 def enterRule(self, listener:ParseTreeListener):

15003 if hasattr( listener, "enterConversion_operator_declarator" ):

15004 listener.enterConversion_operator_declarator(self)

15005

15006 def exitRule(self, listener:ParseTreeListener):

15007 if hasattr( listener, "exitConversion_operator_declarator" ):

15008 listener.exitConversion_operator_declarator(self)

15013 def conversion_operator_declarator(self):

15014

15015 localctx = CSharpParser.Conversion_operator_declaratorContext(self, self._ctx, self.state)

15016 self.enterRule(localctx, 308, self.RULE_conversion_operator_declarator)

15017 self._la = 0 # Token type

15018 try:

15019 self.enterOuterAlt(localctx, 1)

15020 self.state = 1969

15021 _la = self._input.LA(1)

15022 if not(_la==CSharpParser.EXPLICIT or _la==CSharpParser.IMPLICIT):

15023 self._errHandler.recoverInline(self)

15024 else:

15025 self._errHandler.reportMatch(self)

15026 self.consume()

15027 self.state = 1970

15028 self.match(CSharpParser.OPERATOR)

15029 self.state = 1971

15030 self.type_()

15031 self.state = 1972

15032 self.match(CSharpParser.OPEN_PARENS)

15033 self.state = 1973

15034 self.arg_declaration()

15035 self.state = 1974

15036 self.match(CSharpParser.CLOSE_PARENS)

15037 except RecognitionException as re:

15038 localctx.exception = re

15039 self._errHandler.reportError(self, re)

15040 self._errHandler.recover(self, re)

15041 finally:

15042 self.exitRule()

15043 return localctx

15044

15045

15046 class Constructor_initializerContext(ParserRuleContext):

15047 __slots__ = 'parser'

15048

15049 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

15050 super().__init__(parent, invokingState)

15051 self.parser = parser

15052

15053 def COLON(self):

15054 return self.getToken(CSharpParser.COLON, 0)

15055

15056 def OPEN_PARENS(self):

15057 return self.getToken(CSharpParser.OPEN_PARENS, 0)

15058

15059 def CLOSE_PARENS(self):

15060 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

15061

15062 def BASE(self):

15063 return self.getToken(CSharpParser.BASE, 0)

15064

15065 def THIS(self):

15066 return self.getToken(CSharpParser.THIS, 0)

15067

15068 def argument_list(self):

15069 return self.getTypedRuleContext(CSharpParser.Argument_listContext,0)

15070

15071

15072 def getRuleIndex(self):

15073 return CSharpParser.RULE_constructor_initializer

15074

15075 def enterRule(self, listener:ParseTreeListener):

15076 if hasattr( listener, "enterConstructor_initializer" ):

15077 listener.enterConstructor_initializer(self)

15078

15079 def exitRule(self, listener:ParseTreeListener):

15080 if hasattr( listener, "exitConstructor_initializer" ):

15081 listener.exitConstructor_initializer(self)

15086 def constructor_initializer(self):

15087

15088 localctx = CSharpParser.Constructor_initializerContext(self, self._ctx, self.state)

15089 self.enterRule(localctx, 310, self.RULE_constructor_initializer)

15090 self._la = 0 # Token type

15091 try:

15092 self.enterOuterAlt(localctx, 1)

15093 self.state = 1976

15094 self.match(CSharpParser.COLON)

15095 self.state = 1977

15096 _la = self._input.LA(1)

15097 if not(_la==CSharpParser.BASE or _la==CSharpParser.THIS):

15098 self._errHandler.recoverInline(self)

15099 else:

15100 self._errHandler.reportMatch(self)

15101 self.consume()

15102 self.state = 1978

15103 self.match(CSharpParser.OPEN_PARENS)

15104 self.state = 1980

15105 self._errHandler.sync(self)

15106 _la = self._input.LA(1)

15108 self.state = 1979

15109 self.argument_list()

15110

15111

15112 self.state = 1982

15113 self.match(CSharpParser.CLOSE_PARENS)

15114 except RecognitionException as re:

15115 localctx.exception = re

15116 self._errHandler.reportError(self, re)

15117 self._errHandler.recover(self, re)

15118 finally:

15119 self.exitRule()

15120 return localctx

15121

15122

15123 class BodyContext(ParserRuleContext):

15124 __slots__ = 'parser'

15125

15126 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

15127 super().__init__(parent, invokingState)

15128 self.parser = parser

15129

15130 def block(self):

15131 return self.getTypedRuleContext(CSharpParser.BlockContext,0)

15132

15133

15134 def SEMICOLON(self):

15135 return self.getToken(CSharpParser.SEMICOLON, 0)

15136

15137 def getRuleIndex(self):

15138 return CSharpParser.RULE_body

15139

15140 def enterRule(self, listener:ParseTreeListener):

15141 if hasattr( listener, "enterBody" ):

15142 listener.enterBody(self)

15143

15144 def exitRule(self, listener:ParseTreeListener):

15145 if hasattr( listener, "exitBody" ):

15146 listener.exitBody(self)

15151 def body(self):

15152

15153 localctx = CSharpParser.BodyContext(self, self._ctx, self.state)

15154 self.enterRule(localctx, 312, self.RULE_body)

15155 try:

15156 self.state = 1986

15157 self._errHandler.sync(self)

15158 token = self._input.LA(1)

15159 if token in [CSharpParser.OPEN_BRACE]:

15160 self.enterOuterAlt(localctx, 1)

15161 self.state = 1984

15162 self.block()

15163 pass

15164 elif token in [CSharpParser.SEMICOLON]:

15165 self.enterOuterAlt(localctx, 2)

15166 self.state = 1985

15167 self.match(CSharpParser.SEMICOLON)

15168 pass

15169 else:

15170 raise NoViableAltException(self)

15171

15172 except RecognitionException as re:

15173 localctx.exception = re

15174 self._errHandler.reportError(self, re)

15175 self._errHandler.recover(self, re)

15176 finally:

15177 self.exitRule()

15178 return localctx

15179

15180

15181 class Struct_interfacesContext(ParserRuleContext):

15182 __slots__ = 'parser'

15183

15184 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

15185 super().__init__(parent, invokingState)

15186 self.parser = parser

15187

15188 def COLON(self):

15189 return self.getToken(CSharpParser.COLON, 0)

15190

15191 def interface_type_list(self):

15192 return self.getTypedRuleContext(CSharpParser.Interface_type_listContext,0)

15193

15194

15195 def getRuleIndex(self):

15196 return CSharpParser.RULE_struct_interfaces

15197

15198 def enterRule(self, listener:ParseTreeListener):

15199 if hasattr( listener, "enterStruct_interfaces" ):

15200 listener.enterStruct_interfaces(self)

15201

15202 def exitRule(self, listener:ParseTreeListener):

15203 if hasattr( listener, "exitStruct_interfaces" ):

15204 listener.exitStruct_interfaces(self)

15209 def struct_interfaces(self):

15210

15211 localctx = CSharpParser.Struct_interfacesContext(self, self._ctx, self.state)

15212 self.enterRule(localctx, 314, self.RULE_struct_interfaces)

15213 try:

15214 self.enterOuterAlt(localctx, 1)

15215 self.state = 1988

15216 self.match(CSharpParser.COLON)

15217 self.state = 1989

15218 self.interface_type_list()

15219 except RecognitionException as re:

15220 localctx.exception = re

15221 self._errHandler.reportError(self, re)

15222 self._errHandler.recover(self, re)

15223 finally:

15224 self.exitRule()

15225 return localctx

15226

15227

15228 class Struct_bodyContext(ParserRuleContext):

15229 __slots__ = 'parser'

15230

15231 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

15232 super().__init__(parent, invokingState)

15233 self.parser = parser

15234

15235 def OPEN_BRACE(self):

15236 return self.getToken(CSharpParser.OPEN_BRACE, 0)

15237

15238 def CLOSE_BRACE(self):

15239 return self.getToken(CSharpParser.CLOSE_BRACE, 0)

15240

15241 def struct_member_declaration(self, i:int=None):

15242 if i is None:

15243 return self.getTypedRuleContexts(CSharpParser.Struct_member_declarationContext)

15244 else:

15245 return self.getTypedRuleContext(CSharpParser.Struct_member_declarationContext,i)

15246

15247

15248 def getRuleIndex(self):

15249 return CSharpParser.RULE_struct_body

15250

15251 def enterRule(self, listener:ParseTreeListener):

15252 if hasattr( listener, "enterStruct_body" ):

15253 listener.enterStruct_body(self)

15254

15255 def exitRule(self, listener:ParseTreeListener):

15256 if hasattr( listener, "exitStruct_body" ):

15257 listener.exitStruct_body(self)

15262 def struct_body(self):

15263

15264 localctx = CSharpParser.Struct_bodyContext(self, self._ctx, self.state)

15265 self.enterRule(localctx, 316, self.RULE_struct_body)

15266 self._la = 0 # Token type

15267 try:

15268 self.enterOuterAlt(localctx, 1)

15269 self.state = 1991

15270 self.match(CSharpParser.OPEN_BRACE)

15271 self.state = 1995

15272 self._errHandler.sync(self)

15273 _la = self._input.LA(1)

15275 self.state = 1992

15276 self.struct_member_declaration()

15277 self.state = 1997

15278 self._errHandler.sync(self)

15279 _la = self._input.LA(1)

15280

15281 self.state = 1998

15282 self.match(CSharpParser.CLOSE_BRACE)

15283 except RecognitionException as re:

15284 localctx.exception = re

15285 self._errHandler.reportError(self, re)

15286 self._errHandler.recover(self, re)

15287 finally:

15288 self.exitRule()

15289 return localctx

15290

15291

15292 class Struct_member_declarationContext(ParserRuleContext):

15293 __slots__ = 'parser'

15294

15295 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

15296 super().__init__(parent, invokingState)

15297 self.parser = parser

15298

15299 def common_member_declaration(self):

15300 return self.getTypedRuleContext(CSharpParser.Common_member_declarationContext,0)

15301

15302

15303 def FIXED(self):

15304 return self.getToken(CSharpParser.FIXED, 0)

15305

15306 def type_(self):

15307 return self.getTypedRuleContext(CSharpParser.Type_Context,0)

15308

15309

15310 def SEMICOLON(self):

15311 return self.getToken(CSharpParser.SEMICOLON, 0)

15312

15313 def attributes(self):

15314 return self.getTypedRuleContext(CSharpParser.AttributesContext,0)

15315

15316

15317 def all_member_modifiers(self):

15318 return self.getTypedRuleContext(CSharpParser.All_member_modifiersContext,0)

15319

15320

15321 def fixed_size_buffer_declarator(self, i:int=None):

15322 if i is None:

15323 return self.getTypedRuleContexts(CSharpParser.Fixed_size_buffer_declaratorContext)

15324 else:

15325 return self.getTypedRuleContext(CSharpParser.Fixed_size_buffer_declaratorContext,i)

15326

15327

15328 def getRuleIndex(self):

15329 return CSharpParser.RULE_struct_member_declaration

15330

15331 def enterRule(self, listener:ParseTreeListener):

15332 if hasattr( listener, "enterStruct_member_declaration" ):

15333 listener.enterStruct_member_declaration(self)

15334

15335 def exitRule(self, listener:ParseTreeListener):

15336 if hasattr( listener, "exitStruct_member_declaration" ):

15337 listener.exitStruct_member_declaration(self)

15342 def struct_member_declaration(self):

15343

15344 localctx = CSharpParser.Struct_member_declarationContext(self, self._ctx, self.state)

15345 self.enterRule(localctx, 318, self.RULE_struct_member_declaration)

15346 self._la = 0 # Token type

15347 try:

15348 self.enterOuterAlt(localctx, 1)

15349 self.state = 2001

15350 self._errHandler.sync(self)

15351 _la = self._input.LA(1)

15352 if _la==CSharpParser.OPEN_BRACKET:

15353 self.state = 2000

15354 self.attributes()

15355

15356

15357 self.state = 2004

15358 self._errHandler.sync(self)

15359 la_ = self._interp.adaptivePredict(self._input,236,self._ctx)

15360 if la_ == 1:

15361 self.state = 2003

15362 self.all_member_modifiers()

15363

15364

15365 self.state = 2016

15366 self._errHandler.sync(self)

15367 token = self._input.LA(1)

15368 if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CLASS, CSharpParser.CONST, CSharpParser.DECIMAL, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.ENUM, CSharpParser.EQUALS, CSharpParser.EVENT, CSharpParser.EXPLICIT, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.IMPLICIT, CSharpParser.INT, CSharpParser.INTERFACE, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.READONLY, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.STRING, CSharpParser.STRUCT, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.VOID, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.OPEN_PARENS]:

15369 self.state = 2006

15370 self.common_member_declaration()

15371 pass

15372 elif token in [CSharpParser.FIXED]:

15373 self.state = 2007

15374 self.match(CSharpParser.FIXED)

15375 self.state = 2008

15376 self.type_()

15377 self.state = 2010

15378 self._errHandler.sync(self)

15379 _la = self._input.LA(1)

15380 while True:

15381 self.state = 2009

15382 self.fixed_size_buffer_declarator()

15383 self.state = 2012

15384 self._errHandler.sync(self)

15385 _la = self._input.LA(1)

15387 break

15388

15389 self.state = 2014

15390 self.match(CSharpParser.SEMICOLON)

15391 pass

15392 else:

15393 raise NoViableAltException(self)

15394

15395 except RecognitionException as re:

15396 localctx.exception = re

15397 self._errHandler.reportError(self, re)

15398 self._errHandler.recover(self, re)

15399 finally:

15400 self.exitRule()

15401 return localctx

15402

15403

15404 class Array_typeContext(ParserRuleContext):

15405 __slots__ = 'parser'

15406

15407 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

15408 super().__init__(parent, invokingState)

15409 self.parser = parser

15410

15411 def base_type(self):

15412 return self.getTypedRuleContext(CSharpParser.Base_typeContext,0)

15413

15414

15415 def rank_specifier(self, i:int=None):

15416 if i is None:

15417 return self.getTypedRuleContexts(CSharpParser.Rank_specifierContext)

15418 else:

15419 return self.getTypedRuleContext(CSharpParser.Rank_specifierContext,i)

15420

15421

15422 def STAR(self, i:int=None):

15423 if i is None:

15424 return self.getTokens(CSharpParser.STAR)

15425 else:

15426 return self.getToken(CSharpParser.STAR, i)

15427

15428 def INTERR(self, i:int=None):

15429 if i is None:

15430 return self.getTokens(CSharpParser.INTERR)

15431 else:

15432 return self.getToken(CSharpParser.INTERR, i)

15433

15434 def getRuleIndex(self):

15435 return CSharpParser.RULE_array_type

15436

15437 def enterRule(self, listener:ParseTreeListener):

15438 if hasattr( listener, "enterArray_type" ):

15439 listener.enterArray_type(self)

15440

15441 def exitRule(self, listener:ParseTreeListener):

15442 if hasattr( listener, "exitArray_type" ):

15443 listener.exitArray_type(self)

15448 def array_type(self):

15449

15450 localctx = CSharpParser.Array_typeContext(self, self._ctx, self.state)

15451 self.enterRule(localctx, 320, self.RULE_array_type)

15452 self._la = 0 # Token type

15453 try:

15454 self.enterOuterAlt(localctx, 1)

15455 self.state = 2018

15456 self.base_type()

15457 self.state = 2026

15458 self._errHandler.sync(self)

15459 _la = self._input.LA(1)

15460 while True:

15461 self.state = 2022

15462 self._errHandler.sync(self)

15463 _la = self._input.LA(1)

15464 while _la==CSharpParser.STAR or _la==CSharpParser.INTERR:

15465 self.state = 2019

15466 _la = self._input.LA(1)

15467 if not(_la==CSharpParser.STAR or _la==CSharpParser.INTERR):

15468 self._errHandler.recoverInline(self)

15469 else:

15470 self._errHandler.reportMatch(self)

15471 self.consume()

15472 self.state = 2024

15473 self._errHandler.sync(self)

15474 _la = self._input.LA(1)

15475

15476 self.state = 2025

15477 self.rank_specifier()

15478 self.state = 2028

15479 self._errHandler.sync(self)

15480 _la = self._input.LA(1)

15481 if not (((((_la - 127)) & ~0x3f) == 0 and ((1 << (_la - 127)) & ((1 << (CSharpParser.OPEN_BRACKET - 127)) | (1 << (CSharpParser.STAR - 127)) | (1 << (CSharpParser.INTERR - 127)))) != 0)):

15482 break

15483

15484 except RecognitionException as re:

15485 localctx.exception = re

15486 self._errHandler.reportError(self, re)

15487 self._errHandler.recover(self, re)

15488 finally:

15489 self.exitRule()

15490 return localctx

15491

15492

15493 class Rank_specifierContext(ParserRuleContext):

15494 __slots__ = 'parser'

15495

15496 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

15497 super().__init__(parent, invokingState)

15498 self.parser = parser

15499

15500 def OPEN_BRACKET(self):

15501 return self.getToken(CSharpParser.OPEN_BRACKET, 0)

15502

15503 def CLOSE_BRACKET(self):

15504 return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

15505

15506 def COMMA(self, i:int=None):

15507 if i is None:

15508 return self.getTokens(CSharpParser.COMMA)

15509 else:

15510 return self.getToken(CSharpParser.COMMA, i)

15511

15512 def getRuleIndex(self):

15513 return CSharpParser.RULE_rank_specifier

15514

15515 def enterRule(self, listener:ParseTreeListener):

15516 if hasattr( listener, "enterRank_specifier" ):

15517 listener.enterRank_specifier(self)

15518

15519 def exitRule(self, listener:ParseTreeListener):

15520 if hasattr( listener, "exitRank_specifier" ):

15521 listener.exitRank_specifier(self)

15526 def rank_specifier(self):

15527

15528 localctx = CSharpParser.Rank_specifierContext(self, self._ctx, self.state)

15529 self.enterRule(localctx, 322, self.RULE_rank_specifier)

15530 self._la = 0 # Token type

15531 try:

15532 self.enterOuterAlt(localctx, 1)

15533 self.state = 2030

15534 self.match(CSharpParser.OPEN_BRACKET)

15535 self.state = 2034

15536 self._errHandler.sync(self)

15537 _la = self._input.LA(1)

15538 while _la==CSharpParser.COMMA:

15539 self.state = 2031

15540 self.match(CSharpParser.COMMA)

15541 self.state = 2036

15542 self._errHandler.sync(self)

15543 _la = self._input.LA(1)

15544

15545 self.state = 2037

15546 self.match(CSharpParser.CLOSE_BRACKET)

15547 except RecognitionException as re:

15548 localctx.exception = re

15549 self._errHandler.reportError(self, re)

15550 self._errHandler.recover(self, re)

15551 finally:

15552 self.exitRule()

15553 return localctx

15554

15555

15556 class Array_initializerContext(ParserRuleContext):

15557 __slots__ = 'parser'

15558

15559 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

15560 super().__init__(parent, invokingState)

15561 self.parser = parser

15562

15563 def OPEN_BRACE(self):

15564 return self.getToken(CSharpParser.OPEN_BRACE, 0)

15565

15566 def CLOSE_BRACE(self):

15567 return self.getToken(CSharpParser.CLOSE_BRACE, 0)

15568

15569 def variable_initializer(self, i:int=None):

15570 if i is None:

15571 return self.getTypedRuleContexts(CSharpParser.Variable_initializerContext)

15572 else:

15573 return self.getTypedRuleContext(CSharpParser.Variable_initializerContext,i)

15574

15575

15576 def COMMA(self, i:int=None):

15577 if i is None:

15578 return self.getTokens(CSharpParser.COMMA)

15579 else:

15580 return self.getToken(CSharpParser.COMMA, i)

15581

15582 def getRuleIndex(self):

15583 return CSharpParser.RULE_array_initializer

15584

15585 def enterRule(self, listener:ParseTreeListener):

15586 if hasattr( listener, "enterArray_initializer" ):

15587 listener.enterArray_initializer(self)

15588

15589 def exitRule(self, listener:ParseTreeListener):

15590 if hasattr( listener, "exitArray_initializer" ):

15591 listener.exitArray_initializer(self)

15596 def array_initializer(self):

15597

15598 localctx = CSharpParser.Array_initializerContext(self, self._ctx, self.state)

15599 self.enterRule(localctx, 324, self.RULE_array_initializer)

15600 self._la = 0 # Token type

15601 try:

15602 self.enterOuterAlt(localctx, 1)

15603 self.state = 2039

15604 self.match(CSharpParser.OPEN_BRACE)

15605 self.state = 2051

15606 self._errHandler.sync(self)

15607 _la = self._input.LA(1)

15609 self.state = 2040

15610 self.variable_initializer()

15611 self.state = 2045

15612 self._errHandler.sync(self)

15613 _alt = self._interp.adaptivePredict(self._input,242,self._ctx)

15614 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

15615 if _alt==1:

15616 self.state = 2041

15617 self.match(CSharpParser.COMMA)

15618 self.state = 2042

15619 self.variable_initializer()

15620 self.state = 2047

15621 self._errHandler.sync(self)

15622 _alt = self._interp.adaptivePredict(self._input,242,self._ctx)

15623

15624 self.state = 2049

15625 self._errHandler.sync(self)

15626 _la = self._input.LA(1)

15627 if _la==CSharpParser.COMMA:

15628 self.state = 2048

15629 self.match(CSharpParser.COMMA)

15634 self.state = 2053

15635 self.match(CSharpParser.CLOSE_BRACE)

15636 except RecognitionException as re:

15637 localctx.exception = re

15638 self._errHandler.reportError(self, re)

15639 self._errHandler.recover(self, re)

15640 finally:

15641 self.exitRule()

15642 return localctx

15643

15644

15645 class Variant_type_parameter_listContext(ParserRuleContext):

15646 __slots__ = 'parser'

15647

15648 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

15649 super().__init__(parent, invokingState)

15650 self.parser = parser

15651

15652 def LT(self):

15653 return self.getToken(CSharpParser.LT, 0)

15654

15655 def variant_type_parameter(self, i:int=None):

15656 if i is None:

15657 return self.getTypedRuleContexts(CSharpParser.Variant_type_parameterContext)

15658 else:

15659 return self.getTypedRuleContext(CSharpParser.Variant_type_parameterContext,i)

15660

15661

15662 def GT(self):

15663 return self.getToken(CSharpParser.GT, 0)

15664

15665 def COMMA(self, i:int=None):

15666 if i is None:

15667 return self.getTokens(CSharpParser.COMMA)

15668 else:

15669 return self.getToken(CSharpParser.COMMA, i)

15670

15671 def getRuleIndex(self):

15672 return CSharpParser.RULE_variant_type_parameter_list

15673

15674 def enterRule(self, listener:ParseTreeListener):

15675 if hasattr( listener, "enterVariant_type_parameter_list" ):

15676 listener.enterVariant_type_parameter_list(self)

15677

15678 def exitRule(self, listener:ParseTreeListener):

15679 if hasattr( listener, "exitVariant_type_parameter_list" ):

15680 listener.exitVariant_type_parameter_list(self)

15685 def variant_type_parameter_list(self):

15686

15687 localctx = CSharpParser.Variant_type_parameter_listContext(self, self._ctx, self.state)

15688 self.enterRule(localctx, 326, self.RULE_variant_type_parameter_list)

15689 self._la = 0 # Token type

15690 try:

15691 self.enterOuterAlt(localctx, 1)

15692 self.state = 2055

15693 self.match(CSharpParser.LT)

15694 self.state = 2056

15695 self.variant_type_parameter()

15696 self.state = 2061

15697 self._errHandler.sync(self)

15698 _la = self._input.LA(1)

15699 while _la==CSharpParser.COMMA:

15700 self.state = 2057

15701 self.match(CSharpParser.COMMA)

15702 self.state = 2058

15703 self.variant_type_parameter()

15704 self.state = 2063

15705 self._errHandler.sync(self)

15706 _la = self._input.LA(1)

15707

15708 self.state = 2064

15709 self.match(CSharpParser.GT)

15710 except RecognitionException as re:

15711 localctx.exception = re

15712 self._errHandler.reportError(self, re)

15713 self._errHandler.recover(self, re)

15714 finally:

15715 self.exitRule()

15716 return localctx

15717

15718

15719 class Variant_type_parameterContext(ParserRuleContext):

15720 __slots__ = 'parser'

15721

15722 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

15723 super().__init__(parent, invokingState)

15724 self.parser = parser

15725

15726 def identifier(self):

15727 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

15728

15729

15730 def attributes(self):

15731 return self.getTypedRuleContext(CSharpParser.AttributesContext,0)

15732

15733

15734 def variance_annotation(self):

15735 return self.getTypedRuleContext(CSharpParser.Variance_annotationContext,0)

15736

15737

15738 def getRuleIndex(self):

15739 return CSharpParser.RULE_variant_type_parameter

15740

15741 def enterRule(self, listener:ParseTreeListener):

15742 if hasattr( listener, "enterVariant_type_parameter" ):

15743 listener.enterVariant_type_parameter(self)

15744

15745 def exitRule(self, listener:ParseTreeListener):

15746 if hasattr( listener, "exitVariant_type_parameter" ):

15747 listener.exitVariant_type_parameter(self)

15752 def variant_type_parameter(self):

15753

15754 localctx = CSharpParser.Variant_type_parameterContext(self, self._ctx, self.state)

15755 self.enterRule(localctx, 328, self.RULE_variant_type_parameter)

15756 self._la = 0 # Token type

15757 try:

15758 self.enterOuterAlt(localctx, 1)

15759 self.state = 2067

15760 self._errHandler.sync(self)

15761 _la = self._input.LA(1)

15762 if _la==CSharpParser.OPEN_BRACKET:

15763 self.state = 2066

15764 self.attributes()

15765

15766

15767 self.state = 2070

15768 self._errHandler.sync(self)

15769 _la = self._input.LA(1)

15770 if _la==CSharpParser.IN or _la==CSharpParser.OUT:

15771 self.state = 2069

15772 self.variance_annotation()

15773

15774

15775 self.state = 2072

15776 self.identifier()

15777 except RecognitionException as re:

15778 localctx.exception = re

15779 self._errHandler.reportError(self, re)

15780 self._errHandler.recover(self, re)

15781 finally:

15782 self.exitRule()

15783 return localctx

15784

15785

15786 class Variance_annotationContext(ParserRuleContext):

15787 __slots__ = 'parser'

15788

15789 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

15790 super().__init__(parent, invokingState)

15791 self.parser = parser

15792

15793 def IN(self):

15794 return self.getToken(CSharpParser.IN, 0)

15795

15796 def OUT(self):

15797 return self.getToken(CSharpParser.OUT, 0)

15798

15799 def getRuleIndex(self):

15800 return CSharpParser.RULE_variance_annotation

15801

15802 def enterRule(self, listener:ParseTreeListener):

15803 if hasattr( listener, "enterVariance_annotation" ):

15804 listener.enterVariance_annotation(self)

15805

15806 def exitRule(self, listener:ParseTreeListener):

15807 if hasattr( listener, "exitVariance_annotation" ):

15808 listener.exitVariance_annotation(self)

15813 def variance_annotation(self):

15814

15815 localctx = CSharpParser.Variance_annotationContext(self, self._ctx, self.state)

15816 self.enterRule(localctx, 330, self.RULE_variance_annotation)

15817 self._la = 0 # Token type

15818 try:

15819 self.enterOuterAlt(localctx, 1)

15820 self.state = 2074

15821 _la = self._input.LA(1)

15822 if not(_la==CSharpParser.IN or _la==CSharpParser.OUT):

15823 self._errHandler.recoverInline(self)

15824 else:

15825 self._errHandler.reportMatch(self)

15826 self.consume()

15827 except RecognitionException as re:

15828 localctx.exception = re

15829 self._errHandler.reportError(self, re)

15830 self._errHandler.recover(self, re)

15831 finally:

15832 self.exitRule()

15833 return localctx

15834

15835

15836 class Interface_baseContext(ParserRuleContext):

15837 __slots__ = 'parser'

15838

15839 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

15840 super().__init__(parent, invokingState)

15841 self.parser = parser

15842

15843 def COLON(self):

15844 return self.getToken(CSharpParser.COLON, 0)

15845

15846 def interface_type_list(self):

15847 return self.getTypedRuleContext(CSharpParser.Interface_type_listContext,0)

15848

15849

15850 def getRuleIndex(self):

15851 return CSharpParser.RULE_interface_base

15852

15853 def enterRule(self, listener:ParseTreeListener):

15854 if hasattr( listener, "enterInterface_base" ):

15855 listener.enterInterface_base(self)

15856

15857 def exitRule(self, listener:ParseTreeListener):

15858 if hasattr( listener, "exitInterface_base" ):

15859 listener.exitInterface_base(self)

15864 def interface_base(self):

15865

15866 localctx = CSharpParser.Interface_baseContext(self, self._ctx, self.state)

15867 self.enterRule(localctx, 332, self.RULE_interface_base)

15868 try:

15869 self.enterOuterAlt(localctx, 1)

15870 self.state = 2076

15871 self.match(CSharpParser.COLON)

15872 self.state = 2077

15873 self.interface_type_list()

15874 except RecognitionException as re:

15875 localctx.exception = re

15876 self._errHandler.reportError(self, re)

15877 self._errHandler.recover(self, re)

15878 finally:

15879 self.exitRule()

15880 return localctx

15881

15882

15883 class Interface_bodyContext(ParserRuleContext):

15884 __slots__ = 'parser'

15885

15886 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

15887 super().__init__(parent, invokingState)

15888 self.parser = parser

15889

15890 def OPEN_BRACE(self):

15891 return self.getToken(CSharpParser.OPEN_BRACE, 0)

15892

15893 def CLOSE_BRACE(self):

15894 return self.getToken(CSharpParser.CLOSE_BRACE, 0)

15895

15896 def interface_member_declaration(self, i:int=None):

15897 if i is None:

15898 return self.getTypedRuleContexts(CSharpParser.Interface_member_declarationContext)

15899 else:

15900 return self.getTypedRuleContext(CSharpParser.Interface_member_declarationContext,i)

15901

15902

15903 def getRuleIndex(self):

15904 return CSharpParser.RULE_interface_body

15905

15906 def enterRule(self, listener:ParseTreeListener):

15907 if hasattr( listener, "enterInterface_body" ):

15908 listener.enterInterface_body(self)

15909

15910 def exitRule(self, listener:ParseTreeListener):

15911 if hasattr( listener, "exitInterface_body" ):

15912 listener.exitInterface_body(self)

15917 def interface_body(self):

15918

15919 localctx = CSharpParser.Interface_bodyContext(self, self._ctx, self.state)

15920 self.enterRule(localctx, 334, self.RULE_interface_body)

15921 self._la = 0 # Token type

15922 try:

15923 self.enterOuterAlt(localctx, 1)

15924 self.state = 2079

15925 self.match(CSharpParser.OPEN_BRACE)

15926 self.state = 2083

15927 self._errHandler.sync(self)

15928 _la = self._input.LA(1)

15930 self.state = 2080

15931 self.interface_member_declaration()

15932 self.state = 2085

15933 self._errHandler.sync(self)

15934 _la = self._input.LA(1)

15935

15936 self.state = 2086

15937 self.match(CSharpParser.CLOSE_BRACE)

15938 except RecognitionException as re:

15939 localctx.exception = re

15940 self._errHandler.reportError(self, re)

15941 self._errHandler.recover(self, re)

15942 finally:

15943 self.exitRule()

15944 return localctx

15945

15946

15947 class Interface_member_declarationContext(ParserRuleContext):

15948 __slots__ = 'parser'

15949

15950 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

15951 super().__init__(parent, invokingState)

15952 self.parser = parser

15953

15954 def type_(self):

15955 return self.getTypedRuleContext(CSharpParser.Type_Context,0)

15956

15957

15958 def VOID(self):

15959 return self.getToken(CSharpParser.VOID, 0)

15960

15961 def identifier(self):

15962 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

15963

15964

15965 def OPEN_PARENS(self):

15966 return self.getToken(CSharpParser.OPEN_PARENS, 0)

15967

15968 def CLOSE_PARENS(self):

15969 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

15970

15971 def SEMICOLON(self):

15972 return self.getToken(CSharpParser.SEMICOLON, 0)

15973

15974 def EVENT(self):

15975 return self.getToken(CSharpParser.EVENT, 0)

15976

15977 def attributes(self):

15978 return self.getTypedRuleContext(CSharpParser.AttributesContext,0)

15979

15980

15981 def NEW(self):

15982 return self.getToken(CSharpParser.NEW, 0)

15983

15984 def OPEN_BRACE(self):

15985 return self.getToken(CSharpParser.OPEN_BRACE, 0)

15986

15987 def interface_accessors(self):

15988 return self.getTypedRuleContext(CSharpParser.Interface_accessorsContext,0)

15989

15990

15991 def CLOSE_BRACE(self):

15992 return self.getToken(CSharpParser.CLOSE_BRACE, 0)

15993

15994 def THIS(self):

15995 return self.getToken(CSharpParser.THIS, 0)

15996

15997 def OPEN_BRACKET(self):

15998 return self.getToken(CSharpParser.OPEN_BRACKET, 0)

15999

16000 def formal_parameter_list(self):

16001 return self.getTypedRuleContext(CSharpParser.Formal_parameter_listContext,0)

16002

16003

16004 def CLOSE_BRACKET(self):

16005 return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

16006

16007 def UNSAFE(self):

16008 return self.getToken(CSharpParser.UNSAFE, 0)

16009

16010 def REF(self):

16011 return self.getToken(CSharpParser.REF, 0)

16012

16013 def READONLY(self):

16014 return self.getToken(CSharpParser.READONLY, 0)

16015

16016 def type_parameter_list(self):

16017 return self.getTypedRuleContext(CSharpParser.Type_parameter_listContext,0)

16018

16019

16020 def type_parameter_constraints_clauses(self):

16021 return self.getTypedRuleContext(CSharpParser.Type_parameter_constraints_clausesContext,0)

16022

16023

16024 def getRuleIndex(self):

16025 return CSharpParser.RULE_interface_member_declaration

16026

16027 def enterRule(self, listener:ParseTreeListener):

16028 if hasattr( listener, "enterInterface_member_declaration" ):

16029 listener.enterInterface_member_declaration(self)

16030

16031 def exitRule(self, listener:ParseTreeListener):

16032 if hasattr( listener, "exitInterface_member_declaration" ):

16033 listener.exitInterface_member_declaration(self)

16038 def interface_member_declaration(self):

16039

16040 localctx = CSharpParser.Interface_member_declarationContext(self, self._ctx, self.state)

16041 self.enterRule(localctx, 336, self.RULE_interface_member_declaration)

16042 self._la = 0 # Token type

16043 try:

16044 self.enterOuterAlt(localctx, 1)

16045 self.state = 2089

16046 self._errHandler.sync(self)

16047 _la = self._input.LA(1)

16048 if _la==CSharpParser.OPEN_BRACKET:

16049 self.state = 2088

16050 self.attributes()

16051

16052

16053 self.state = 2092

16054 self._errHandler.sync(self)

16055 _la = self._input.LA(1)

16056 if _la==CSharpParser.NEW:

16057 self.state = 2091

16058 self.match(CSharpParser.NEW)

16059

16060

16061 self.state = 2157

16062 self._errHandler.sync(self)

16063 la_ = self._interp.adaptivePredict(self._input,261,self._ctx)

16064 if la_ == 1:

16065 self.state = 2095

16066 self._errHandler.sync(self)

16067 _la = self._input.LA(1)

16068 if _la==CSharpParser.UNSAFE:

16069 self.state = 2094

16070 self.match(CSharpParser.UNSAFE)

16071

16072

16073 self.state = 2102

16074 self._errHandler.sync(self)

16075 la_ = self._interp.adaptivePredict(self._input,252,self._ctx)

16076 if la_ == 1:

16077 self.state = 2097

16078 self.match(CSharpParser.REF)

16079

16080 elif la_ == 2:

16081 self.state = 2098

16082 self.match(CSharpParser.REF)

16083 self.state = 2099

16084 self.match(CSharpParser.READONLY)

16085

16086 elif la_ == 3:

16087 self.state = 2100

16088 self.match(CSharpParser.READONLY)

16089 self.state = 2101

16090 self.match(CSharpParser.REF)

16091

16092

16093 self.state = 2104

16094 self.type_()

16095 self.state = 2132

16096 self._errHandler.sync(self)

16097 la_ = self._interp.adaptivePredict(self._input,256,self._ctx)

16098 if la_ == 1:

16099 self.state = 2105

16100 self.identifier()

16101 self.state = 2107

16102 self._errHandler.sync(self)

16103 _la = self._input.LA(1)

16104 if _la==CSharpParser.LT:

16105 self.state = 2106

16106 self.type_parameter_list()

16107

16108

16109 self.state = 2109

16110 self.match(CSharpParser.OPEN_PARENS)

16111 self.state = 2111

16112 self._errHandler.sync(self)

16113 _la = self._input.LA(1)

16115 self.state = 2110

16116 self.formal_parameter_list()

16117

16118

16119 self.state = 2113

16120 self.match(CSharpParser.CLOSE_PARENS)

16121 self.state = 2115

16122 self._errHandler.sync(self)

16123 _la = self._input.LA(1)

16124 if _la==CSharpParser.WHERE:

16125 self.state = 2114

16126 self.type_parameter_constraints_clauses()

16127

16128

16129 self.state = 2117

16130 self.match(CSharpParser.SEMICOLON)

16131 pass

16132

16133 elif la_ == 2:

16134 self.state = 2119

16135 self.identifier()

16136 self.state = 2120

16137 self.match(CSharpParser.OPEN_BRACE)

16138 self.state = 2121

16139 self.interface_accessors()

16140 self.state = 2122

16141 self.match(CSharpParser.CLOSE_BRACE)

16142 pass

16143

16144 elif la_ == 3:

16145 self.state = 2124

16146 self.match(CSharpParser.THIS)

16147 self.state = 2125

16148 self.match(CSharpParser.OPEN_BRACKET)

16149 self.state = 2126

16150 self.formal_parameter_list()

16151 self.state = 2127

16152 self.match(CSharpParser.CLOSE_BRACKET)

16153 self.state = 2128

16154 self.match(CSharpParser.OPEN_BRACE)

16155 self.state = 2129

16156 self.interface_accessors()

16157 self.state = 2130

16158 self.match(CSharpParser.CLOSE_BRACE)

16159 pass

16160

16161

16162 pass

16163

16164 elif la_ == 2:

16165 self.state = 2135

16166 self._errHandler.sync(self)

16167 _la = self._input.LA(1)

16168 if _la==CSharpParser.UNSAFE:

16169 self.state = 2134

16170 self.match(CSharpParser.UNSAFE)

16171

16172

16173 self.state = 2137

16174 self.match(CSharpParser.VOID)

16175 self.state = 2138

16176 self.identifier()

16177 self.state = 2140

16178 self._errHandler.sync(self)

16179 _la = self._input.LA(1)

16180 if _la==CSharpParser.LT:

16181 self.state = 2139

16182 self.type_parameter_list()

16183

16184

16185 self.state = 2142

16186 self.match(CSharpParser.OPEN_PARENS)

16187 self.state = 2144

16188 self._errHandler.sync(self)

16189 _la = self._input.LA(1)

16191 self.state = 2143

16192 self.formal_parameter_list()

16193

16194

16195 self.state = 2146

16196 self.match(CSharpParser.CLOSE_PARENS)

16197 self.state = 2148

16198 self._errHandler.sync(self)

16199 _la = self._input.LA(1)

16200 if _la==CSharpParser.WHERE:

16201 self.state = 2147

16202 self.type_parameter_constraints_clauses()

16203

16204

16205 self.state = 2150

16206 self.match(CSharpParser.SEMICOLON)

16207 pass

16208

16209 elif la_ == 3:

16210 self.state = 2152

16211 self.match(CSharpParser.EVENT)

16212 self.state = 2153

16213 self.type_()

16214 self.state = 2154

16215 self.identifier()

16216 self.state = 2155

16217 self.match(CSharpParser.SEMICOLON)

16218 pass

16219

16220

16221 except RecognitionException as re:

16222 localctx.exception = re

16223 self._errHandler.reportError(self, re)

16224 self._errHandler.recover(self, re)

16225 finally:

16226 self.exitRule()

16227 return localctx

16228

16229

16230 class Interface_accessorsContext(ParserRuleContext):

16231 __slots__ = 'parser'

16232

16233 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

16234 super().__init__(parent, invokingState)

16235 self.parser = parser

16236

16237 def GET(self):

16238 return self.getToken(CSharpParser.GET, 0)

16239

16240 def SEMICOLON(self, i:int=None):

16241 if i is None:

16242 return self.getTokens(CSharpParser.SEMICOLON)

16243 else:

16244 return self.getToken(CSharpParser.SEMICOLON, i)

16245

16246 def SET(self):

16247 return self.getToken(CSharpParser.SET, 0)

16248

16249 def attributes(self, i:int=None):

16250 if i is None:

16251 return self.getTypedRuleContexts(CSharpParser.AttributesContext)

16252 else:

16253 return self.getTypedRuleContext(CSharpParser.AttributesContext,i)

16254

16255

16256 def getRuleIndex(self):

16257 return CSharpParser.RULE_interface_accessors

16258

16259 def enterRule(self, listener:ParseTreeListener):

16260 if hasattr( listener, "enterInterface_accessors" ):

16261 listener.enterInterface_accessors(self)

16262

16263 def exitRule(self, listener:ParseTreeListener):

16264 if hasattr( listener, "exitInterface_accessors" ):

16265 listener.exitInterface_accessors(self)

16270 def interface_accessors(self):

16271

16272 localctx = CSharpParser.Interface_accessorsContext(self, self._ctx, self.state)

16273 self.enterRule(localctx, 338, self.RULE_interface_accessors)

16274 self._la = 0 # Token type

16275 try:

16276 self.enterOuterAlt(localctx, 1)

16277 self.state = 2160

16278 self._errHandler.sync(self)

16279 _la = self._input.LA(1)

16280 if _la==CSharpParser.OPEN_BRACKET:

16281 self.state = 2159

16282 self.attributes()

16283

16284

16285 self.state = 2180

16286 self._errHandler.sync(self)

16287 token = self._input.LA(1)

16288 if token in [CSharpParser.GET]:

16289 self.state = 2162

16290 self.match(CSharpParser.GET)

16291 self.state = 2163

16292 self.match(CSharpParser.SEMICOLON)

16293 self.state = 2169

16294 self._errHandler.sync(self)

16295 _la = self._input.LA(1)

16296 if _la==CSharpParser.SET or _la==CSharpParser.OPEN_BRACKET:

16297 self.state = 2165

16298 self._errHandler.sync(self)

16299 _la = self._input.LA(1)

16300 if _la==CSharpParser.OPEN_BRACKET:

16301 self.state = 2164

16302 self.attributes()

16303

16304

16305 self.state = 2167

16306 self.match(CSharpParser.SET)

16307 self.state = 2168

16308 self.match(CSharpParser.SEMICOLON)

16309

16310

16311 pass

16312 elif token in [CSharpParser.SET]:

16313 self.state = 2171

16314 self.match(CSharpParser.SET)

16315 self.state = 2172

16316 self.match(CSharpParser.SEMICOLON)

16317 self.state = 2178

16318 self._errHandler.sync(self)

16319 _la = self._input.LA(1)

16320 if _la==CSharpParser.GET or _la==CSharpParser.OPEN_BRACKET:

16321 self.state = 2174

16322 self._errHandler.sync(self)

16323 _la = self._input.LA(1)

16324 if _la==CSharpParser.OPEN_BRACKET:

16325 self.state = 2173

16326 self.attributes()

16327

16328

16329 self.state = 2176

16330 self.match(CSharpParser.GET)

16331 self.state = 2177

16332 self.match(CSharpParser.SEMICOLON)

16333

16334

16335 pass

16336 else:

16337 raise NoViableAltException(self)

16338

16339 except RecognitionException as re:

16340 localctx.exception = re

16341 self._errHandler.reportError(self, re)

16342 self._errHandler.recover(self, re)

16343 finally:

16344 self.exitRule()

16345 return localctx

16346

16347

16348 class Enum_baseContext(ParserRuleContext):

16349 __slots__ = 'parser'

16350

16351 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

16352 super().__init__(parent, invokingState)

16353 self.parser = parser

16354

16355 def COLON(self):

16356 return self.getToken(CSharpParser.COLON, 0)

16357

16358 def type_(self):

16359 return self.getTypedRuleContext(CSharpParser.Type_Context,0)

16360

16361

16362 def getRuleIndex(self):

16363 return CSharpParser.RULE_enum_base

16364

16365 def enterRule(self, listener:ParseTreeListener):

16366 if hasattr( listener, "enterEnum_base" ):

16367 listener.enterEnum_base(self)

16368

16369 def exitRule(self, listener:ParseTreeListener):

16370 if hasattr( listener, "exitEnum_base" ):

16371 listener.exitEnum_base(self)

16376 def enum_base(self):

16377

16378 localctx = CSharpParser.Enum_baseContext(self, self._ctx, self.state)

16379 self.enterRule(localctx, 340, self.RULE_enum_base)

16380 try:

16381 self.enterOuterAlt(localctx, 1)

16382 self.state = 2182

16383 self.match(CSharpParser.COLON)

16384 self.state = 2183

16385 self.type_()

16386 except RecognitionException as re:

16387 localctx.exception = re

16388 self._errHandler.reportError(self, re)

16389 self._errHandler.recover(self, re)

16390 finally:

16391 self.exitRule()

16392 return localctx

16393

16394

16395 class Enum_bodyContext(ParserRuleContext):

16396 __slots__ = 'parser'

16397

16398 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

16399 super().__init__(parent, invokingState)

16400 self.parser = parser

16401

16402 def OPEN_BRACE(self):

16403 return self.getToken(CSharpParser.OPEN_BRACE, 0)

16404

16405 def CLOSE_BRACE(self):

16406 return self.getToken(CSharpParser.CLOSE_BRACE, 0)

16407

16408 def enum_member_declaration(self, i:int=None):

16409 if i is None:

16410 return self.getTypedRuleContexts(CSharpParser.Enum_member_declarationContext)

16411 else:

16412 return self.getTypedRuleContext(CSharpParser.Enum_member_declarationContext,i)

16413

16414

16415 def COMMA(self, i:int=None):

16416 if i is None:

16417 return self.getTokens(CSharpParser.COMMA)

16418 else:

16419 return self.getToken(CSharpParser.COMMA, i)

16420

16421 def getRuleIndex(self):

16422 return CSharpParser.RULE_enum_body

16423

16424 def enterRule(self, listener:ParseTreeListener):

16425 if hasattr( listener, "enterEnum_body" ):

16426 listener.enterEnum_body(self)

16427

16428 def exitRule(self, listener:ParseTreeListener):

16429 if hasattr( listener, "exitEnum_body" ):

16430 listener.exitEnum_body(self)

16435 def enum_body(self):

16436

16437 localctx = CSharpParser.Enum_bodyContext(self, self._ctx, self.state)

16438 self.enterRule(localctx, 342, self.RULE_enum_body)

16439 self._la = 0 # Token type

16440 try:

16441 self.enterOuterAlt(localctx, 1)

16442 self.state = 2185

16443 self.match(CSharpParser.OPEN_BRACE)

16444 self.state = 2197

16445 self._errHandler.sync(self)

16446 _la = self._input.LA(1)

16448 self.state = 2186

16449 self.enum_member_declaration()

16450 self.state = 2191

16451 self._errHandler.sync(self)

16452 _alt = self._interp.adaptivePredict(self._input,268,self._ctx)

16453 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

16454 if _alt==1:

16455 self.state = 2187

16456 self.match(CSharpParser.COMMA)

16457 self.state = 2188

16458 self.enum_member_declaration()

16459 self.state = 2193

16460 self._errHandler.sync(self)

16461 _alt = self._interp.adaptivePredict(self._input,268,self._ctx)

16462

16463 self.state = 2195

16464 self._errHandler.sync(self)

16465 _la = self._input.LA(1)

16466 if _la==CSharpParser.COMMA:

16467 self.state = 2194

16468 self.match(CSharpParser.COMMA)

16473 self.state = 2199

16474 self.match(CSharpParser.CLOSE_BRACE)

16475 except RecognitionException as re:

16476 localctx.exception = re

16477 self._errHandler.reportError(self, re)

16478 self._errHandler.recover(self, re)

16479 finally:

16480 self.exitRule()

16481 return localctx

16482

16483

16484 class Enum_member_declarationContext(ParserRuleContext):

16485 __slots__ = 'parser'

16486

16487 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

16488 super().__init__(parent, invokingState)

16489 self.parser = parser

16490

16491 def identifier(self):

16492 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

16493

16494

16495 def attributes(self):

16496 return self.getTypedRuleContext(CSharpParser.AttributesContext,0)

16497

16498

16499 def ASSIGNMENT(self):

16500 return self.getToken(CSharpParser.ASSIGNMENT, 0)

16501

16502 def expression(self):

16503 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

16504

16505

16506 def getRuleIndex(self):

16507 return CSharpParser.RULE_enum_member_declaration

16508

16509 def enterRule(self, listener:ParseTreeListener):

16510 if hasattr( listener, "enterEnum_member_declaration" ):

16511 listener.enterEnum_member_declaration(self)

16512

16513 def exitRule(self, listener:ParseTreeListener):

16514 if hasattr( listener, "exitEnum_member_declaration" ):

16515 listener.exitEnum_member_declaration(self)

16520 def enum_member_declaration(self):

16521

16522 localctx = CSharpParser.Enum_member_declarationContext(self, self._ctx, self.state)

16523 self.enterRule(localctx, 344, self.RULE_enum_member_declaration)

16524 self._la = 0 # Token type

16525 try:

16526 self.enterOuterAlt(localctx, 1)

16527 self.state = 2202

16528 self._errHandler.sync(self)

16529 _la = self._input.LA(1)

16530 if _la==CSharpParser.OPEN_BRACKET:

16531 self.state = 2201

16532 self.attributes()

16533

16534

16535 self.state = 2204

16536 self.identifier()

16537 self.state = 2207

16538 self._errHandler.sync(self)

16539 _la = self._input.LA(1)

16540 if _la==CSharpParser.ASSIGNMENT:

16541 self.state = 2205

16542 self.match(CSharpParser.ASSIGNMENT)

16543 self.state = 2206

16544 self.expression()

16545

16546

16547 except RecognitionException as re:

16548 localctx.exception = re

16549 self._errHandler.reportError(self, re)

16550 self._errHandler.recover(self, re)

16551 finally:

16552 self.exitRule()

16553 return localctx

16554

16555

16556 class Global_attribute_sectionContext(ParserRuleContext):

16557 __slots__ = 'parser'

16558

16559 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

16560 super().__init__(parent, invokingState)

16561 self.parser = parser

16562

16563 def OPEN_BRACKET(self):

16564 return self.getToken(CSharpParser.OPEN_BRACKET, 0)

16565

16566 def global_attribute_target(self):

16567 return self.getTypedRuleContext(CSharpParser.Global_attribute_targetContext,0)

16568

16569

16570 def COLON(self):

16571 return self.getToken(CSharpParser.COLON, 0)

16572

16573 def attribute_list(self):

16574 return self.getTypedRuleContext(CSharpParser.Attribute_listContext,0)

16575

16576

16577 def CLOSE_BRACKET(self):

16578 return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

16579

16580 def COMMA(self):

16581 return self.getToken(CSharpParser.COMMA, 0)

16582

16583 def getRuleIndex(self):

16584 return CSharpParser.RULE_global_attribute_section

16585

16586 def enterRule(self, listener:ParseTreeListener):

16587 if hasattr( listener, "enterGlobal_attribute_section" ):

16588 listener.enterGlobal_attribute_section(self)

16589

16590 def exitRule(self, listener:ParseTreeListener):

16591 if hasattr( listener, "exitGlobal_attribute_section" ):

16592 listener.exitGlobal_attribute_section(self)

16597 def global_attribute_section(self):

16598

16599 localctx = CSharpParser.Global_attribute_sectionContext(self, self._ctx, self.state)

16600 self.enterRule(localctx, 346, self.RULE_global_attribute_section)

16601 self._la = 0 # Token type

16602 try:

16603 self.enterOuterAlt(localctx, 1)

16604 self.state = 2209

16605 self.match(CSharpParser.OPEN_BRACKET)

16606 self.state = 2210

16607 self.global_attribute_target()

16608 self.state = 2211

16609 self.match(CSharpParser.COLON)

16610 self.state = 2212

16611 self.attribute_list()

16612 self.state = 2214

16613 self._errHandler.sync(self)

16614 _la = self._input.LA(1)

16615 if _la==CSharpParser.COMMA:

16616 self.state = 2213

16617 self.match(CSharpParser.COMMA)

16618

16619

16620 self.state = 2216

16621 self.match(CSharpParser.CLOSE_BRACKET)

16622 except RecognitionException as re:

16623 localctx.exception = re

16624 self._errHandler.reportError(self, re)

16625 self._errHandler.recover(self, re)

16626 finally:

16627 self.exitRule()

16628 return localctx

16629

16630

16631 class Global_attribute_targetContext(ParserRuleContext):

16632 __slots__ = 'parser'

16633

16634 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

16635 super().__init__(parent, invokingState)

16636 self.parser = parser

16637

16638 def keyword(self):

16639 return self.getTypedRuleContext(CSharpParser.KeywordContext,0)

16640

16641

16642 def identifier(self):

16643 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

16644

16645

16646 def getRuleIndex(self):

16647 return CSharpParser.RULE_global_attribute_target

16648

16649 def enterRule(self, listener:ParseTreeListener):

16650 if hasattr( listener, "enterGlobal_attribute_target" ):

16651 listener.enterGlobal_attribute_target(self)

16652

16653 def exitRule(self, listener:ParseTreeListener):

16654 if hasattr( listener, "exitGlobal_attribute_target" ):

16655 listener.exitGlobal_attribute_target(self)

16660 def global_attribute_target(self):

16661

16662 localctx = CSharpParser.Global_attribute_targetContext(self, self._ctx, self.state)

16663 self.enterRule(localctx, 348, self.RULE_global_attribute_target)

16664 try:

16665 self.state = 2220

16666 self._errHandler.sync(self)

16667 la_ = self._interp.adaptivePredict(self._input,274,self._ctx)

16668 if la_ == 1:

16669 self.enterOuterAlt(localctx, 1)

16670 self.state = 2218

16671 self.keyword()

16672 pass

16673

16674 elif la_ == 2:

16675 self.enterOuterAlt(localctx, 2)

16676 self.state = 2219

16677 self.identifier()

16678 pass

16679

16680

16681 except RecognitionException as re:

16682 localctx.exception = re

16683 self._errHandler.reportError(self, re)

16684 self._errHandler.recover(self, re)

16685 finally:

16686 self.exitRule()

16687 return localctx

16688

16689

16690 class AttributesContext(ParserRuleContext):

16691 __slots__ = 'parser'

16692

16693 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

16694 super().__init__(parent, invokingState)

16695 self.parser = parser

16696

16697 def attribute_section(self, i:int=None):

16698 if i is None:

16699 return self.getTypedRuleContexts(CSharpParser.Attribute_sectionContext)

16700 else:

16701 return self.getTypedRuleContext(CSharpParser.Attribute_sectionContext,i)

16702

16703

16704 def getRuleIndex(self):

16705 return CSharpParser.RULE_attributes

16706

16707 def enterRule(self, listener:ParseTreeListener):

16708 if hasattr( listener, "enterAttributes" ):

16709 listener.enterAttributes(self)

16710

16711 def exitRule(self, listener:ParseTreeListener):

16712 if hasattr( listener, "exitAttributes" ):

16713 listener.exitAttributes(self)

16718 def attributes(self):

16719

16720 localctx = CSharpParser.AttributesContext(self, self._ctx, self.state)

16721 self.enterRule(localctx, 350, self.RULE_attributes)

16722 self._la = 0 # Token type

16723 try:

16724 self.enterOuterAlt(localctx, 1)

16725 self.state = 2223

16726 self._errHandler.sync(self)

16727 _la = self._input.LA(1)

16728 while True:

16729 self.state = 2222

16730 self.attribute_section()

16731 self.state = 2225

16732 self._errHandler.sync(self)

16733 _la = self._input.LA(1)

16734 if not (_la==CSharpParser.OPEN_BRACKET):

16735 break

16736

16737 except RecognitionException as re:

16738 localctx.exception = re

16739 self._errHandler.reportError(self, re)

16740 self._errHandler.recover(self, re)

16741 finally:

16742 self.exitRule()

16743 return localctx

16744

16745

16746 class Attribute_sectionContext(ParserRuleContext):

16747 __slots__ = 'parser'

16748

16749 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

16750 super().__init__(parent, invokingState)

16751 self.parser = parser

16752

16753 def OPEN_BRACKET(self):

16754 return self.getToken(CSharpParser.OPEN_BRACKET, 0)

16755

16756 def attribute_list(self):

16757 return self.getTypedRuleContext(CSharpParser.Attribute_listContext,0)

16758

16759

16760 def CLOSE_BRACKET(self):

16761 return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

16762

16763 def attribute_target(self):

16764 return self.getTypedRuleContext(CSharpParser.Attribute_targetContext,0)

16765

16766

16767 def COLON(self):

16768 return self.getToken(CSharpParser.COLON, 0)

16769

16770 def COMMA(self):

16771 return self.getToken(CSharpParser.COMMA, 0)

16772

16773 def getRuleIndex(self):

16774 return CSharpParser.RULE_attribute_section

16775

16776 def enterRule(self, listener:ParseTreeListener):

16777 if hasattr( listener, "enterAttribute_section" ):

16778 listener.enterAttribute_section(self)

16779

16780 def exitRule(self, listener:ParseTreeListener):

16781 if hasattr( listener, "exitAttribute_section" ):

16782 listener.exitAttribute_section(self)

16787 def attribute_section(self):

16788

16789 localctx = CSharpParser.Attribute_sectionContext(self, self._ctx, self.state)

16790 self.enterRule(localctx, 352, self.RULE_attribute_section)

16791 self._la = 0 # Token type

16792 try:

16793 self.enterOuterAlt(localctx, 1)

16794 self.state = 2227

16795 self.match(CSharpParser.OPEN_BRACKET)

16796 self.state = 2231

16797 self._errHandler.sync(self)

16798 la_ = self._interp.adaptivePredict(self._input,276,self._ctx)

16799 if la_ == 1:

16800 self.state = 2228

16801 self.attribute_target()

16802 self.state = 2229

16803 self.match(CSharpParser.COLON)

16804

16805

16806 self.state = 2233

16807 self.attribute_list()

16808 self.state = 2235

16809 self._errHandler.sync(self)

16810 _la = self._input.LA(1)

16811 if _la==CSharpParser.COMMA:

16812 self.state = 2234

16813 self.match(CSharpParser.COMMA)

16814

16815

16816 self.state = 2237

16817 self.match(CSharpParser.CLOSE_BRACKET)

16818 except RecognitionException as re:

16819 localctx.exception = re

16820 self._errHandler.reportError(self, re)

16821 self._errHandler.recover(self, re)

16822 finally:

16823 self.exitRule()

16824 return localctx

16825

16826

16827 class Attribute_targetContext(ParserRuleContext):

16828 __slots__ = 'parser'

16829

16830 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

16831 super().__init__(parent, invokingState)

16832 self.parser = parser

16833

16834 def keyword(self):

16835 return self.getTypedRuleContext(CSharpParser.KeywordContext,0)

16836

16837

16838 def identifier(self):

16839 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

16840

16841

16842 def getRuleIndex(self):

16843 return CSharpParser.RULE_attribute_target

16844

16845 def enterRule(self, listener:ParseTreeListener):

16846 if hasattr( listener, "enterAttribute_target" ):

16847 listener.enterAttribute_target(self)

16848

16849 def exitRule(self, listener:ParseTreeListener):

16850 if hasattr( listener, "exitAttribute_target" ):

16851 listener.exitAttribute_target(self)

16856 def attribute_target(self):

16857

16858 localctx = CSharpParser.Attribute_targetContext(self, self._ctx, self.state)

16859 self.enterRule(localctx, 354, self.RULE_attribute_target)

16860 try:

16861 self.state = 2241

16862 self._errHandler.sync(self)

16863 la_ = self._interp.adaptivePredict(self._input,278,self._ctx)

16864 if la_ == 1:

16865 self.enterOuterAlt(localctx, 1)

16866 self.state = 2239

16867 self.keyword()

16868 pass

16869

16870 elif la_ == 2:

16871 self.enterOuterAlt(localctx, 2)

16872 self.state = 2240

16873 self.identifier()

16874 pass

16875

16876

16877 except RecognitionException as re:

16878 localctx.exception = re

16879 self._errHandler.reportError(self, re)

16880 self._errHandler.recover(self, re)

16881 finally:

16882 self.exitRule()

16883 return localctx

16884

16885

16886 class Attribute_listContext(ParserRuleContext):

16887 __slots__ = 'parser'

16888

16889 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

16890 super().__init__(parent, invokingState)

16891 self.parser = parser

16892

16893 def attribute(self, i:int=None):

16894 if i is None:

16895 return self.getTypedRuleContexts(CSharpParser.AttributeContext)

16896 else:

16897 return self.getTypedRuleContext(CSharpParser.AttributeContext,i)

16898

16899

16900 def COMMA(self, i:int=None):

16901 if i is None:

16902 return self.getTokens(CSharpParser.COMMA)

16903 else:

16904 return self.getToken(CSharpParser.COMMA, i)

16905

16906 def getRuleIndex(self):

16907 return CSharpParser.RULE_attribute_list

16908

16909 def enterRule(self, listener:ParseTreeListener):

16910 if hasattr( listener, "enterAttribute_list" ):

16911 listener.enterAttribute_list(self)

16912

16913 def exitRule(self, listener:ParseTreeListener):

16914 if hasattr( listener, "exitAttribute_list" ):

16915 listener.exitAttribute_list(self)

16920 def attribute_list(self):

16921

16922 localctx = CSharpParser.Attribute_listContext(self, self._ctx, self.state)

16923 self.enterRule(localctx, 356, self.RULE_attribute_list)

16924 try:

16925 self.enterOuterAlt(localctx, 1)

16926 self.state = 2243

16927 self.attribute()

16928 self.state = 2248

16929 self._errHandler.sync(self)

16930 _alt = self._interp.adaptivePredict(self._input,279,self._ctx)

16931 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

16932 if _alt==1:

16933 self.state = 2244

16934 self.match(CSharpParser.COMMA)

16935 self.state = 2245

16936 self.attribute()

16937 self.state = 2250

16938 self._errHandler.sync(self)

16939 _alt = self._interp.adaptivePredict(self._input,279,self._ctx)

16940

16941 except RecognitionException as re:

16942 localctx.exception = re

16943 self._errHandler.reportError(self, re)

16944 self._errHandler.recover(self, re)

16945 finally:

16946 self.exitRule()

16947 return localctx

16948

16949

16950 class AttributeContext(ParserRuleContext):

16951 __slots__ = 'parser'

16952

16953 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

16954 super().__init__(parent, invokingState)

16955 self.parser = parser

16956

16957 def namespace_or_type_name(self):

16958 return self.getTypedRuleContext(CSharpParser.Namespace_or_type_nameContext,0)

16959

16960

16961 def OPEN_PARENS(self):

16962 return self.getToken(CSharpParser.OPEN_PARENS, 0)

16963

16964 def CLOSE_PARENS(self):

16965 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

16966

16967 def attribute_argument(self, i:int=None):

16968 if i is None:

16969 return self.getTypedRuleContexts(CSharpParser.Attribute_argumentContext)

16970 else:

16971 return self.getTypedRuleContext(CSharpParser.Attribute_argumentContext,i)

16972

16973

16974 def COMMA(self, i:int=None):

16975 if i is None:

16976 return self.getTokens(CSharpParser.COMMA)

16977 else:

16978 return self.getToken(CSharpParser.COMMA, i)

16979

16980 def getRuleIndex(self):

16981 return CSharpParser.RULE_attribute

16982

16983 def enterRule(self, listener:ParseTreeListener):

16984 if hasattr( listener, "enterAttribute" ):

16985 listener.enterAttribute(self)

16986

16987 def exitRule(self, listener:ParseTreeListener):

16988 if hasattr( listener, "exitAttribute" ):

16989 listener.exitAttribute(self)

16994 def attribute(self):

16995

16996 localctx = CSharpParser.AttributeContext(self, self._ctx, self.state)

16997 self.enterRule(localctx, 358, self.RULE_attribute)

16998 self._la = 0 # Token type

16999 try:

17000 self.enterOuterAlt(localctx, 1)

17001 self.state = 2251

17002 self.namespace_or_type_name()

17003 self.state = 2264

17004 self._errHandler.sync(self)

17005 _la = self._input.LA(1)

17006 if _la==CSharpParser.OPEN_PARENS:

17007 self.state = 2252

17008 self.match(CSharpParser.OPEN_PARENS)

17009 self.state = 2261

17010 self._errHandler.sync(self)

17011 _la = self._input.LA(1)

17013 self.state = 2253

17014 self.attribute_argument()

17015 self.state = 2258

17016 self._errHandler.sync(self)

17017 _la = self._input.LA(1)

17018 while _la==CSharpParser.COMMA:

17019 self.state = 2254

17020 self.match(CSharpParser.COMMA)

17021 self.state = 2255

17022 self.attribute_argument()

17023 self.state = 2260

17024 self._errHandler.sync(self)

17025 _la = self._input.LA(1)

17026

17027

17028

17029 self.state = 2263

17030 self.match(CSharpParser.CLOSE_PARENS)

17031

17032

17033 except RecognitionException as re:

17034 localctx.exception = re

17035 self._errHandler.reportError(self, re)

17036 self._errHandler.recover(self, re)

17037 finally:

17038 self.exitRule()

17039 return localctx

17040

17041

17042 class Attribute_argumentContext(ParserRuleContext):

17043 __slots__ = 'parser'

17044

17045 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

17046 super().__init__(parent, invokingState)

17047 self.parser = parser

17048

17049 def expression(self):

17050 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

17051

17052

17053 def identifier(self):

17054 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

17055

17056

17057 def COLON(self):

17058 return self.getToken(CSharpParser.COLON, 0)

17059

17060 def getRuleIndex(self):

17061 return CSharpParser.RULE_attribute_argument

17062

17063 def enterRule(self, listener:ParseTreeListener):

17064 if hasattr( listener, "enterAttribute_argument" ):

17065 listener.enterAttribute_argument(self)

17066

17067 def exitRule(self, listener:ParseTreeListener):

17068 if hasattr( listener, "exitAttribute_argument" ):

17069 listener.exitAttribute_argument(self)

17074 def attribute_argument(self):

17075

17076 localctx = CSharpParser.Attribute_argumentContext(self, self._ctx, self.state)

17077 self.enterRule(localctx, 360, self.RULE_attribute_argument)

17078 try:

17079 self.enterOuterAlt(localctx, 1)

17080 self.state = 2269

17081 self._errHandler.sync(self)

17082 la_ = self._interp.adaptivePredict(self._input,283,self._ctx)

17083 if la_ == 1:

17084 self.state = 2266

17085 self.identifier()

17086 self.state = 2267

17087 self.match(CSharpParser.COLON)

17088

17089

17090 self.state = 2271

17091 self.expression()

17092 except RecognitionException as re:

17093 localctx.exception = re

17094 self._errHandler.reportError(self, re)

17095 self._errHandler.recover(self, re)

17096 finally:

17097 self.exitRule()

17098 return localctx

17099

17100

17101 class Pointer_typeContext(ParserRuleContext):

17102 __slots__ = 'parser'

17103

17104 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

17105 super().__init__(parent, invokingState)

17106 self.parser = parser

17107

17108 def STAR(self):

17109 return self.getToken(CSharpParser.STAR, 0)

17110

17111 def simple_type(self):

17112 return self.getTypedRuleContext(CSharpParser.Simple_typeContext,0)

17113

17114

17115 def class_type(self):

17116 return self.getTypedRuleContext(CSharpParser.Class_typeContext,0)

17117

17118

17119 def rank_specifier(self, i:int=None):

17120 if i is None:

17121 return self.getTypedRuleContexts(CSharpParser.Rank_specifierContext)

17122 else:

17123 return self.getTypedRuleContext(CSharpParser.Rank_specifierContext,i)

17124

17125

17126 def INTERR(self, i:int=None):

17127 if i is None:

17128 return self.getTokens(CSharpParser.INTERR)

17129 else:

17130 return self.getToken(CSharpParser.INTERR, i)

17131

17132 def VOID(self):

17133 return self.getToken(CSharpParser.VOID, 0)

17134

17135 def getRuleIndex(self):

17136 return CSharpParser.RULE_pointer_type

17137

17138 def enterRule(self, listener:ParseTreeListener):

17139 if hasattr( listener, "enterPointer_type" ):

17140 listener.enterPointer_type(self)

17141

17142 def exitRule(self, listener:ParseTreeListener):

17143 if hasattr( listener, "exitPointer_type" ):

17144 listener.exitPointer_type(self)

17149 def pointer_type(self):

17150

17151 localctx = CSharpParser.Pointer_typeContext(self, self._ctx, self.state)

17152 self.enterRule(localctx, 362, self.RULE_pointer_type)

17153 self._la = 0 # Token type

17154 try:

17155 self.state = 2288

17156 self._errHandler.sync(self)

17157 token = self._input.LA(1)

17158 if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.DECIMAL, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.STRING, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER]:

17159 self.enterOuterAlt(localctx, 1)

17160 self.state = 2275

17161 self._errHandler.sync(self)

17162 token = self._input.LA(1)

17163 if token in [CSharpParser.BOOL, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.DECIMAL, CSharpParser.DOUBLE, CSharpParser.FLOAT, CSharpParser.INT, CSharpParser.LONG, CSharpParser.SBYTE, CSharpParser.SHORT, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.USHORT]:

17164 self.state = 2273

17165 self.simple_type()

17166 pass

17167 elif token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BY, CSharpParser.DESCENDING, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.NAMEOF, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REMOVE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.STRING, CSharpParser.UNMANAGED, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER]:

17168 self.state = 2274

17169 self.class_type()

17170 pass

17171 else:

17172 raise NoViableAltException(self)

17173

17174 self.state = 2281

17175 self._errHandler.sync(self)

17176 _la = self._input.LA(1)

17177 while _la==CSharpParser.OPEN_BRACKET or _la==CSharpParser.INTERR:

17178 self.state = 2279

17179 self._errHandler.sync(self)

17180 token = self._input.LA(1)

17181 if token in [CSharpParser.OPEN_BRACKET]:

17182 self.state = 2277

17183 self.rank_specifier()

17184 pass

17185 elif token in [CSharpParser.INTERR]:

17186 self.state = 2278

17187 self.match(CSharpParser.INTERR)

17188 pass

17189 else:

17190 raise NoViableAltException(self)

17191

17192 self.state = 2283

17193 self._errHandler.sync(self)

17194 _la = self._input.LA(1)

17195

17196 self.state = 2284

17197 self.match(CSharpParser.STAR)

17198 pass

17199 elif token in [CSharpParser.VOID]:

17200 self.enterOuterAlt(localctx, 2)

17201 self.state = 2286

17202 self.match(CSharpParser.VOID)

17203 self.state = 2287

17204 self.match(CSharpParser.STAR)

17205 pass

17206 else:

17207 raise NoViableAltException(self)

17208

17209 except RecognitionException as re:

17210 localctx.exception = re

17211 self._errHandler.reportError(self, re)

17212 self._errHandler.recover(self, re)

17213 finally:

17214 self.exitRule()

17215 return localctx

17216

17217

17218 class Fixed_pointer_declaratorsContext(ParserRuleContext):

17219 __slots__ = 'parser'

17220

17221 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

17222 super().__init__(parent, invokingState)

17223 self.parser = parser

17224

17225 def fixed_pointer_declarator(self, i:int=None):

17226 if i is None:

17227 return self.getTypedRuleContexts(CSharpParser.Fixed_pointer_declaratorContext)

17228 else:

17229 return self.getTypedRuleContext(CSharpParser.Fixed_pointer_declaratorContext,i)

17230

17231

17232 def COMMA(self, i:int=None):

17233 if i is None:

17234 return self.getTokens(CSharpParser.COMMA)

17235 else:

17236 return self.getToken(CSharpParser.COMMA, i)

17237

17238 def getRuleIndex(self):

17239 return CSharpParser.RULE_fixed_pointer_declarators

17240

17241 def enterRule(self, listener:ParseTreeListener):

17242 if hasattr( listener, "enterFixed_pointer_declarators" ):

17243 listener.enterFixed_pointer_declarators(self)

17244

17245 def exitRule(self, listener:ParseTreeListener):

17246 if hasattr( listener, "exitFixed_pointer_declarators" ):

17247 listener.exitFixed_pointer_declarators(self)

17252 def fixed_pointer_declarators(self):

17253

17254 localctx = CSharpParser.Fixed_pointer_declaratorsContext(self, self._ctx, self.state)

17255 self.enterRule(localctx, 364, self.RULE_fixed_pointer_declarators)

17256 self._la = 0 # Token type

17257 try:

17258 self.enterOuterAlt(localctx, 1)

17259 self.state = 2290

17260 self.fixed_pointer_declarator()

17261 self.state = 2295

17262 self._errHandler.sync(self)

17263 _la = self._input.LA(1)

17264 while _la==CSharpParser.COMMA:

17265 self.state = 2291

17266 self.match(CSharpParser.COMMA)

17267 self.state = 2292

17268 self.fixed_pointer_declarator()

17269 self.state = 2297

17270 self._errHandler.sync(self)

17271 _la = self._input.LA(1)

17272

17273 except RecognitionException as re:

17274 localctx.exception = re

17275 self._errHandler.reportError(self, re)

17276 self._errHandler.recover(self, re)

17277 finally:

17278 self.exitRule()

17279 return localctx

17280

17281

17282 class Fixed_pointer_declaratorContext(ParserRuleContext):

17283 __slots__ = 'parser'

17284

17285 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

17286 super().__init__(parent, invokingState)

17287 self.parser = parser

17288

17289 def identifier(self):

17290 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

17291

17292

17293 def ASSIGNMENT(self):

17294 return self.getToken(CSharpParser.ASSIGNMENT, 0)

17295

17296 def fixed_pointer_initializer(self):

17297 return self.getTypedRuleContext(CSharpParser.Fixed_pointer_initializerContext,0)

17298

17299

17300 def getRuleIndex(self):

17301 return CSharpParser.RULE_fixed_pointer_declarator

17302

17303 def enterRule(self, listener:ParseTreeListener):

17304 if hasattr( listener, "enterFixed_pointer_declarator" ):

17305 listener.enterFixed_pointer_declarator(self)

17306

17307 def exitRule(self, listener:ParseTreeListener):

17308 if hasattr( listener, "exitFixed_pointer_declarator" ):

17309 listener.exitFixed_pointer_declarator(self)

17314 def fixed_pointer_declarator(self):

17315

17316 localctx = CSharpParser.Fixed_pointer_declaratorContext(self, self._ctx, self.state)

17317 self.enterRule(localctx, 366, self.RULE_fixed_pointer_declarator)

17318 try:

17319 self.enterOuterAlt(localctx, 1)

17320 self.state = 2298

17321 self.identifier()

17322 self.state = 2299

17323 self.match(CSharpParser.ASSIGNMENT)

17324 self.state = 2300

17325 self.fixed_pointer_initializer()

17326 except RecognitionException as re:

17327 localctx.exception = re

17328 self._errHandler.reportError(self, re)

17329 self._errHandler.recover(self, re)

17330 finally:

17331 self.exitRule()

17332 return localctx

17333

17334

17335 class Fixed_pointer_initializerContext(ParserRuleContext):

17336 __slots__ = 'parser'

17337

17338 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

17339 super().__init__(parent, invokingState)

17340 self.parser = parser

17341

17342 def expression(self):

17343 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

17344

17345

17346 def AMP(self):

17347 return self.getToken(CSharpParser.AMP, 0)

17348

17349 def stackalloc_initializer(self):

17350 return self.getTypedRuleContext(CSharpParser.Stackalloc_initializerContext,0)

17351

17352

17353 def getRuleIndex(self):

17354 return CSharpParser.RULE_fixed_pointer_initializer

17355

17356 def enterRule(self, listener:ParseTreeListener):

17357 if hasattr( listener, "enterFixed_pointer_initializer" ):

17358 listener.enterFixed_pointer_initializer(self)

17359

17360 def exitRule(self, listener:ParseTreeListener):

17361 if hasattr( listener, "exitFixed_pointer_initializer" ):

17362 listener.exitFixed_pointer_initializer(self)

17367 def fixed_pointer_initializer(self):

17368

17369 localctx = CSharpParser.Fixed_pointer_initializerContext(self, self._ctx, self.state)

17370 self.enterRule(localctx, 368, self.RULE_fixed_pointer_initializer)

17371 try:

17372 self.state = 2307

17373 self._errHandler.sync(self)

17374 token = self._input.LA(1)

17375 if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:

17376 self.enterOuterAlt(localctx, 1)

17377 self.state = 2303

17378 self._errHandler.sync(self)

17379 la_ = self._interp.adaptivePredict(self._input,289,self._ctx)

17380 if la_ == 1:

17381 self.state = 2302

17382 self.match(CSharpParser.AMP)

17383

17384

17385 self.state = 2305

17386 self.expression()

17387 pass

17388 elif token in [CSharpParser.STACKALLOC]:

17389 self.enterOuterAlt(localctx, 2)

17390 self.state = 2306

17391 self.stackalloc_initializer()

17392 pass

17393 else:

17394 raise NoViableAltException(self)

17395

17396 except RecognitionException as re:

17397 localctx.exception = re

17398 self._errHandler.reportError(self, re)

17399 self._errHandler.recover(self, re)

17400 finally:

17401 self.exitRule()

17402 return localctx

17403

17404

17405 class Fixed_size_buffer_declaratorContext(ParserRuleContext):

17406 __slots__ = 'parser'

17407

17408 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

17409 super().__init__(parent, invokingState)

17410 self.parser = parser

17411

17412 def identifier(self):

17413 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

17414

17415

17416 def OPEN_BRACKET(self):

17417 return self.getToken(CSharpParser.OPEN_BRACKET, 0)

17418

17419 def expression(self):

17420 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

17421

17422

17423 def CLOSE_BRACKET(self):

17424 return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

17425

17426 def getRuleIndex(self):

17427 return CSharpParser.RULE_fixed_size_buffer_declarator

17428

17429 def enterRule(self, listener:ParseTreeListener):

17430 if hasattr( listener, "enterFixed_size_buffer_declarator" ):

17431 listener.enterFixed_size_buffer_declarator(self)

17432

17433 def exitRule(self, listener:ParseTreeListener):

17434 if hasattr( listener, "exitFixed_size_buffer_declarator" ):

17435 listener.exitFixed_size_buffer_declarator(self)

17440 def fixed_size_buffer_declarator(self):

17441

17442 localctx = CSharpParser.Fixed_size_buffer_declaratorContext(self, self._ctx, self.state)

17443 self.enterRule(localctx, 370, self.RULE_fixed_size_buffer_declarator)

17444 try:

17445 self.enterOuterAlt(localctx, 1)

17446 self.state = 2309

17447 self.identifier()

17448 self.state = 2310

17449 self.match(CSharpParser.OPEN_BRACKET)

17450 self.state = 2311

17451 self.expression()

17452 self.state = 2312

17453 self.match(CSharpParser.CLOSE_BRACKET)

17454 except RecognitionException as re:

17455 localctx.exception = re

17456 self._errHandler.reportError(self, re)

17457 self._errHandler.recover(self, re)

17458 finally:

17459 self.exitRule()

17460 return localctx

17461

17462

17463 class Stackalloc_initializerContext(ParserRuleContext):

17464 __slots__ = 'parser'

17465

17466 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

17467 super().__init__(parent, invokingState)

17468 self.parser = parser

17469

17470 def STACKALLOC(self):

17471 return self.getToken(CSharpParser.STACKALLOC, 0)

17472

17473 def type_(self):

17474 return self.getTypedRuleContext(CSharpParser.Type_Context,0)

17475

17476

17477 def OPEN_BRACKET(self):

17478 return self.getToken(CSharpParser.OPEN_BRACKET, 0)

17479

17480 def expression(self, i:int=None):

17481 if i is None:

17482 return self.getTypedRuleContexts(CSharpParser.ExpressionContext)

17483 else:

17484 return self.getTypedRuleContext(CSharpParser.ExpressionContext,i)

17485

17486

17487 def CLOSE_BRACKET(self):

17488 return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

17489

17490 def OPEN_BRACE(self):

17491 return self.getToken(CSharpParser.OPEN_BRACE, 0)

17492

17493 def CLOSE_BRACE(self):

17494 return self.getToken(CSharpParser.CLOSE_BRACE, 0)

17495

17496 def COMMA(self, i:int=None):

17497 if i is None:

17498 return self.getTokens(CSharpParser.COMMA)

17499 else:

17500 return self.getToken(CSharpParser.COMMA, i)

17501

17502 def getRuleIndex(self):

17503 return CSharpParser.RULE_stackalloc_initializer

17504

17505 def enterRule(self, listener:ParseTreeListener):

17506 if hasattr( listener, "enterStackalloc_initializer" ):

17507 listener.enterStackalloc_initializer(self)

17508

17509 def exitRule(self, listener:ParseTreeListener):

17510 if hasattr( listener, "exitStackalloc_initializer" ):

17511 listener.exitStackalloc_initializer(self)

17516 def stackalloc_initializer(self):

17517

17518 localctx = CSharpParser.Stackalloc_initializerContext(self, self._ctx, self.state)

17519 self.enterRule(localctx, 372, self.RULE_stackalloc_initializer)

17520 self._la = 0 # Token type

17521 try:

17522 self.state = 2343

17523 self._errHandler.sync(self)

17524 la_ = self._interp.adaptivePredict(self._input,295,self._ctx)

17525 if la_ == 1:

17526 self.enterOuterAlt(localctx, 1)

17527 self.state = 2314

17528 self.match(CSharpParser.STACKALLOC)

17529 self.state = 2315

17530 self.type_()

17531 self.state = 2316

17532 self.match(CSharpParser.OPEN_BRACKET)

17533 self.state = 2317

17534 self.expression()

17535 self.state = 2318

17536 self.match(CSharpParser.CLOSE_BRACKET)

17537 pass

17538

17539 elif la_ == 2:

17540 self.enterOuterAlt(localctx, 2)

17541 self.state = 2320

17542 self.match(CSharpParser.STACKALLOC)

17543 self.state = 2322

17544 self._errHandler.sync(self)

17545 _la = self._input.LA(1)

17547 self.state = 2321

17548 self.type_()

17549

17550

17551 self.state = 2324

17552 self.match(CSharpParser.OPEN_BRACKET)

17553 self.state = 2326

17554 self._errHandler.sync(self)

17555 _la = self._input.LA(1)

17557 self.state = 2325

17558 self.expression()

17559

17560

17561 self.state = 2328

17562 self.match(CSharpParser.CLOSE_BRACKET)

17563 self.state = 2329

17564 self.match(CSharpParser.OPEN_BRACE)

17565 self.state = 2330

17566 self.expression()

17567 self.state = 2335

17568 self._errHandler.sync(self)

17569 _alt = self._interp.adaptivePredict(self._input,293,self._ctx)

17570 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

17571 if _alt==1:

17572 self.state = 2331

17573 self.match(CSharpParser.COMMA)

17574 self.state = 2332

17575 self.expression()

17576 self.state = 2337

17577 self._errHandler.sync(self)

17578 _alt = self._interp.adaptivePredict(self._input,293,self._ctx)

17579

17580 self.state = 2339

17581 self._errHandler.sync(self)

17582 _la = self._input.LA(1)

17583 if _la==CSharpParser.COMMA:

17584 self.state = 2338

17585 self.match(CSharpParser.COMMA)

17586

17587

17588 self.state = 2341

17589 self.match(CSharpParser.CLOSE_BRACE)

17590 pass

17591

17592

17593 except RecognitionException as re:

17594 localctx.exception = re

17595 self._errHandler.reportError(self, re)

17596 self._errHandler.recover(self, re)

17597 finally:

17598 self.exitRule()

17599 return localctx

17600

17601

17602 class Right_arrowContext(ParserRuleContext):

17603 __slots__ = 'parser'

17604

17605 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

17606 super().__init__(parent, invokingState)

17607 self.parser = parser

17608 self.first = None # Token

17609 self.second = None # Token

17610

17611 def ASSIGNMENT(self):

17612 return self.getToken(CSharpParser.ASSIGNMENT, 0)

17613

17614 def GT(self):

17615 return self.getToken(CSharpParser.GT, 0)

17616

17617 def getRuleIndex(self):

17618 return CSharpParser.RULE_right_arrow

17619

17620 def enterRule(self, listener:ParseTreeListener):

17621 if hasattr( listener, "enterRight_arrow" ):

17622 listener.enterRight_arrow(self)

17623

17624 def exitRule(self, listener:ParseTreeListener):

17625 if hasattr( listener, "exitRight_arrow" ):

17626 listener.exitRight_arrow(self)

17631 def right_arrow(self):

17632

17633 localctx = CSharpParser.Right_arrowContext(self, self._ctx, self.state)

17634 self.enterRule(localctx, 374, self.RULE_right_arrow)

17635 try:

17636 self.enterOuterAlt(localctx, 1)

17637 self.state = 2345

17638 localctx.first = self.match(CSharpParser.ASSIGNMENT)

17639 self.state = 2346

17640 localctx.second = self.match(CSharpParser.GT)

17641 self.state = 2347

17642 if not (0 if localctx.first is None else localctx.first.tokenIndex) + 1 == (0 if localctx.second is None else localctx.second.tokenIndex):

17643 from antlr4.error.Errors import FailedPredicateException

17644 raise FailedPredicateException(self, "$first.index + 1 == $second.index")

17645 except RecognitionException as re:

17646 localctx.exception = re

17647 self._errHandler.reportError(self, re)

17648 self._errHandler.recover(self, re)

17649 finally:

17650 self.exitRule()

17651 return localctx

17652

17653

17654 class Right_shiftContext(ParserRuleContext):

17655 __slots__ = 'parser'

17656

17657 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

17658 super().__init__(parent, invokingState)

17659 self.parser = parser

17660 self.first = None # Token

17661 self.second = None # Token

17662

17663 def GT(self, i:int=None):

17664 if i is None:

17665 return self.getTokens(CSharpParser.GT)

17666 else:

17667 return self.getToken(CSharpParser.GT, i)

17668

17669 def getRuleIndex(self):

17670 return CSharpParser.RULE_right_shift

17671

17672 def enterRule(self, listener:ParseTreeListener):

17673 if hasattr( listener, "enterRight_shift" ):

17674 listener.enterRight_shift(self)

17675

17676 def exitRule(self, listener:ParseTreeListener):

17677 if hasattr( listener, "exitRight_shift" ):

17678 listener.exitRight_shift(self)

17683 def right_shift(self):

17684

17685 localctx = CSharpParser.Right_shiftContext(self, self._ctx, self.state)

17686 self.enterRule(localctx, 376, self.RULE_right_shift)

17687 try:

17688 self.enterOuterAlt(localctx, 1)

17689 self.state = 2349

17690 localctx.first = self.match(CSharpParser.GT)

17691 self.state = 2350

17692 localctx.second = self.match(CSharpParser.GT)

17693 self.state = 2351

17694 if not (0 if localctx.first is None else localctx.first.tokenIndex) + 1 == (0 if localctx.second is None else localctx.second.tokenIndex):

17695 from antlr4.error.Errors import FailedPredicateException

17696 raise FailedPredicateException(self, "$first.index + 1 == $second.index")

17697 except RecognitionException as re:

17698 localctx.exception = re

17699 self._errHandler.reportError(self, re)

17700 self._errHandler.recover(self, re)

17701 finally:

17702 self.exitRule()

17703 return localctx

17704

17705

17706 class Right_shift_assignmentContext(ParserRuleContext):

17707 __slots__ = 'parser'

17708

17709 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

17710 super().__init__(parent, invokingState)

17711 self.parser = parser

17712 self.first = None # Token

17713 self.second = None # Token

17714

17715 def GT(self):

17716 return self.getToken(CSharpParser.GT, 0)

17717

17718 def OP_GE(self):

17719 return self.getToken(CSharpParser.OP_GE, 0)

17720

17721 def getRuleIndex(self):

17722 return CSharpParser.RULE_right_shift_assignment

17723

17724 def enterRule(self, listener:ParseTreeListener):

17725 if hasattr( listener, "enterRight_shift_assignment" ):

17726 listener.enterRight_shift_assignment(self)

17727

17728 def exitRule(self, listener:ParseTreeListener):

17729 if hasattr( listener, "exitRight_shift_assignment" ):

17730 listener.exitRight_shift_assignment(self)

17735 def right_shift_assignment(self):

17736

17737 localctx = CSharpParser.Right_shift_assignmentContext(self, self._ctx, self.state)

17738 self.enterRule(localctx, 378, self.RULE_right_shift_assignment)

17739 try:

17740 self.enterOuterAlt(localctx, 1)

17741 self.state = 2353

17742 localctx.first = self.match(CSharpParser.GT)

17743 self.state = 2354

17744 localctx.second = self.match(CSharpParser.OP_GE)

17745 self.state = 2355

17746 if not (0 if localctx.first is None else localctx.first.tokenIndex) + 1 == (0 if localctx.second is None else localctx.second.tokenIndex):

17747 from antlr4.error.Errors import FailedPredicateException

17748 raise FailedPredicateException(self, "$first.index + 1 == $second.index")

17749 except RecognitionException as re:

17750 localctx.exception = re

17751 self._errHandler.reportError(self, re)

17752 self._errHandler.recover(self, re)

17753 finally:

17754 self.exitRule()

17755 return localctx

17756

17757

17758 class LiteralContext(ParserRuleContext):

17759 __slots__ = 'parser'

17760

17761 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

17762 super().__init__(parent, invokingState)

17763 self.parser = parser

17764

17765 def boolean_literal(self):

17766 return self.getTypedRuleContext(CSharpParser.Boolean_literalContext,0)

17767

17768

17769 def string_literal(self):

17770 return self.getTypedRuleContext(CSharpParser.String_literalContext,0)

17771

17772

17773 def INTEGER_LITERAL(self):

17774 return self.getToken(CSharpParser.INTEGER_LITERAL, 0)

17775

17776 def HEX_INTEGER_LITERAL(self):

17777 return self.getToken(CSharpParser.HEX_INTEGER_LITERAL, 0)

17778

17779 def BIN_INTEGER_LITERAL(self):

17780 return self.getToken(CSharpParser.BIN_INTEGER_LITERAL, 0)

17781

17782 def REAL_LITERAL(self):

17783 return self.getToken(CSharpParser.REAL_LITERAL, 0)

17784

17785 def CHARACTER_LITERAL(self):

17786 return self.getToken(CSharpParser.CHARACTER_LITERAL, 0)

17787

17788 def NULL_(self):

17789 return self.getToken(CSharpParser.NULL_, 0)

17790

17791 def getRuleIndex(self):

17792 return CSharpParser.RULE_literal

17793

17794 def enterRule(self, listener:ParseTreeListener):

17795 if hasattr( listener, "enterLiteral" ):

17796 listener.enterLiteral(self)

17797

17798 def exitRule(self, listener:ParseTreeListener):

17799 if hasattr( listener, "exitLiteral" ):

17800 listener.exitLiteral(self)

17805 def literal(self):

17806

17807 localctx = CSharpParser.LiteralContext(self, self._ctx, self.state)

17808 self.enterRule(localctx, 380, self.RULE_literal)

17809 try:

17810 self.state = 2365

17811 self._errHandler.sync(self)

17812 token = self._input.LA(1)

17813 if token in [CSharpParser.FALSE, CSharpParser.TRUE]:

17814 self.enterOuterAlt(localctx, 1)

17815 self.state = 2357

17816 self.boolean_literal()

17817 pass

17818 elif token in [CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START]:

17819 self.enterOuterAlt(localctx, 2)

17820 self.state = 2358

17821 self.string_literal()

17822 pass

17823 elif token in [CSharpParser.INTEGER_LITERAL]:

17824 self.enterOuterAlt(localctx, 3)

17825 self.state = 2359

17826 self.match(CSharpParser.INTEGER_LITERAL)

17827 pass

17828 elif token in [CSharpParser.HEX_INTEGER_LITERAL]:

17829 self.enterOuterAlt(localctx, 4)

17830 self.state = 2360

17831 self.match(CSharpParser.HEX_INTEGER_LITERAL)

17832 pass

17833 elif token in [CSharpParser.BIN_INTEGER_LITERAL]:

17834 self.enterOuterAlt(localctx, 5)

17835 self.state = 2361

17836 self.match(CSharpParser.BIN_INTEGER_LITERAL)

17837 pass

17838 elif token in [CSharpParser.REAL_LITERAL]:

17839 self.enterOuterAlt(localctx, 6)

17840 self.state = 2362

17841 self.match(CSharpParser.REAL_LITERAL)

17842 pass

17843 elif token in [CSharpParser.CHARACTER_LITERAL]:

17844 self.enterOuterAlt(localctx, 7)

17845 self.state = 2363

17846 self.match(CSharpParser.CHARACTER_LITERAL)

17847 pass

17848 elif token in [CSharpParser.NULL_]:

17849 self.enterOuterAlt(localctx, 8)

17850 self.state = 2364

17851 self.match(CSharpParser.NULL_)

17852 pass

17853 else:

17854 raise NoViableAltException(self)

17855

17856 except RecognitionException as re:

17857 localctx.exception = re

17858 self._errHandler.reportError(self, re)

17859 self._errHandler.recover(self, re)

17860 finally:

17861 self.exitRule()

17862 return localctx

17863

17864

17865 class Boolean_literalContext(ParserRuleContext):

17866 __slots__ = 'parser'

17867

17868 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

17869 super().__init__(parent, invokingState)

17870 self.parser = parser

17871

17872 def TRUE(self):

17873 return self.getToken(CSharpParser.TRUE, 0)

17874

17875 def FALSE(self):

17876 return self.getToken(CSharpParser.FALSE, 0)

17877

17878 def getRuleIndex(self):

17879 return CSharpParser.RULE_boolean_literal

17880

17881 def enterRule(self, listener:ParseTreeListener):

17882 if hasattr( listener, "enterBoolean_literal" ):

17883 listener.enterBoolean_literal(self)

17884

17885 def exitRule(self, listener:ParseTreeListener):

17886 if hasattr( listener, "exitBoolean_literal" ):

17887 listener.exitBoolean_literal(self)

17892 def boolean_literal(self):

17893

17894 localctx = CSharpParser.Boolean_literalContext(self, self._ctx, self.state)

17895 self.enterRule(localctx, 382, self.RULE_boolean_literal)

17896 self._la = 0 # Token type

17897 try:

17898 self.enterOuterAlt(localctx, 1)

17899 self.state = 2367

17900 _la = self._input.LA(1)

17901 if not(_la==CSharpParser.FALSE or _la==CSharpParser.TRUE):

17902 self._errHandler.recoverInline(self)

17903 else:

17904 self._errHandler.reportMatch(self)

17905 self.consume()

17906 except RecognitionException as re:

17907 localctx.exception = re

17908 self._errHandler.reportError(self, re)

17909 self._errHandler.recover(self, re)

17910 finally:

17911 self.exitRule()

17912 return localctx

17913

17914

17915 class String_literalContext(ParserRuleContext):

17916 __slots__ = 'parser'

17917

17918 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

17919 super().__init__(parent, invokingState)

17920 self.parser = parser

17921

17922 def interpolated_regular_string(self):

17923 return self.getTypedRuleContext(CSharpParser.Interpolated_regular_stringContext,0)

17924

17925

17926 def interpolated_verbatium_string(self):

17927 return self.getTypedRuleContext(CSharpParser.Interpolated_verbatium_stringContext,0)

17928

17929

17930 def REGULAR_STRING(self):

17931 return self.getToken(CSharpParser.REGULAR_STRING, 0)

17932

17933 def VERBATIUM_STRING(self):

17934 return self.getToken(CSharpParser.VERBATIUM_STRING, 0)

17935

17936 def getRuleIndex(self):

17937 return CSharpParser.RULE_string_literal

17938

17939 def enterRule(self, listener:ParseTreeListener):

17940 if hasattr( listener, "enterString_literal" ):

17941 listener.enterString_literal(self)

17942

17943 def exitRule(self, listener:ParseTreeListener):

17944 if hasattr( listener, "exitString_literal" ):

17945 listener.exitString_literal(self)

17950 def string_literal(self):

17951

17952 localctx = CSharpParser.String_literalContext(self, self._ctx, self.state)

17953 self.enterRule(localctx, 384, self.RULE_string_literal)

17954 try:

17955 self.state = 2373

17956 self._errHandler.sync(self)

17957 token = self._input.LA(1)

17958 if token in [CSharpParser.INTERPOLATED_REGULAR_STRING_START]:

17959 self.enterOuterAlt(localctx, 1)

17960 self.state = 2369

17961 self.interpolated_regular_string()

17962 pass

17963 elif token in [CSharpParser.INTERPOLATED_VERBATIUM_STRING_START]:

17964 self.enterOuterAlt(localctx, 2)

17965 self.state = 2370

17966 self.interpolated_verbatium_string()

17967 pass

17968 elif token in [CSharpParser.REGULAR_STRING]:

17969 self.enterOuterAlt(localctx, 3)

17970 self.state = 2371

17971 self.match(CSharpParser.REGULAR_STRING)

17972 pass

17973 elif token in [CSharpParser.VERBATIUM_STRING]:

17974 self.enterOuterAlt(localctx, 4)

17975 self.state = 2372

17976 self.match(CSharpParser.VERBATIUM_STRING)

17977 pass

17978 else:

17979 raise NoViableAltException(self)

17980

17981 except RecognitionException as re:

17982 localctx.exception = re

17983 self._errHandler.reportError(self, re)

17984 self._errHandler.recover(self, re)

17985 finally:

17986 self.exitRule()

17987 return localctx

17988

17989

17990 class Interpolated_regular_stringContext(ParserRuleContext):

17991 __slots__ = 'parser'

17992

17993 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

17994 super().__init__(parent, invokingState)

17995 self.parser = parser

17996

17997 def INTERPOLATED_REGULAR_STRING_START(self):

17998 return self.getToken(CSharpParser.INTERPOLATED_REGULAR_STRING_START, 0)

17999

18000 def DOUBLE_QUOTE_INSIDE(self):

18001 return self.getToken(CSharpParser.DOUBLE_QUOTE_INSIDE, 0)

18002

18003 def interpolated_regular_string_part(self, i:int=None):

18004 if i is None:

18005 return self.getTypedRuleContexts(CSharpParser.Interpolated_regular_string_partContext)

18006 else:

18007 return self.getTypedRuleContext(CSharpParser.Interpolated_regular_string_partContext,i)

18008

18009

18010 def getRuleIndex(self):

18011 return CSharpParser.RULE_interpolated_regular_string

18012

18013 def enterRule(self, listener:ParseTreeListener):

18014 if hasattr( listener, "enterInterpolated_regular_string" ):

18015 listener.enterInterpolated_regular_string(self)

18016

18017 def exitRule(self, listener:ParseTreeListener):

18018 if hasattr( listener, "exitInterpolated_regular_string" ):

18019 listener.exitInterpolated_regular_string(self)

18024 def interpolated_regular_string(self):

18025

18026 localctx = CSharpParser.Interpolated_regular_stringContext(self, self._ctx, self.state)

18027 self.enterRule(localctx, 386, self.RULE_interpolated_regular_string)

18028 self._la = 0 # Token type

18029 try:

18030 self.enterOuterAlt(localctx, 1)

18031 self.state = 2375

18032 self.match(CSharpParser.INTERPOLATED_REGULAR_STRING_START)

18033 self.state = 2379

18034 self._errHandler.sync(self)

18035 _la = self._input.LA(1)

18037 self.state = 2376

18038 self.interpolated_regular_string_part()

18039 self.state = 2381

18040 self._errHandler.sync(self)

18041 _la = self._input.LA(1)

18042

18043 self.state = 2382

18044 self.match(CSharpParser.DOUBLE_QUOTE_INSIDE)

18045 except RecognitionException as re:

18046 localctx.exception = re

18047 self._errHandler.reportError(self, re)

18048 self._errHandler.recover(self, re)

18049 finally:

18050 self.exitRule()

18051 return localctx

18052

18053

18054 class Interpolated_verbatium_stringContext(ParserRuleContext):

18055 __slots__ = 'parser'

18056

18057 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

18058 super().__init__(parent, invokingState)

18059 self.parser = parser

18060

18061 def INTERPOLATED_VERBATIUM_STRING_START(self):

18062 return self.getToken(CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, 0)

18063

18064 def DOUBLE_QUOTE_INSIDE(self):

18065 return self.getToken(CSharpParser.DOUBLE_QUOTE_INSIDE, 0)

18066

18067 def interpolated_verbatium_string_part(self, i:int=None):

18068 if i is None:

18069 return self.getTypedRuleContexts(CSharpParser.Interpolated_verbatium_string_partContext)

18070 else:

18071 return self.getTypedRuleContext(CSharpParser.Interpolated_verbatium_string_partContext,i)

18072

18073

18074 def getRuleIndex(self):

18075 return CSharpParser.RULE_interpolated_verbatium_string

18076

18077 def enterRule(self, listener:ParseTreeListener):

18078 if hasattr( listener, "enterInterpolated_verbatium_string" ):

18079 listener.enterInterpolated_verbatium_string(self)

18080

18081 def exitRule(self, listener:ParseTreeListener):

18082 if hasattr( listener, "exitInterpolated_verbatium_string" ):

18083 listener.exitInterpolated_verbatium_string(self)

18088 def interpolated_verbatium_string(self):

18089

18090 localctx = CSharpParser.Interpolated_verbatium_stringContext(self, self._ctx, self.state)

18091 self.enterRule(localctx, 388, self.RULE_interpolated_verbatium_string)

18092 self._la = 0 # Token type

18093 try:

18094 self.enterOuterAlt(localctx, 1)

18095 self.state = 2384

18096 self.match(CSharpParser.INTERPOLATED_VERBATIUM_STRING_START)

18097 self.state = 2388

18098 self._errHandler.sync(self)

18099 _la = self._input.LA(1)

18101 self.state = 2385

18102 self.interpolated_verbatium_string_part()

18103 self.state = 2390

18104 self._errHandler.sync(self)

18105 _la = self._input.LA(1)

18106

18107 self.state = 2391

18108 self.match(CSharpParser.DOUBLE_QUOTE_INSIDE)

18109 except RecognitionException as re:

18110 localctx.exception = re

18111 self._errHandler.reportError(self, re)

18112 self._errHandler.recover(self, re)

18113 finally:

18114 self.exitRule()

18115 return localctx

18116

18117

18118 class Interpolated_regular_string_partContext(ParserRuleContext):

18119 __slots__ = 'parser'

18120

18121 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

18122 super().__init__(parent, invokingState)

18123 self.parser = parser

18124

18125 def interpolated_string_expression(self):

18126 return self.getTypedRuleContext(CSharpParser.Interpolated_string_expressionContext,0)

18127

18128

18129 def DOUBLE_CURLY_INSIDE(self):

18130 return self.getToken(CSharpParser.DOUBLE_CURLY_INSIDE, 0)

18131

18132 def REGULAR_CHAR_INSIDE(self):

18133 return self.getToken(CSharpParser.REGULAR_CHAR_INSIDE, 0)

18134

18135 def REGULAR_STRING_INSIDE(self):

18136 return self.getToken(CSharpParser.REGULAR_STRING_INSIDE, 0)

18137

18138 def getRuleIndex(self):

18139 return CSharpParser.RULE_interpolated_regular_string_part

18140

18141 def enterRule(self, listener:ParseTreeListener):

18142 if hasattr( listener, "enterInterpolated_regular_string_part" ):

18143 listener.enterInterpolated_regular_string_part(self)

18144

18145 def exitRule(self, listener:ParseTreeListener):

18146 if hasattr( listener, "exitInterpolated_regular_string_part" ):

18147 listener.exitInterpolated_regular_string_part(self)

18152 def interpolated_regular_string_part(self):

18153

18154 localctx = CSharpParser.Interpolated_regular_string_partContext(self, self._ctx, self.state)

18155 self.enterRule(localctx, 390, self.RULE_interpolated_regular_string_part)

18156 try:

18157 self.state = 2397

18158 self._errHandler.sync(self)

18159 token = self._input.LA(1)

18160 if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:

18161 self.enterOuterAlt(localctx, 1)

18162 self.state = 2393

18163 self.interpolated_string_expression()

18164 pass

18165 elif token in [CSharpParser.DOUBLE_CURLY_INSIDE]:

18166 self.enterOuterAlt(localctx, 2)

18167 self.state = 2394

18168 self.match(CSharpParser.DOUBLE_CURLY_INSIDE)

18169 pass

18170 elif token in [CSharpParser.REGULAR_CHAR_INSIDE]:

18171 self.enterOuterAlt(localctx, 3)

18172 self.state = 2395

18173 self.match(CSharpParser.REGULAR_CHAR_INSIDE)

18174 pass

18175 elif token in [CSharpParser.REGULAR_STRING_INSIDE]:

18176 self.enterOuterAlt(localctx, 4)

18177 self.state = 2396

18178 self.match(CSharpParser.REGULAR_STRING_INSIDE)

18179 pass

18180 else:

18181 raise NoViableAltException(self)

18182

18183 except RecognitionException as re:

18184 localctx.exception = re

18185 self._errHandler.reportError(self, re)

18186 self._errHandler.recover(self, re)

18187 finally:

18188 self.exitRule()

18189 return localctx

18190

18191

18192 class Interpolated_verbatium_string_partContext(ParserRuleContext):

18193 __slots__ = 'parser'

18194

18195 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

18196 super().__init__(parent, invokingState)

18197 self.parser = parser

18198

18199 def interpolated_string_expression(self):

18200 return self.getTypedRuleContext(CSharpParser.Interpolated_string_expressionContext,0)

18201

18202

18203 def DOUBLE_CURLY_INSIDE(self):

18204 return self.getToken(CSharpParser.DOUBLE_CURLY_INSIDE, 0)

18205

18206 def VERBATIUM_DOUBLE_QUOTE_INSIDE(self):

18207 return self.getToken(CSharpParser.VERBATIUM_DOUBLE_QUOTE_INSIDE, 0)

18208

18209 def VERBATIUM_INSIDE_STRING(self):

18210 return self.getToken(CSharpParser.VERBATIUM_INSIDE_STRING, 0)

18211

18212 def getRuleIndex(self):

18213 return CSharpParser.RULE_interpolated_verbatium_string_part

18214

18215 def enterRule(self, listener:ParseTreeListener):

18216 if hasattr( listener, "enterInterpolated_verbatium_string_part" ):

18217 listener.enterInterpolated_verbatium_string_part(self)

18218

18219 def exitRule(self, listener:ParseTreeListener):

18220 if hasattr( listener, "exitInterpolated_verbatium_string_part" ):

18221 listener.exitInterpolated_verbatium_string_part(self)

18226 def interpolated_verbatium_string_part(self):

18227

18228 localctx = CSharpParser.Interpolated_verbatium_string_partContext(self, self._ctx, self.state)

18229 self.enterRule(localctx, 392, self.RULE_interpolated_verbatium_string_part)

18230 try:

18231 self.state = 2403

18232 self._errHandler.sync(self)

18233 token = self._input.LA(1)

18234 if token in [CSharpParser.ADD, CSharpParser.ALIAS, CSharpParser.ARGLIST, CSharpParser.ASCENDING, CSharpParser.ASYNC, CSharpParser.AWAIT, CSharpParser.BASE, CSharpParser.BOOL, CSharpParser.BY, CSharpParser.BYTE, CSharpParser.CHAR, CSharpParser.CHECKED, CSharpParser.DECIMAL, CSharpParser.DEFAULT, CSharpParser.DELEGATE, CSharpParser.DESCENDING, CSharpParser.DOUBLE, CSharpParser.DYNAMIC, CSharpParser.EQUALS, CSharpParser.FALSE, CSharpParser.FLOAT, CSharpParser.FROM, CSharpParser.GET, CSharpParser.GROUP, CSharpParser.INT, CSharpParser.INTO, CSharpParser.JOIN, CSharpParser.LET, CSharpParser.LONG, CSharpParser.NAMEOF, CSharpParser.NEW, CSharpParser.NULL_, CSharpParser.OBJECT, CSharpParser.ON, CSharpParser.ORDERBY, CSharpParser.PARTIAL, CSharpParser.REF, CSharpParser.REMOVE, CSharpParser.SBYTE, CSharpParser.SELECT, CSharpParser.SET, CSharpParser.SHORT, CSharpParser.SIZEOF, CSharpParser.STRING, CSharpParser.THIS, CSharpParser.TRUE, CSharpParser.TYPEOF, CSharpParser.UINT, CSharpParser.ULONG, CSharpParser.UNCHECKED, CSharpParser.UNMANAGED, CSharpParser.USHORT, CSharpParser.VAR, CSharpParser.WHEN, CSharpParser.WHERE, CSharpParser.YIELD, CSharpParser.IDENTIFIER, CSharpParser.LITERAL_ACCESS, CSharpParser.INTEGER_LITERAL, CSharpParser.HEX_INTEGER_LITERAL, CSharpParser.BIN_INTEGER_LITERAL, CSharpParser.REAL_LITERAL, CSharpParser.CHARACTER_LITERAL, CSharpParser.REGULAR_STRING, CSharpParser.VERBATIUM_STRING, CSharpParser.INTERPOLATED_REGULAR_STRING_START, CSharpParser.INTERPOLATED_VERBATIUM_STRING_START, CSharpParser.OPEN_PARENS, CSharpParser.PLUS, CSharpParser.MINUS, CSharpParser.STAR, CSharpParser.AMP, CSharpParser.CARET, CSharpParser.BANG, CSharpParser.TILDE, CSharpParser.OP_INC, CSharpParser.OP_DEC, CSharpParser.OP_RANGE]:

18235 self.enterOuterAlt(localctx, 1)

18236 self.state = 2399

18237 self.interpolated_string_expression()

18238 pass

18239 elif token in [CSharpParser.DOUBLE_CURLY_INSIDE]:

18240 self.enterOuterAlt(localctx, 2)

18241 self.state = 2400

18242 self.match(CSharpParser.DOUBLE_CURLY_INSIDE)

18243 pass

18244 elif token in [CSharpParser.VERBATIUM_DOUBLE_QUOTE_INSIDE]:

18245 self.enterOuterAlt(localctx, 3)

18246 self.state = 2401

18247 self.match(CSharpParser.VERBATIUM_DOUBLE_QUOTE_INSIDE)

18248 pass

18249 elif token in [CSharpParser.VERBATIUM_INSIDE_STRING]:

18250 self.enterOuterAlt(localctx, 4)

18251 self.state = 2402

18252 self.match(CSharpParser.VERBATIUM_INSIDE_STRING)

18253 pass

18254 else:

18255 raise NoViableAltException(self)

18256

18257 except RecognitionException as re:

18258 localctx.exception = re

18259 self._errHandler.reportError(self, re)

18260 self._errHandler.recover(self, re)

18261 finally:

18262 self.exitRule()

18263 return localctx

18264

18265

18266 class Interpolated_string_expressionContext(ParserRuleContext):

18267 __slots__ = 'parser'

18268

18269 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

18270 super().__init__(parent, invokingState)

18271 self.parser = parser

18272

18273 def expression(self, i:int=None):

18274 if i is None:

18275 return self.getTypedRuleContexts(CSharpParser.ExpressionContext)

18276 else:

18277 return self.getTypedRuleContext(CSharpParser.ExpressionContext,i)

18278

18279

18280 def COMMA(self, i:int=None):

18281 if i is None:

18282 return self.getTokens(CSharpParser.COMMA)

18283 else:

18284 return self.getToken(CSharpParser.COMMA, i)

18285

18286 def COLON(self):

18287 return self.getToken(CSharpParser.COLON, 0)

18288

18289 def FORMAT_STRING(self, i:int=None):

18290 if i is None:

18291 return self.getTokens(CSharpParser.FORMAT_STRING)

18292 else:

18293 return self.getToken(CSharpParser.FORMAT_STRING, i)

18294

18295 def getRuleIndex(self):

18296 return CSharpParser.RULE_interpolated_string_expression

18297

18298 def enterRule(self, listener:ParseTreeListener):

18299 if hasattr( listener, "enterInterpolated_string_expression" ):

18300 listener.enterInterpolated_string_expression(self)

18301

18302 def exitRule(self, listener:ParseTreeListener):

18303 if hasattr( listener, "exitInterpolated_string_expression" ):

18304 listener.exitInterpolated_string_expression(self)

18309 def interpolated_string_expression(self):

18310

18311 localctx = CSharpParser.Interpolated_string_expressionContext(self, self._ctx, self.state)

18312 self.enterRule(localctx, 394, self.RULE_interpolated_string_expression)

18313 self._la = 0 # Token type

18314 try:

18315 self.enterOuterAlt(localctx, 1)

18316 self.state = 2405

18317 self.expression()

18318 self.state = 2410

18319 self._errHandler.sync(self)

18320 _la = self._input.LA(1)

18321 while _la==CSharpParser.COMMA:

18322 self.state = 2406

18323 self.match(CSharpParser.COMMA)

18324 self.state = 2407

18325 self.expression()

18326 self.state = 2412

18327 self._errHandler.sync(self)

18328 _la = self._input.LA(1)

18329

18330 self.state = 2419

18331 self._errHandler.sync(self)

18332 _la = self._input.LA(1)

18333 if _la==CSharpParser.COLON:

18334 self.state = 2413

18335 self.match(CSharpParser.COLON)

18336 self.state = 2415

18337 self._errHandler.sync(self)

18338 _la = self._input.LA(1)

18339 while True:

18340 self.state = 2414

18341 self.match(CSharpParser.FORMAT_STRING)

18342 self.state = 2417

18343 self._errHandler.sync(self)

18344 _la = self._input.LA(1)

18345 if not (_la==CSharpParser.FORMAT_STRING):

18346 break

18347

18348

18349

18350 except RecognitionException as re:

18351 localctx.exception = re

18352 self._errHandler.reportError(self, re)

18353 self._errHandler.recover(self, re)

18354 finally:

18355 self.exitRule()

18356 return localctx

18357

18358

18359 class KeywordContext(ParserRuleContext):

18360 __slots__ = 'parser'

18361

18362 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

18363 super().__init__(parent, invokingState)

18364 self.parser = parser

18365

18366 def ABSTRACT(self):

18367 return self.getToken(CSharpParser.ABSTRACT, 0)

18368

18369 def AS(self):

18370 return self.getToken(CSharpParser.AS, 0)

18371

18372 def BASE(self):

18373 return self.getToken(CSharpParser.BASE, 0)

18374

18375 def BOOL(self):

18376 return self.getToken(CSharpParser.BOOL, 0)

18377

18378 def BREAK(self):

18379 return self.getToken(CSharpParser.BREAK, 0)

18380

18381 def BYTE(self):

18382 return self.getToken(CSharpParser.BYTE, 0)

18383

18384 def CASE(self):

18385 return self.getToken(CSharpParser.CASE, 0)

18386

18387 def CATCH(self):

18388 return self.getToken(CSharpParser.CATCH, 0)

18389

18390 def CHAR(self):

18391 return self.getToken(CSharpParser.CHAR, 0)

18392

18393 def CHECKED(self):

18394 return self.getToken(CSharpParser.CHECKED, 0)

18395

18396 def CLASS(self):

18397 return self.getToken(CSharpParser.CLASS, 0)

18398

18399 def CONST(self):

18400 return self.getToken(CSharpParser.CONST, 0)

18401

18402 def CONTINUE(self):

18403 return self.getToken(CSharpParser.CONTINUE, 0)

18404

18405 def DECIMAL(self):

18406 return self.getToken(CSharpParser.DECIMAL, 0)

18407

18408 def DEFAULT(self):

18409 return self.getToken(CSharpParser.DEFAULT, 0)

18410

18411 def DELEGATE(self):

18412 return self.getToken(CSharpParser.DELEGATE, 0)

18413

18414 def DO(self):

18415 return self.getToken(CSharpParser.DO, 0)

18416

18417 def DOUBLE(self):

18418 return self.getToken(CSharpParser.DOUBLE, 0)

18419

18420 def ELSE(self):

18421 return self.getToken(CSharpParser.ELSE, 0)

18422

18423 def ENUM(self):

18424 return self.getToken(CSharpParser.ENUM, 0)

18425

18426 def EVENT(self):

18427 return self.getToken(CSharpParser.EVENT, 0)

18428

18429 def EXPLICIT(self):

18430 return self.getToken(CSharpParser.EXPLICIT, 0)

18431

18432 def EXTERN(self):

18433 return self.getToken(CSharpParser.EXTERN, 0)

18434

18435 def FALSE(self):

18436 return self.getToken(CSharpParser.FALSE, 0)

18437

18438 def FINALLY(self):

18439 return self.getToken(CSharpParser.FINALLY, 0)

18440

18441 def FIXED(self):

18442 return self.getToken(CSharpParser.FIXED, 0)

18443

18444 def FLOAT(self):

18445 return self.getToken(CSharpParser.FLOAT, 0)

18446

18447 def FOR(self):

18448 return self.getToken(CSharpParser.FOR, 0)

18449

18450 def FOREACH(self):

18451 return self.getToken(CSharpParser.FOREACH, 0)

18452

18453 def GOTO(self):

18454 return self.getToken(CSharpParser.GOTO, 0)

18455

18456 def IF(self):

18457 return self.getToken(CSharpParser.IF, 0)

18458

18459 def IMPLICIT(self):

18460 return self.getToken(CSharpParser.IMPLICIT, 0)

18461

18462 def IN(self):

18463 return self.getToken(CSharpParser.IN, 0)

18464

18465 def INT(self):

18466 return self.getToken(CSharpParser.INT, 0)

18467

18468 def INTERFACE(self):

18469 return self.getToken(CSharpParser.INTERFACE, 0)

18470

18471 def INTERNAL(self):

18472 return self.getToken(CSharpParser.INTERNAL, 0)

18473

18474 def IS(self):

18475 return self.getToken(CSharpParser.IS, 0)

18476

18477 def LOCK(self):

18478 return self.getToken(CSharpParser.LOCK, 0)

18479

18480 def LONG(self):

18481 return self.getToken(CSharpParser.LONG, 0)

18482

18483 def NAMESPACE(self):

18484 return self.getToken(CSharpParser.NAMESPACE, 0)

18485

18486 def NEW(self):

18487 return self.getToken(CSharpParser.NEW, 0)

18488

18489 def NULL_(self):

18490 return self.getToken(CSharpParser.NULL_, 0)

18491

18492 def OBJECT(self):

18493 return self.getToken(CSharpParser.OBJECT, 0)

18494

18495 def OPERATOR(self):

18496 return self.getToken(CSharpParser.OPERATOR, 0)

18497

18498 def OUT(self):

18499 return self.getToken(CSharpParser.OUT, 0)

18500

18501 def OVERRIDE(self):

18502 return self.getToken(CSharpParser.OVERRIDE, 0)

18503

18504 def PARAMS(self):

18505 return self.getToken(CSharpParser.PARAMS, 0)

18506

18507 def PRIVATE(self):

18508 return self.getToken(CSharpParser.PRIVATE, 0)

18509

18510 def PROTECTED(self):

18511 return self.getToken(CSharpParser.PROTECTED, 0)

18512

18513 def PUBLIC(self):

18514 return self.getToken(CSharpParser.PUBLIC, 0)

18515

18516 def READONLY(self):

18517 return self.getToken(CSharpParser.READONLY, 0)

18518

18519 def REF(self):

18520 return self.getToken(CSharpParser.REF, 0)

18521

18522 def RETURN(self):

18523 return self.getToken(CSharpParser.RETURN, 0)

18524

18525 def SBYTE(self):

18526 return self.getToken(CSharpParser.SBYTE, 0)

18527

18528 def SEALED(self):

18529 return self.getToken(CSharpParser.SEALED, 0)

18530

18531 def SHORT(self):

18532 return self.getToken(CSharpParser.SHORT, 0)

18533

18534 def SIZEOF(self):

18535 return self.getToken(CSharpParser.SIZEOF, 0)

18536

18537 def STACKALLOC(self):

18538 return self.getToken(CSharpParser.STACKALLOC, 0)

18539

18540 def STATIC(self):

18541 return self.getToken(CSharpParser.STATIC, 0)

18542

18543 def STRING(self):

18544 return self.getToken(CSharpParser.STRING, 0)

18545

18546 def STRUCT(self):

18547 return self.getToken(CSharpParser.STRUCT, 0)

18548

18549 def SWITCH(self):

18550 return self.getToken(CSharpParser.SWITCH, 0)

18551

18552 def THIS(self):

18553 return self.getToken(CSharpParser.THIS, 0)

18554

18555 def THROW(self):

18556 return self.getToken(CSharpParser.THROW, 0)

18557

18558 def TRUE(self):

18559 return self.getToken(CSharpParser.TRUE, 0)

18560

18561 def TRY(self):

18562 return self.getToken(CSharpParser.TRY, 0)

18563

18564 def TYPEOF(self):

18565 return self.getToken(CSharpParser.TYPEOF, 0)

18566

18567 def UINT(self):

18568 return self.getToken(CSharpParser.UINT, 0)

18569

18570 def ULONG(self):

18571 return self.getToken(CSharpParser.ULONG, 0)

18572

18573 def UNCHECKED(self):

18574 return self.getToken(CSharpParser.UNCHECKED, 0)

18575

18576 def UNMANAGED(self):

18577 return self.getToken(CSharpParser.UNMANAGED, 0)

18578

18579 def UNSAFE(self):

18580 return self.getToken(CSharpParser.UNSAFE, 0)

18581

18582 def USHORT(self):

18583 return self.getToken(CSharpParser.USHORT, 0)

18584

18585 def USING(self):

18586 return self.getToken(CSharpParser.USING, 0)

18587

18588 def VIRTUAL(self):

18589 return self.getToken(CSharpParser.VIRTUAL, 0)

18590

18591 def VOID(self):

18592 return self.getToken(CSharpParser.VOID, 0)

18593

18594 def VOLATILE(self):

18595 return self.getToken(CSharpParser.VOLATILE, 0)

18596

18597 def WHILE(self):

18598 return self.getToken(CSharpParser.WHILE, 0)

18599

18600 def getRuleIndex(self):

18601 return CSharpParser.RULE_keyword

18602

18603 def enterRule(self, listener:ParseTreeListener):

18604 if hasattr( listener, "enterKeyword" ):

18605 listener.enterKeyword(self)

18606

18607 def exitRule(self, listener:ParseTreeListener):

18608 if hasattr( listener, "exitKeyword" ):

18609 listener.exitKeyword(self)

18614 def keyword(self):

18615

18616 localctx = CSharpParser.KeywordContext(self, self._ctx, self.state)

18617 self.enterRule(localctx, 396, self.RULE_keyword)

18618 self._la = 0 # Token type

18619 try:

18620 self.enterOuterAlt(localctx, 1)

18621 self.state = 2421

18622 _la = self._input.LA(1)

18624 self._errHandler.recoverInline(self)

18625 else:

18626 self._errHandler.reportMatch(self)

18627 self.consume()

18628 except RecognitionException as re:

18629 localctx.exception = re

18630 self._errHandler.reportError(self, re)

18631 self._errHandler.recover(self, re)

18632 finally:

18633 self.exitRule()

18634 return localctx

18635

18636

18637 class Class_definitionContext(ParserRuleContext):

18638 __slots__ = 'parser'

18639

18640 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

18641 super().__init__(parent, invokingState)

18642 self.parser = parser

18643

18644 def CLASS(self):

18645 return self.getToken(CSharpParser.CLASS, 0)

18646

18647 def identifier(self):

18648 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

18649

18650

18651 def class_body(self):

18652 return self.getTypedRuleContext(CSharpParser.Class_bodyContext,0)

18653

18654

18655 def type_parameter_list(self):

18656 return self.getTypedRuleContext(CSharpParser.Type_parameter_listContext,0)

18657

18658

18659 def class_base(self):

18660 return self.getTypedRuleContext(CSharpParser.Class_baseContext,0)

18661

18662

18663 def type_parameter_constraints_clauses(self):

18664 return self.getTypedRuleContext(CSharpParser.Type_parameter_constraints_clausesContext,0)

18665

18666

18667 def SEMICOLON(self):

18668 return self.getToken(CSharpParser.SEMICOLON, 0)

18669

18670 def getRuleIndex(self):

18671 return CSharpParser.RULE_class_definition

18672

18673 def enterRule(self, listener:ParseTreeListener):

18674 if hasattr( listener, "enterClass_definition" ):

18675 listener.enterClass_definition(self)

18676

18677 def exitRule(self, listener:ParseTreeListener):

18678 if hasattr( listener, "exitClass_definition" ):

18679 listener.exitClass_definition(self)

18684 def class_definition(self):

18685

18686 localctx = CSharpParser.Class_definitionContext(self, self._ctx, self.state)

18687 self.enterRule(localctx, 398, self.RULE_class_definition)

18688 self._la = 0 # Token type

18689 try:

18690 self.enterOuterAlt(localctx, 1)

18691 self.state = 2423

18692 self.match(CSharpParser.CLASS)

18693 self.state = 2424

18694 self.identifier()

18695 self.state = 2426

18696 self._errHandler.sync(self)

18697 _la = self._input.LA(1)

18698 if _la==CSharpParser.LT:

18699 self.state = 2425

18700 self.type_parameter_list()

18701

18702

18703 self.state = 2429

18704 self._errHandler.sync(self)

18705 _la = self._input.LA(1)

18706 if _la==CSharpParser.COLON:

18707 self.state = 2428

18708 self.class_base()

18709

18710

18711 self.state = 2432

18712 self._errHandler.sync(self)

18713 _la = self._input.LA(1)

18714 if _la==CSharpParser.WHERE:

18715 self.state = 2431

18716 self.type_parameter_constraints_clauses()

18717

18718

18719 self.state = 2434

18720 self.class_body()

18721 self.state = 2436

18722 self._errHandler.sync(self)

18723 _la = self._input.LA(1)

18724 if _la==CSharpParser.SEMICOLON:

18725 self.state = 2435

18726 self.match(CSharpParser.SEMICOLON)

18727

18728

18729 except RecognitionException as re:

18730 localctx.exception = re

18731 self._errHandler.reportError(self, re)

18732 self._errHandler.recover(self, re)

18733 finally:

18734 self.exitRule()

18735 return localctx

18736

18737

18738 class Struct_definitionContext(ParserRuleContext):

18739 __slots__ = 'parser'

18740

18741 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

18742 super().__init__(parent, invokingState)

18743 self.parser = parser

18744

18745 def STRUCT(self):

18746 return self.getToken(CSharpParser.STRUCT, 0)

18747

18748 def identifier(self):

18749 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

18750

18751

18752 def struct_body(self):

18753 return self.getTypedRuleContext(CSharpParser.Struct_bodyContext,0)

18754

18755

18756 def type_parameter_list(self):

18757 return self.getTypedRuleContext(CSharpParser.Type_parameter_listContext,0)

18758

18759

18760 def struct_interfaces(self):

18761 return self.getTypedRuleContext(CSharpParser.Struct_interfacesContext,0)

18762

18763

18764 def type_parameter_constraints_clauses(self):

18765 return self.getTypedRuleContext(CSharpParser.Type_parameter_constraints_clausesContext,0)

18766

18767

18768 def SEMICOLON(self):

18769 return self.getToken(CSharpParser.SEMICOLON, 0)

18770

18771 def READONLY(self):

18772 return self.getToken(CSharpParser.READONLY, 0)

18773

18774 def REF(self):

18775 return self.getToken(CSharpParser.REF, 0)

18776

18777 def getRuleIndex(self):

18778 return CSharpParser.RULE_struct_definition

18779

18780 def enterRule(self, listener:ParseTreeListener):

18781 if hasattr( listener, "enterStruct_definition" ):

18782 listener.enterStruct_definition(self)

18783

18784 def exitRule(self, listener:ParseTreeListener):

18785 if hasattr( listener, "exitStruct_definition" ):

18786 listener.exitStruct_definition(self)

18791 def struct_definition(self):

18792

18793 localctx = CSharpParser.Struct_definitionContext(self, self._ctx, self.state)

18794 self.enterRule(localctx, 400, self.RULE_struct_definition)

18795 self._la = 0 # Token type

18796 try:

18797 self.enterOuterAlt(localctx, 1)

18798 self.state = 2439

18799 self._errHandler.sync(self)

18800 _la = self._input.LA(1)

18801 if _la==CSharpParser.READONLY or _la==CSharpParser.REF:

18802 self.state = 2438

18803 _la = self._input.LA(1)

18804 if not(_la==CSharpParser.READONLY or _la==CSharpParser.REF):

18805 self._errHandler.recoverInline(self)

18806 else:

18807 self._errHandler.reportMatch(self)

18808 self.consume()

18809

18810

18811 self.state = 2441

18812 self.match(CSharpParser.STRUCT)

18813 self.state = 2442

18814 self.identifier()

18815 self.state = 2444

18816 self._errHandler.sync(self)

18817 _la = self._input.LA(1)

18818 if _la==CSharpParser.LT:

18819 self.state = 2443

18820 self.type_parameter_list()

18821

18822

18823 self.state = 2447

18824 self._errHandler.sync(self)

18825 _la = self._input.LA(1)

18826 if _la==CSharpParser.COLON:

18827 self.state = 2446

18828 self.struct_interfaces()

18829

18830

18831 self.state = 2450

18832 self._errHandler.sync(self)

18833 _la = self._input.LA(1)

18834 if _la==CSharpParser.WHERE:

18835 self.state = 2449

18836 self.type_parameter_constraints_clauses()

18837

18838

18839 self.state = 2452

18840 self.struct_body()

18841 self.state = 2454

18842 self._errHandler.sync(self)

18843 _la = self._input.LA(1)

18844 if _la==CSharpParser.SEMICOLON:

18845 self.state = 2453

18846 self.match(CSharpParser.SEMICOLON)

18847

18848

18849 except RecognitionException as re:

18850 localctx.exception = re

18851 self._errHandler.reportError(self, re)

18852 self._errHandler.recover(self, re)

18853 finally:

18854 self.exitRule()

18855 return localctx

18856

18857

18858 class Interface_definitionContext(ParserRuleContext):

18859 __slots__ = 'parser'

18860

18861 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

18862 super().__init__(parent, invokingState)

18863 self.parser = parser

18864

18865 def INTERFACE(self):

18866 return self.getToken(CSharpParser.INTERFACE, 0)

18867

18868 def identifier(self):

18869 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

18870

18871

18872 def class_body(self):

18873 return self.getTypedRuleContext(CSharpParser.Class_bodyContext,0)

18874

18875

18876 def variant_type_parameter_list(self):

18877 return self.getTypedRuleContext(CSharpParser.Variant_type_parameter_listContext,0)

18878

18879

18880 def interface_base(self):

18881 return self.getTypedRuleContext(CSharpParser.Interface_baseContext,0)

18882

18883

18884 def type_parameter_constraints_clauses(self):

18885 return self.getTypedRuleContext(CSharpParser.Type_parameter_constraints_clausesContext,0)

18886

18887

18888 def SEMICOLON(self):

18889 return self.getToken(CSharpParser.SEMICOLON, 0)

18890

18891 def getRuleIndex(self):

18892 return CSharpParser.RULE_interface_definition

18893

18894 def enterRule(self, listener:ParseTreeListener):

18895 if hasattr( listener, "enterInterface_definition" ):

18896 listener.enterInterface_definition(self)

18897

18898 def exitRule(self, listener:ParseTreeListener):

18899 if hasattr( listener, "exitInterface_definition" ):

18900 listener.exitInterface_definition(self)

18905 def interface_definition(self):

18906

18907 localctx = CSharpParser.Interface_definitionContext(self, self._ctx, self.state)

18908 self.enterRule(localctx, 402, self.RULE_interface_definition)

18909 self._la = 0 # Token type

18910 try:

18911 self.enterOuterAlt(localctx, 1)

18912 self.state = 2456

18913 self.match(CSharpParser.INTERFACE)

18914 self.state = 2457

18915 self.identifier()

18916 self.state = 2459

18917 self._errHandler.sync(self)

18918 _la = self._input.LA(1)

18919 if _la==CSharpParser.LT:

18920 self.state = 2458

18921 self.variant_type_parameter_list()

18922

18923

18924 self.state = 2462

18925 self._errHandler.sync(self)

18926 _la = self._input.LA(1)

18927 if _la==CSharpParser.COLON:

18928 self.state = 2461

18929 self.interface_base()

18930

18931

18932 self.state = 2465

18933 self._errHandler.sync(self)

18934 _la = self._input.LA(1)

18935 if _la==CSharpParser.WHERE:

18936 self.state = 2464

18937 self.type_parameter_constraints_clauses()

18938

18939

18940 self.state = 2467

18941 self.class_body()

18942 self.state = 2469

18943 self._errHandler.sync(self)

18944 _la = self._input.LA(1)

18945 if _la==CSharpParser.SEMICOLON:

18946 self.state = 2468

18947 self.match(CSharpParser.SEMICOLON)

18948

18949

18950 except RecognitionException as re:

18951 localctx.exception = re

18952 self._errHandler.reportError(self, re)

18953 self._errHandler.recover(self, re)

18954 finally:

18955 self.exitRule()

18956 return localctx

18957

18958

18959 class Enum_definitionContext(ParserRuleContext):

18960 __slots__ = 'parser'

18961

18962 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

18963 super().__init__(parent, invokingState)

18964 self.parser = parser

18965

18966 def ENUM(self):

18967 return self.getToken(CSharpParser.ENUM, 0)

18968

18969 def identifier(self):

18970 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

18971

18972

18973 def enum_body(self):

18974 return self.getTypedRuleContext(CSharpParser.Enum_bodyContext,0)

18975

18976

18977 def enum_base(self):

18978 return self.getTypedRuleContext(CSharpParser.Enum_baseContext,0)

18979

18980

18981 def SEMICOLON(self):

18982 return self.getToken(CSharpParser.SEMICOLON, 0)

18983

18984 def getRuleIndex(self):

18985 return CSharpParser.RULE_enum_definition

18986

18987 def enterRule(self, listener:ParseTreeListener):

18988 if hasattr( listener, "enterEnum_definition" ):

18989 listener.enterEnum_definition(self)

18990

18991 def exitRule(self, listener:ParseTreeListener):

18992 if hasattr( listener, "exitEnum_definition" ):

18993 listener.exitEnum_definition(self)

18998 def enum_definition(self):

18999

19000 localctx = CSharpParser.Enum_definitionContext(self, self._ctx, self.state)

19001 self.enterRule(localctx, 404, self.RULE_enum_definition)

19002 self._la = 0 # Token type

19003 try:

19004 self.enterOuterAlt(localctx, 1)

19005 self.state = 2471

19006 self.match(CSharpParser.ENUM)

19007 self.state = 2472

19008 self.identifier()

19009 self.state = 2474

19010 self._errHandler.sync(self)

19011 _la = self._input.LA(1)

19012 if _la==CSharpParser.COLON:

19013 self.state = 2473

19014 self.enum_base()

19015

19016

19017 self.state = 2476

19018 self.enum_body()

19019 self.state = 2478

19020 self._errHandler.sync(self)

19021 _la = self._input.LA(1)

19022 if _la==CSharpParser.SEMICOLON:

19023 self.state = 2477

19024 self.match(CSharpParser.SEMICOLON)

19025

19026

19027 except RecognitionException as re:

19028 localctx.exception = re

19029 self._errHandler.reportError(self, re)

19030 self._errHandler.recover(self, re)

19031 finally:

19032 self.exitRule()

19033 return localctx

19034

19035

19036 class Delegate_definitionContext(ParserRuleContext):

19037 __slots__ = 'parser'

19038

19039 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

19040 super().__init__(parent, invokingState)

19041 self.parser = parser

19042

19043 def DELEGATE(self):

19044 return self.getToken(CSharpParser.DELEGATE, 0)

19045

19046 def return_type(self):

19047 return self.getTypedRuleContext(CSharpParser.Return_typeContext,0)

19048

19049

19050 def identifier(self):

19051 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

19052

19053

19054 def OPEN_PARENS(self):

19055 return self.getToken(CSharpParser.OPEN_PARENS, 0)

19056

19057 def CLOSE_PARENS(self):

19058 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

19059

19060 def SEMICOLON(self):

19061 return self.getToken(CSharpParser.SEMICOLON, 0)

19062

19063 def variant_type_parameter_list(self):

19064 return self.getTypedRuleContext(CSharpParser.Variant_type_parameter_listContext,0)

19065

19066

19067 def formal_parameter_list(self):

19068 return self.getTypedRuleContext(CSharpParser.Formal_parameter_listContext,0)

19069

19070

19071 def type_parameter_constraints_clauses(self):

19072 return self.getTypedRuleContext(CSharpParser.Type_parameter_constraints_clausesContext,0)

19073

19074

19075 def getRuleIndex(self):

19076 return CSharpParser.RULE_delegate_definition

19077

19078 def enterRule(self, listener:ParseTreeListener):

19079 if hasattr( listener, "enterDelegate_definition" ):

19080 listener.enterDelegate_definition(self)

19081

19082 def exitRule(self, listener:ParseTreeListener):

19083 if hasattr( listener, "exitDelegate_definition" ):

19084 listener.exitDelegate_definition(self)

19089 def delegate_definition(self):

19090

19091 localctx = CSharpParser.Delegate_definitionContext(self, self._ctx, self.state)

19092 self.enterRule(localctx, 406, self.RULE_delegate_definition)

19093 self._la = 0 # Token type

19094 try:

19095 self.enterOuterAlt(localctx, 1)

19096 self.state = 2480

19097 self.match(CSharpParser.DELEGATE)

19098 self.state = 2481

19099 self.return_type()

19100 self.state = 2482

19101 self.identifier()

19102 self.state = 2484

19103 self._errHandler.sync(self)

19104 _la = self._input.LA(1)

19105 if _la==CSharpParser.LT:

19106 self.state = 2483

19107 self.variant_type_parameter_list()

19108

19109

19110 self.state = 2486

19111 self.match(CSharpParser.OPEN_PARENS)

19112 self.state = 2488

19113 self._errHandler.sync(self)

19114 _la = self._input.LA(1)

19116 self.state = 2487

19117 self.formal_parameter_list()

19118

19119

19120 self.state = 2490

19121 self.match(CSharpParser.CLOSE_PARENS)

19122 self.state = 2492

19123 self._errHandler.sync(self)

19124 _la = self._input.LA(1)

19125 if _la==CSharpParser.WHERE:

19126 self.state = 2491

19127 self.type_parameter_constraints_clauses()

19128

19129

19130 self.state = 2494

19131 self.match(CSharpParser.SEMICOLON)

19132 except RecognitionException as re:

19133 localctx.exception = re

19134 self._errHandler.reportError(self, re)

19135 self._errHandler.recover(self, re)

19136 finally:

19137 self.exitRule()

19138 return localctx

19139

19140

19141 class Event_declarationContext(ParserRuleContext):

19142 __slots__ = 'parser'

19143

19144 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

19145 super().__init__(parent, invokingState)

19146 self.parser = parser

19147

19148 def EVENT(self):

19149 return self.getToken(CSharpParser.EVENT, 0)

19150

19151 def type_(self):

19152 return self.getTypedRuleContext(CSharpParser.Type_Context,0)

19153

19154

19155 def variable_declarators(self):

19156 return self.getTypedRuleContext(CSharpParser.Variable_declaratorsContext,0)

19157

19158

19159 def SEMICOLON(self):

19160 return self.getToken(CSharpParser.SEMICOLON, 0)

19161

19162 def member_name(self):

19163 return self.getTypedRuleContext(CSharpParser.Member_nameContext,0)

19164

19165

19166 def OPEN_BRACE(self):

19167 return self.getToken(CSharpParser.OPEN_BRACE, 0)

19168

19169 def event_accessor_declarations(self):

19170 return self.getTypedRuleContext(CSharpParser.Event_accessor_declarationsContext,0)

19171

19172

19173 def CLOSE_BRACE(self):

19174 return self.getToken(CSharpParser.CLOSE_BRACE, 0)

19175

19176 def getRuleIndex(self):

19177 return CSharpParser.RULE_event_declaration

19178

19179 def enterRule(self, listener:ParseTreeListener):

19180 if hasattr( listener, "enterEvent_declaration" ):

19181 listener.enterEvent_declaration(self)

19182

19183 def exitRule(self, listener:ParseTreeListener):

19184 if hasattr( listener, "exitEvent_declaration" ):

19185 listener.exitEvent_declaration(self)

19190 def event_declaration(self):

19191

19192 localctx = CSharpParser.Event_declarationContext(self, self._ctx, self.state)

19193 self.enterRule(localctx, 408, self.RULE_event_declaration)

19194 try:

19195 self.enterOuterAlt(localctx, 1)

19196 self.state = 2496

19197 self.match(CSharpParser.EVENT)

19198 self.state = 2497

19199 self.type_()

19200 self.state = 2506

19201 self._errHandler.sync(self)

19202 la_ = self._interp.adaptivePredict(self._input,323,self._ctx)

19203 if la_ == 1:

19204 self.state = 2498

19205 self.variable_declarators()

19206 self.state = 2499

19207 self.match(CSharpParser.SEMICOLON)

19208 pass

19209

19210 elif la_ == 2:

19211 self.state = 2501

19212 self.member_name()

19213 self.state = 2502

19214 self.match(CSharpParser.OPEN_BRACE)

19215 self.state = 2503

19216 self.event_accessor_declarations()

19217 self.state = 2504

19218 self.match(CSharpParser.CLOSE_BRACE)

19219 pass

19220

19221

19222 except RecognitionException as re:

19223 localctx.exception = re

19224 self._errHandler.reportError(self, re)

19225 self._errHandler.recover(self, re)

19226 finally:

19227 self.exitRule()

19228 return localctx

19229

19230

19231 class Field_declarationContext(ParserRuleContext):

19232 __slots__ = 'parser'

19233

19234 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

19235 super().__init__(parent, invokingState)

19236 self.parser = parser

19237

19238 def variable_declarators(self):

19239 return self.getTypedRuleContext(CSharpParser.Variable_declaratorsContext,0)

19240

19241

19242 def SEMICOLON(self):

19243 return self.getToken(CSharpParser.SEMICOLON, 0)

19244

19245 def getRuleIndex(self):

19246 return CSharpParser.RULE_field_declaration

19247

19248 def enterRule(self, listener:ParseTreeListener):

19249 if hasattr( listener, "enterField_declaration" ):

19250 listener.enterField_declaration(self)

19251

19252 def exitRule(self, listener:ParseTreeListener):

19253 if hasattr( listener, "exitField_declaration" ):

19254 listener.exitField_declaration(self)

19259 def field_declaration(self):

19260

19261 localctx = CSharpParser.Field_declarationContext(self, self._ctx, self.state)

19262 self.enterRule(localctx, 410, self.RULE_field_declaration)

19263 try:

19264 self.enterOuterAlt(localctx, 1)

19265 self.state = 2508

19266 self.variable_declarators()

19267 self.state = 2509

19268 self.match(CSharpParser.SEMICOLON)

19269 except RecognitionException as re:

19270 localctx.exception = re

19271 self._errHandler.reportError(self, re)

19272 self._errHandler.recover(self, re)

19273 finally:

19274 self.exitRule()

19275 return localctx

19276

19277

19278 class Property_declarationContext(ParserRuleContext):

19279 __slots__ = 'parser'

19280

19281 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

19282 super().__init__(parent, invokingState)

19283 self.parser = parser

19284

19285 def member_name(self):

19286 return self.getTypedRuleContext(CSharpParser.Member_nameContext,0)

19287

19288

19289 def OPEN_BRACE(self):

19290 return self.getToken(CSharpParser.OPEN_BRACE, 0)

19291

19292 def accessor_declarations(self):

19293 return self.getTypedRuleContext(CSharpParser.Accessor_declarationsContext,0)

19294

19295

19296 def CLOSE_BRACE(self):

19297 return self.getToken(CSharpParser.CLOSE_BRACE, 0)

19298

19299 def right_arrow(self):

19300 return self.getTypedRuleContext(CSharpParser.Right_arrowContext,0)

19301

19302

19303 def throwable_expression(self):

19304 return self.getTypedRuleContext(CSharpParser.Throwable_expressionContext,0)

19305

19306

19307 def SEMICOLON(self):

19308 return self.getToken(CSharpParser.SEMICOLON, 0)

19309

19310 def ASSIGNMENT(self):

19311 return self.getToken(CSharpParser.ASSIGNMENT, 0)

19312

19313 def variable_initializer(self):

19314 return self.getTypedRuleContext(CSharpParser.Variable_initializerContext,0)

19315

19316

19317 def getRuleIndex(self):

19318 return CSharpParser.RULE_property_declaration

19319

19320 def enterRule(self, listener:ParseTreeListener):

19321 if hasattr( listener, "enterProperty_declaration" ):

19322 listener.enterProperty_declaration(self)

19323

19324 def exitRule(self, listener:ParseTreeListener):

19325 if hasattr( listener, "exitProperty_declaration" ):

19326 listener.exitProperty_declaration(self)

19331 def property_declaration(self):

19332

19333 localctx = CSharpParser.Property_declarationContext(self, self._ctx, self.state)

19334 self.enterRule(localctx, 412, self.RULE_property_declaration)

19335 self._la = 0 # Token type

19336 try:

19337 self.enterOuterAlt(localctx, 1)

19338 self.state = 2511

19339 self.member_name()

19340 self.state = 2525

19341 self._errHandler.sync(self)

19342 token = self._input.LA(1)

19343 if token in [CSharpParser.OPEN_BRACE]:

19344 self.state = 2512

19345 self.match(CSharpParser.OPEN_BRACE)

19346 self.state = 2513

19347 self.accessor_declarations()

19348 self.state = 2514

19349 self.match(CSharpParser.CLOSE_BRACE)

19350 self.state = 2519

19351 self._errHandler.sync(self)

19352 _la = self._input.LA(1)

19353 if _la==CSharpParser.ASSIGNMENT:

19354 self.state = 2515

19355 self.match(CSharpParser.ASSIGNMENT)

19356 self.state = 2516

19357 self.variable_initializer()

19358 self.state = 2517

19359 self.match(CSharpParser.SEMICOLON)

19360

19361

19362 pass

19363 elif token in [CSharpParser.ASSIGNMENT]:

19364 self.state = 2521

19365 self.right_arrow()

19366 self.state = 2522

19367 self.throwable_expression()

19368 self.state = 2523

19369 self.match(CSharpParser.SEMICOLON)

19370 pass

19371 else:

19372 raise NoViableAltException(self)

19373

19374 except RecognitionException as re:

19375 localctx.exception = re

19376 self._errHandler.reportError(self, re)

19377 self._errHandler.recover(self, re)

19378 finally:

19379 self.exitRule()

19380 return localctx

19381

19382

19383 class Constant_declarationContext(ParserRuleContext):

19384 __slots__ = 'parser'

19385

19386 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

19387 super().__init__(parent, invokingState)

19388 self.parser = parser

19389

19390 def CONST(self):

19391 return self.getToken(CSharpParser.CONST, 0)

19392

19393 def type_(self):

19394 return self.getTypedRuleContext(CSharpParser.Type_Context,0)

19395

19396

19397 def constant_declarators(self):

19398 return self.getTypedRuleContext(CSharpParser.Constant_declaratorsContext,0)

19399

19400

19401 def SEMICOLON(self):

19402 return self.getToken(CSharpParser.SEMICOLON, 0)

19403

19404 def getRuleIndex(self):

19405 return CSharpParser.RULE_constant_declaration

19406

19407 def enterRule(self, listener:ParseTreeListener):

19408 if hasattr( listener, "enterConstant_declaration" ):

19409 listener.enterConstant_declaration(self)

19410

19411 def exitRule(self, listener:ParseTreeListener):

19412 if hasattr( listener, "exitConstant_declaration" ):

19413 listener.exitConstant_declaration(self)

19418 def constant_declaration(self):

19419

19420 localctx = CSharpParser.Constant_declarationContext(self, self._ctx, self.state)

19421 self.enterRule(localctx, 414, self.RULE_constant_declaration)

19422 try:

19423 self.enterOuterAlt(localctx, 1)

19424 self.state = 2527

19425 self.match(CSharpParser.CONST)

19426 self.state = 2528

19427 self.type_()

19428 self.state = 2529

19429 self.constant_declarators()

19430 self.state = 2530

19431 self.match(CSharpParser.SEMICOLON)

19432 except RecognitionException as re:

19433 localctx.exception = re

19434 self._errHandler.reportError(self, re)

19435 self._errHandler.recover(self, re)

19436 finally:

19437 self.exitRule()

19438 return localctx

19439

19440

19441 class Indexer_declarationContext(ParserRuleContext):

19442 __slots__ = 'parser'

19443

19444 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

19445 super().__init__(parent, invokingState)

19446 self.parser = parser

19447

19448 def THIS(self):

19449 return self.getToken(CSharpParser.THIS, 0)

19450

19451 def OPEN_BRACKET(self):

19452 return self.getToken(CSharpParser.OPEN_BRACKET, 0)

19453

19454 def formal_parameter_list(self):

19455 return self.getTypedRuleContext(CSharpParser.Formal_parameter_listContext,0)

19456

19457

19458 def CLOSE_BRACKET(self):

19459 return self.getToken(CSharpParser.CLOSE_BRACKET, 0)

19460

19461 def OPEN_BRACE(self):

19462 return self.getToken(CSharpParser.OPEN_BRACE, 0)

19463

19464 def accessor_declarations(self):

19465 return self.getTypedRuleContext(CSharpParser.Accessor_declarationsContext,0)

19466

19467

19468 def CLOSE_BRACE(self):

19469 return self.getToken(CSharpParser.CLOSE_BRACE, 0)

19470

19471 def right_arrow(self):

19472 return self.getTypedRuleContext(CSharpParser.Right_arrowContext,0)

19473

19474

19475 def throwable_expression(self):

19476 return self.getTypedRuleContext(CSharpParser.Throwable_expressionContext,0)

19477

19478

19479 def SEMICOLON(self):

19480 return self.getToken(CSharpParser.SEMICOLON, 0)

19481

19482 def getRuleIndex(self):

19483 return CSharpParser.RULE_indexer_declaration

19484

19485 def enterRule(self, listener:ParseTreeListener):

19486 if hasattr( listener, "enterIndexer_declaration" ):

19487 listener.enterIndexer_declaration(self)

19488

19489 def exitRule(self, listener:ParseTreeListener):

19490 if hasattr( listener, "exitIndexer_declaration" ):

19491 listener.exitIndexer_declaration(self)

19496 def indexer_declaration(self):

19497

19498 localctx = CSharpParser.Indexer_declarationContext(self, self._ctx, self.state)

19499 self.enterRule(localctx, 416, self.RULE_indexer_declaration)

19500 try:

19501 self.enterOuterAlt(localctx, 1)

19502 self.state = 2532

19503 self.match(CSharpParser.THIS)

19504 self.state = 2533

19505 self.match(CSharpParser.OPEN_BRACKET)

19506 self.state = 2534

19507 self.formal_parameter_list()

19508 self.state = 2535

19509 self.match(CSharpParser.CLOSE_BRACKET)

19510 self.state = 2544

19511 self._errHandler.sync(self)

19512 token = self._input.LA(1)

19513 if token in [CSharpParser.OPEN_BRACE]:

19514 self.state = 2536

19515 self.match(CSharpParser.OPEN_BRACE)

19516 self.state = 2537

19517 self.accessor_declarations()

19518 self.state = 2538

19519 self.match(CSharpParser.CLOSE_BRACE)

19520 pass

19521 elif token in [CSharpParser.ASSIGNMENT]:

19522 self.state = 2540

19523 self.right_arrow()

19524 self.state = 2541

19525 self.throwable_expression()

19526 self.state = 2542

19527 self.match(CSharpParser.SEMICOLON)

19528 pass

19529 else:

19530 raise NoViableAltException(self)

19531

19532 except RecognitionException as re:

19533 localctx.exception = re

19534 self._errHandler.reportError(self, re)

19535 self._errHandler.recover(self, re)

19536 finally:

19537 self.exitRule()

19538 return localctx

19539

19540

19541 class Destructor_definitionContext(ParserRuleContext):

19542 __slots__ = 'parser'

19543

19544 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

19545 super().__init__(parent, invokingState)

19546 self.parser = parser

19547

19548 def TILDE(self):

19549 return self.getToken(CSharpParser.TILDE, 0)

19550

19551 def identifier(self):

19552 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

19553

19554

19555 def OPEN_PARENS(self):

19556 return self.getToken(CSharpParser.OPEN_PARENS, 0)

19557

19558 def CLOSE_PARENS(self):

19559 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

19560

19561 def body(self):

19562 return self.getTypedRuleContext(CSharpParser.BodyContext,0)

19563

19564

19565 def getRuleIndex(self):

19566 return CSharpParser.RULE_destructor_definition

19567

19568 def enterRule(self, listener:ParseTreeListener):

19569 if hasattr( listener, "enterDestructor_definition" ):

19570 listener.enterDestructor_definition(self)

19571

19572 def exitRule(self, listener:ParseTreeListener):

19573 if hasattr( listener, "exitDestructor_definition" ):

19574 listener.exitDestructor_definition(self)

19579 def destructor_definition(self):

19580

19581 localctx = CSharpParser.Destructor_definitionContext(self, self._ctx, self.state)

19582 self.enterRule(localctx, 418, self.RULE_destructor_definition)

19583 try:

19584 self.enterOuterAlt(localctx, 1)

19585 self.state = 2546

19586 self.match(CSharpParser.TILDE)

19587 self.state = 2547

19588 self.identifier()

19589 self.state = 2548

19590 self.match(CSharpParser.OPEN_PARENS)

19591 self.state = 2549

19592 self.match(CSharpParser.CLOSE_PARENS)

19593 self.state = 2550

19594 self.body()

19595 except RecognitionException as re:

19596 localctx.exception = re

19597 self._errHandler.reportError(self, re)

19598 self._errHandler.recover(self, re)

19599 finally:

19600 self.exitRule()

19601 return localctx

19602

19603

19604 class Constructor_declarationContext(ParserRuleContext):

19605 __slots__ = 'parser'

19606

19607 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

19608 super().__init__(parent, invokingState)

19609 self.parser = parser

19610

19611 def identifier(self):

19612 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

19613

19614

19615 def OPEN_PARENS(self):

19616 return self.getToken(CSharpParser.OPEN_PARENS, 0)

19617

19618 def CLOSE_PARENS(self):

19619 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

19620

19621 def body(self):

19622 return self.getTypedRuleContext(CSharpParser.BodyContext,0)

19623

19624

19625 def formal_parameter_list(self):

19626 return self.getTypedRuleContext(CSharpParser.Formal_parameter_listContext,0)

19627

19628

19629 def constructor_initializer(self):

19630 return self.getTypedRuleContext(CSharpParser.Constructor_initializerContext,0)

19631

19632

19633 def getRuleIndex(self):

19634 return CSharpParser.RULE_constructor_declaration

19635

19636 def enterRule(self, listener:ParseTreeListener):

19637 if hasattr( listener, "enterConstructor_declaration" ):

19638 listener.enterConstructor_declaration(self)

19639

19640 def exitRule(self, listener:ParseTreeListener):

19641 if hasattr( listener, "exitConstructor_declaration" ):

19642 listener.exitConstructor_declaration(self)

19647 def constructor_declaration(self):

19648

19649 localctx = CSharpParser.Constructor_declarationContext(self, self._ctx, self.state)

19650 self.enterRule(localctx, 420, self.RULE_constructor_declaration)

19651 self._la = 0 # Token type

19652 try:

19653 self.enterOuterAlt(localctx, 1)

19654 self.state = 2552

19655 self.identifier()

19656 self.state = 2553

19657 self.match(CSharpParser.OPEN_PARENS)

19658 self.state = 2555

19659 self._errHandler.sync(self)

19660 _la = self._input.LA(1)

19662 self.state = 2554

19663 self.formal_parameter_list()

19664

19665

19666 self.state = 2557

19667 self.match(CSharpParser.CLOSE_PARENS)

19668 self.state = 2559

19669 self._errHandler.sync(self)

19670 _la = self._input.LA(1)

19671 if _la==CSharpParser.COLON:

19672 self.state = 2558

19673 self.constructor_initializer()

19674

19675

19676 self.state = 2561

19677 self.body()

19678 except RecognitionException as re:

19679 localctx.exception = re

19680 self._errHandler.reportError(self, re)

19681 self._errHandler.recover(self, re)

19682 finally:

19683 self.exitRule()

19684 return localctx

19685

19686

19687 class Method_declarationContext(ParserRuleContext):

19688 __slots__ = 'parser'

19689

19690 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

19691 super().__init__(parent, invokingState)

19692 self.parser = parser

19693

19694 def method_member_name(self):

19695 return self.getTypedRuleContext(CSharpParser.Method_member_nameContext,0)

19696

19697

19698 def OPEN_PARENS(self):

19699 return self.getToken(CSharpParser.OPEN_PARENS, 0)

19700

19701 def CLOSE_PARENS(self):

19702 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

19703

19704 def method_body(self):

19705 return self.getTypedRuleContext(CSharpParser.Method_bodyContext,0)

19706

19707

19708 def right_arrow(self):

19709 return self.getTypedRuleContext(CSharpParser.Right_arrowContext,0)

19710

19711

19712 def throwable_expression(self):

19713 return self.getTypedRuleContext(CSharpParser.Throwable_expressionContext,0)

19714

19715

19716 def SEMICOLON(self):

19717 return self.getToken(CSharpParser.SEMICOLON, 0)

19718

19719 def type_parameter_list(self):

19720 return self.getTypedRuleContext(CSharpParser.Type_parameter_listContext,0)

19721

19722

19723 def formal_parameter_list(self):

19724 return self.getTypedRuleContext(CSharpParser.Formal_parameter_listContext,0)

19725

19726

19727 def type_parameter_constraints_clauses(self):

19728 return self.getTypedRuleContext(CSharpParser.Type_parameter_constraints_clausesContext,0)

19729

19730

19731 def getRuleIndex(self):

19732 return CSharpParser.RULE_method_declaration

19733

19734 def enterRule(self, listener:ParseTreeListener):

19735 if hasattr( listener, "enterMethod_declaration" ):

19736 listener.enterMethod_declaration(self)

19737

19738 def exitRule(self, listener:ParseTreeListener):

19739 if hasattr( listener, "exitMethod_declaration" ):

19740 listener.exitMethod_declaration(self)

19745 def method_declaration(self):

19746

19747 localctx = CSharpParser.Method_declarationContext(self, self._ctx, self.state)

19748 self.enterRule(localctx, 422, self.RULE_method_declaration)

19749 self._la = 0 # Token type

19750 try:

19751 self.enterOuterAlt(localctx, 1)

19752 self.state = 2563

19753 self.method_member_name()

19754 self.state = 2565

19755 self._errHandler.sync(self)

19756 _la = self._input.LA(1)

19757 if _la==CSharpParser.LT:

19758 self.state = 2564

19759 self.type_parameter_list()

19760

19761

19762 self.state = 2567

19763 self.match(CSharpParser.OPEN_PARENS)

19764 self.state = 2569

19765 self._errHandler.sync(self)

19766 _la = self._input.LA(1)

19768 self.state = 2568

19769 self.formal_parameter_list()

19770

19771

19772 self.state = 2571

19773 self.match(CSharpParser.CLOSE_PARENS)

19774 self.state = 2573

19775 self._errHandler.sync(self)

19776 _la = self._input.LA(1)

19777 if _la==CSharpParser.WHERE:

19778 self.state = 2572

19779 self.type_parameter_constraints_clauses()

19780

19781

19782 self.state = 2580

19783 self._errHandler.sync(self)

19784 token = self._input.LA(1)

19785 if token in [CSharpParser.OPEN_BRACE, CSharpParser.SEMICOLON]:

19786 self.state = 2575

19787 self.method_body()

19788 pass

19789 elif token in [CSharpParser.ASSIGNMENT]:

19790 self.state = 2576

19791 self.right_arrow()

19792 self.state = 2577

19793 self.throwable_expression()

19794 self.state = 2578

19795 self.match(CSharpParser.SEMICOLON)

19796 pass

19797 else:

19798 raise NoViableAltException(self)

19799

19800 except RecognitionException as re:

19801 localctx.exception = re

19802 self._errHandler.reportError(self, re)

19803 self._errHandler.recover(self, re)

19804 finally:

19805 self.exitRule()

19806 return localctx

19807

19808

19809 class Method_member_nameContext(ParserRuleContext):

19810 __slots__ = 'parser'

19811

19812 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

19813 super().__init__(parent, invokingState)

19814 self.parser = parser

19815

19816 def identifier(self, i:int=None):

19817 if i is None:

19818 return self.getTypedRuleContexts(CSharpParser.IdentifierContext)

19819 else:

19820 return self.getTypedRuleContext(CSharpParser.IdentifierContext,i)

19821

19822

19823 def DOUBLE_COLON(self):

19824 return self.getToken(CSharpParser.DOUBLE_COLON, 0)

19825

19826 def DOT(self, i:int=None):

19827 if i is None:

19828 return self.getTokens(CSharpParser.DOT)

19829 else:

19830 return self.getToken(CSharpParser.DOT, i)

19831

19832 def type_argument_list(self, i:int=None):

19833 if i is None:

19834 return self.getTypedRuleContexts(CSharpParser.Type_argument_listContext)

19835 else:

19836 return self.getTypedRuleContext(CSharpParser.Type_argument_listContext,i)

19837

19838

19839 def getRuleIndex(self):

19840 return CSharpParser.RULE_method_member_name

19841

19842 def enterRule(self, listener:ParseTreeListener):

19843 if hasattr( listener, "enterMethod_member_name" ):

19844 listener.enterMethod_member_name(self)

19845

19846 def exitRule(self, listener:ParseTreeListener):

19847 if hasattr( listener, "exitMethod_member_name" ):

19848 listener.exitMethod_member_name(self)

19853 def method_member_name(self):

19854

19855 localctx = CSharpParser.Method_member_nameContext(self, self._ctx, self.state)

19856 self.enterRule(localctx, 424, self.RULE_method_member_name)

19857 self._la = 0 # Token type

19858 try:

19859 self.enterOuterAlt(localctx, 1)

19860 self.state = 2587

19861 self._errHandler.sync(self)

19862 la_ = self._interp.adaptivePredict(self._input,333,self._ctx)

19863 if la_ == 1:

19864 self.state = 2582

19865 self.identifier()

19866 pass

19867

19868 elif la_ == 2:

19869 self.state = 2583

19870 self.identifier()

19871 self.state = 2584

19872 self.match(CSharpParser.DOUBLE_COLON)

19873 self.state = 2585

19874 self.identifier()

19875 pass

19876

19877

19878 self.state = 2596

19879 self._errHandler.sync(self)

19880 _alt = self._interp.adaptivePredict(self._input,335,self._ctx)

19881 while _alt!=2 and _alt!=ATN.INVALID_ALT_NUMBER:

19882 if _alt==1:

19883 self.state = 2590

19884 self._errHandler.sync(self)

19885 _la = self._input.LA(1)

19886 if _la==CSharpParser.LT:

19887 self.state = 2589

19888 self.type_argument_list()

19889

19890

19891 self.state = 2592

19892 self.match(CSharpParser.DOT)

19893 self.state = 2593

19894 self.identifier()

19895 self.state = 2598

19896 self._errHandler.sync(self)

19897 _alt = self._interp.adaptivePredict(self._input,335,self._ctx)

19898

19899 except RecognitionException as re:

19900 localctx.exception = re

19901 self._errHandler.reportError(self, re)

19902 self._errHandler.recover(self, re)

19903 finally:

19904 self.exitRule()

19905 return localctx

19906

19907

19908 class Operator_declarationContext(ParserRuleContext):

19909 __slots__ = 'parser'

19910

19911 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

19912 super().__init__(parent, invokingState)

19913 self.parser = parser

19914

19915 def OPERATOR(self):

19916 return self.getToken(CSharpParser.OPERATOR, 0)

19917

19918 def overloadable_operator(self):

19919 return self.getTypedRuleContext(CSharpParser.Overloadable_operatorContext,0)

19920

19921

19922 def OPEN_PARENS(self):

19923 return self.getToken(CSharpParser.OPEN_PARENS, 0)

19924

19925 def arg_declaration(self, i:int=None):

19926 if i is None:

19927 return self.getTypedRuleContexts(CSharpParser.Arg_declarationContext)

19928 else:

19929 return self.getTypedRuleContext(CSharpParser.Arg_declarationContext,i)

19930

19931

19932 def CLOSE_PARENS(self):

19933 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

19934

19935 def body(self):

19936 return self.getTypedRuleContext(CSharpParser.BodyContext,0)

19937

19938

19939 def right_arrow(self):

19940 return self.getTypedRuleContext(CSharpParser.Right_arrowContext,0)

19941

19942

19943 def throwable_expression(self):

19944 return self.getTypedRuleContext(CSharpParser.Throwable_expressionContext,0)

19945

19946

19947 def SEMICOLON(self):

19948 return self.getToken(CSharpParser.SEMICOLON, 0)

19949

19950 def IN(self, i:int=None):

19951 if i is None:

19952 return self.getTokens(CSharpParser.IN)

19953 else:

19954 return self.getToken(CSharpParser.IN, i)

19955

19956 def COMMA(self):

19957 return self.getToken(CSharpParser.COMMA, 0)

19958

19959 def getRuleIndex(self):

19960 return CSharpParser.RULE_operator_declaration

19961

19962 def enterRule(self, listener:ParseTreeListener):

19963 if hasattr( listener, "enterOperator_declaration" ):

19964 listener.enterOperator_declaration(self)

19965

19966 def exitRule(self, listener:ParseTreeListener):

19967 if hasattr( listener, "exitOperator_declaration" ):

19968 listener.exitOperator_declaration(self)

19973 def operator_declaration(self):

19974

19975 localctx = CSharpParser.Operator_declarationContext(self, self._ctx, self.state)

19976 self.enterRule(localctx, 426, self.RULE_operator_declaration)

19977 self._la = 0 # Token type

19978 try:

19979 self.enterOuterAlt(localctx, 1)

19980 self.state = 2599

19981 self.match(CSharpParser.OPERATOR)

19982 self.state = 2600

19983 self.overloadable_operator()

19984 self.state = 2601

19985 self.match(CSharpParser.OPEN_PARENS)

19986 self.state = 2603

19987 self._errHandler.sync(self)

19988 _la = self._input.LA(1)

19989 if _la==CSharpParser.IN:

19990 self.state = 2602

19991 self.match(CSharpParser.IN)

19992

19993

19994 self.state = 2605

19995 self.arg_declaration()

19996 self.state = 2611

19997 self._errHandler.sync(self)

19998 _la = self._input.LA(1)

19999 if _la==CSharpParser.COMMA:

20000 self.state = 2606

20001 self.match(CSharpParser.COMMA)

20002 self.state = 2608

20003 self._errHandler.sync(self)

20004 _la = self._input.LA(1)

20005 if _la==CSharpParser.IN:

20006 self.state = 2607

20007 self.match(CSharpParser.IN)

20008

20009

20010 self.state = 2610

20011 self.arg_declaration()

20012

20013

20014 self.state = 2613

20015 self.match(CSharpParser.CLOSE_PARENS)

20016 self.state = 2619

20017 self._errHandler.sync(self)

20018 token = self._input.LA(1)

20019 if token in [CSharpParser.OPEN_BRACE, CSharpParser.SEMICOLON]:

20020 self.state = 2614

20021 self.body()

20022 pass

20023 elif token in [CSharpParser.ASSIGNMENT]:

20024 self.state = 2615

20025 self.right_arrow()

20026 self.state = 2616

20027 self.throwable_expression()

20028 self.state = 2617

20029 self.match(CSharpParser.SEMICOLON)

20030 pass

20031 else:

20032 raise NoViableAltException(self)

20033

20034 except RecognitionException as re:

20035 localctx.exception = re

20036 self._errHandler.reportError(self, re)

20037 self._errHandler.recover(self, re)

20038 finally:

20039 self.exitRule()

20040 return localctx

20041

20042

20043 class Arg_declarationContext(ParserRuleContext):

20044 __slots__ = 'parser'

20045

20046 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

20047 super().__init__(parent, invokingState)

20048 self.parser = parser

20049

20050 def type_(self):

20051 return self.getTypedRuleContext(CSharpParser.Type_Context,0)

20052

20053

20054 def identifier(self):

20055 return self.getTypedRuleContext(CSharpParser.IdentifierContext,0)

20056

20057

20058 def ASSIGNMENT(self):

20059 return self.getToken(CSharpParser.ASSIGNMENT, 0)

20060

20061 def expression(self):

20062 return self.getTypedRuleContext(CSharpParser.ExpressionContext,0)

20063

20064

20065 def getRuleIndex(self):

20066 return CSharpParser.RULE_arg_declaration

20067

20068 def enterRule(self, listener:ParseTreeListener):

20069 if hasattr( listener, "enterArg_declaration" ):

20070 listener.enterArg_declaration(self)

20071

20072 def exitRule(self, listener:ParseTreeListener):

20073 if hasattr( listener, "exitArg_declaration" ):

20074 listener.exitArg_declaration(self)

20079 def arg_declaration(self):

20080

20081 localctx = CSharpParser.Arg_declarationContext(self, self._ctx, self.state)

20082 self.enterRule(localctx, 428, self.RULE_arg_declaration)

20083 self._la = 0 # Token type

20084 try:

20085 self.enterOuterAlt(localctx, 1)

20086 self.state = 2621

20087 self.type_()

20088 self.state = 2622

20089 self.identifier()

20090 self.state = 2625

20091 self._errHandler.sync(self)

20092 _la = self._input.LA(1)

20093 if _la==CSharpParser.ASSIGNMENT:

20094 self.state = 2623

20095 self.match(CSharpParser.ASSIGNMENT)

20096 self.state = 2624

20097 self.expression()

20098

20099

20100 except RecognitionException as re:

20101 localctx.exception = re

20102 self._errHandler.reportError(self, re)

20103 self._errHandler.recover(self, re)

20104 finally:

20105 self.exitRule()

20106 return localctx

20107

20108

20109 class Method_invocationContext(ParserRuleContext):

20110 __slots__ = 'parser'

20111

20112 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

20113 super().__init__(parent, invokingState)

20114 self.parser = parser

20115

20116 def OPEN_PARENS(self):

20117 return self.getToken(CSharpParser.OPEN_PARENS, 0)

20118

20119 def CLOSE_PARENS(self):

20120 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

20121

20122 def argument_list(self):

20123 return self.getTypedRuleContext(CSharpParser.Argument_listContext,0)

20124

20125

20126 def getRuleIndex(self):

20127 return CSharpParser.RULE_method_invocation

20128

20129 def enterRule(self, listener:ParseTreeListener):

20130 if hasattr( listener, "enterMethod_invocation" ):

20131 listener.enterMethod_invocation(self)

20132

20133 def exitRule(self, listener:ParseTreeListener):

20134 if hasattr( listener, "exitMethod_invocation" ):

20135 listener.exitMethod_invocation(self)

20140 def method_invocation(self):

20141

20142 localctx = CSharpParser.Method_invocationContext(self, self._ctx, self.state)

20143 self.enterRule(localctx, 430, self.RULE_method_invocation)

20144 self._la = 0 # Token type

20145 try:

20146 self.enterOuterAlt(localctx, 1)

20147 self.state = 2627

20148 self.match(CSharpParser.OPEN_PARENS)

20149 self.state = 2629

20150 self._errHandler.sync(self)

20151 _la = self._input.LA(1)

20153 self.state = 2628

20154 self.argument_list()

20155

20156

20157 self.state = 2631

20158 self.match(CSharpParser.CLOSE_PARENS)

20159 except RecognitionException as re:

20160 localctx.exception = re

20161 self._errHandler.reportError(self, re)

20162 self._errHandler.recover(self, re)

20163 finally:

20164 self.exitRule()

20165 return localctx

20166

20167

20168 class Object_creation_expressionContext(ParserRuleContext):

20169 __slots__ = 'parser'

20170

20171 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

20172 super().__init__(parent, invokingState)

20173 self.parser = parser

20174

20175 def OPEN_PARENS(self):

20176 return self.getToken(CSharpParser.OPEN_PARENS, 0)

20177

20178 def CLOSE_PARENS(self):

20179 return self.getToken(CSharpParser.CLOSE_PARENS, 0)

20180

20181 def argument_list(self):

20182 return self.getTypedRuleContext(CSharpParser.Argument_listContext,0)

20183

20184

20185 def object_or_collection_initializer(self):

20186 return self.getTypedRuleContext(CSharpParser.Object_or_collection_initializerContext,0)

20187

20188

20189 def getRuleIndex(self):

20190 return CSharpParser.RULE_object_creation_expression

20191

20192 def enterRule(self, listener:ParseTreeListener):

20193 if hasattr( listener, "enterObject_creation_expression" ):

20194 listener.enterObject_creation_expression(self)

20195

20196 def exitRule(self, listener:ParseTreeListener):

20197 if hasattr( listener, "exitObject_creation_expression" ):

20198 listener.exitObject_creation_expression(self)

20203 def object_creation_expression(self):

20204

20205 localctx = CSharpParser.Object_creation_expressionContext(self, self._ctx, self.state)

20206 self.enterRule(localctx, 432, self.RULE_object_creation_expression)

20207 self._la = 0 # Token type

20208 try:

20209 self.enterOuterAlt(localctx, 1)

20210 self.state = 2633

20211 self.match(CSharpParser.OPEN_PARENS)

20212 self.state = 2635

20213 self._errHandler.sync(self)

20214 _la = self._input.LA(1)

20216 self.state = 2634

20217 self.argument_list()

20218

20219

20220 self.state = 2637

20221 self.match(CSharpParser.CLOSE_PARENS)

20222 self.state = 2639

20223 self._errHandler.sync(self)

20224 la_ = self._interp.adaptivePredict(self._input,343,self._ctx)

20225 if la_ == 1:

20226 self.state = 2638

20227 self.object_or_collection_initializer()

20228

20229

20230 except RecognitionException as re:

20231 localctx.exception = re

20232 self._errHandler.reportError(self, re)

20233 self._errHandler.recover(self, re)

20234 finally:

20235 self.exitRule()

20236 return localctx

20237

20238

20239 class IdentifierContext(ParserRuleContext):

20240 __slots__ = 'parser'

20241

20242 def __init__(self, parser, parent:ParserRuleContext=None, invokingState:int=-1):

20243 super().__init__(parent, invokingState)

20244 self.parser = parser

20245

20246 def IDENTIFIER(self):

20247 return self.getToken(CSharpParser.IDENTIFIER, 0)

20248

20249 def ADD(self):

20250 return self.getToken(CSharpParser.ADD, 0)

20251

20252 def ALIAS(self):

20253 return self.getToken(CSharpParser.ALIAS, 0)

20254

20255 def ARGLIST(self):

20256 return self.getToken(CSharpParser.ARGLIST, 0)

20257

20258 def ASCENDING(self):

20259 return self.getToken(CSharpParser.ASCENDING, 0)

20260

20261 def ASYNC(self):

20262 return self.getToken(CSharpParser.ASYNC, 0)

20263

20264 def AWAIT(self):

20265 return self.getToken(CSharpParser.AWAIT, 0)

20266

20267 def BY(self):

20268 return self.getToken(CSharpParser.BY, 0)

20269

20270 def DESCENDING(self):

20271 return self.getToken(CSharpParser.DESCENDING, 0)

20272

20273 def DYNAMIC(self):

20274 return self.getToken(CSharpParser.DYNAMIC, 0)

20275

20276 def EQUALS(self):

20277 return self.getToken(CSharpParser.EQUALS, 0)

20278

20279 def FROM(self):

20280 return self.getToken(CSharpParser.FROM, 0)

20281

20282 def GET(self):

20283 return self.getToken(CSharpParser.GET, 0)

20284

20285 def GROUP(self):

20286 return self.getToken(CSharpParser.GROUP, 0)

20287

20288 def INTO(self):

20289 return self.getToken(CSharpParser.INTO, 0)

20290

20291 def JOIN(self):

20292 return self.getToken(CSharpParser.JOIN, 0)

20293

20294 def LET(self):

20295 return self.getToken(CSharpParser.LET, 0)

20296

20297 def NAMEOF(self):

20298 return self.getToken(CSharpParser.NAMEOF, 0)

20299

20300 def ON(self):

20301 return self.getToken(CSharpParser.ON, 0)

20302

20303 def ORDERBY(self):

20304 return self.getToken(CSharpParser.ORDERBY, 0)

20305

20306 def PARTIAL(self):

20307 return self.getToken(CSharpParser.PARTIAL, 0)

20308

20309 def REMOVE(self):

20310 return self.getToken(CSharpParser.REMOVE, 0)

20311

20312 def SELECT(self):

20313 return self.getToken(CSharpParser.SELECT, 0)

20314

20315 def SET(self):

20316 return self.getToken(CSharpParser.SET, 0)

20317

20318 def UNMANAGED(self):

20319 return self.getToken(CSharpParser.UNMANAGED, 0)

20320

20321 def VAR(self):

20322 return self.getToken(CSharpParser.VAR, 0)

20323

20324 def WHEN(self):

20325 return self.getToken(CSharpParser.WHEN, 0)

20326

20327 def WHERE(self):

20328 return self.getToken(CSharpParser.WHERE, 0)

20329

20330 def YIELD(self):

20331 return self.getToken(CSharpParser.YIELD, 0)

20332

20333 def getRuleIndex(self):

20334 return CSharpParser.RULE_identifier

20335

20336 def enterRule(self, listener:ParseTreeListener):

20337 if hasattr( listener, "enterIdentifier" ):

20338 listener.enterIdentifier(self)

20339

20340 def exitRule(self, listener:ParseTreeListener):

20341 if hasattr( listener, "exitIdentifier" ):

20342 listener.exitIdentifier(self)

20347 def identifier(self):

20348

20349 localctx = CSharpParser.IdentifierContext(self, self._ctx, self.state)

20350 self.enterRule(localctx, 434, self.RULE_identifier)

20351 self._la = 0 # Token type

20352 try:

20353 self.enterOuterAlt(localctx, 1)

20354 self.state = 2641

20355 _la = self._input.LA(1)

20357 self._errHandler.recoverInline(self)

20358 else:

20359 self._errHandler.reportMatch(self)

20360 self.consume()

20361 except RecognitionException as re:

20362 localctx.exception = re

20363 self._errHandler.reportError(self, re)

20364 self._errHandler.recover(self, re)

20365 finally:

20366 self.exitRule()

20367 return localctx

20368

20369

20370

20371 def sempred(self, localctx:RuleContext, ruleIndex:int, predIndex:int):

20372 if self._predicates == None:

20373 self._predicates = dict()

20374 self._predicates[86] = self.local_variable_declaration_sempred

20375 self._predicates[187] = self.right_arrow_sempred

20376 self._predicates[188] = self.right_shift_sempred

20377 self._predicates[189] = self.right_shift_assignment_sempred

20378 pred = self._predicates.get(ruleIndex, None)

20379 if pred is None:

20380 raise Exception("No predicate with index:" + str(ruleIndex))

20381 else:

20382 return pred(localctx, predIndex)

20383

20384 def local_variable_declaration_sempred(self, localctx:Local_variable_declarationContext, predIndex:int):

20385 if predIndex == 0:

20386 return this.IsLocalVariableDeclaration()

20387

20388

20389 def right_arrow_sempred(self, localctx:Right_arrowContext, predIndex:int):

20390 if predIndex == 1:

20391 return (0 if localctx.first is None else localctx.first.tokenIndex) + 1 == (0 if localctx.second is None else localctx.second.tokenIndex)

20392

20393

20394 def right_shift_sempred(self, localctx:Right_shiftContext, predIndex:int):

20395 if predIndex == 2:

20396 return (0 if localctx.first is None else localctx.first.tokenIndex) + 1 == (0 if localctx.second is None else localctx.second.tokenIndex)

20397

20398

20399 def right_shift_assignment_sempred(self, localctx:Right_shift_assignmentContext, predIndex:int):

20400 if predIndex == 3:

20401 return (0 if localctx.first is None else localctx.first.tokenIndex) + 1 == (0 if localctx.second is None else localctx.second.tokenIndex)